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.18 by gcodispo, Mon Dec 11 09:16:06 2006 UTC vs.
Revision 1.21 by gcodispo, Tue Feb 20 09:57:08 2007 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[0]
658	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[1]
659	<	#define  SWIGTYPE_p_XMLDoc swig_types[2]
657	>	#define  SWIGTYPE_p_XMLDoc swig_types[0]
658	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
659	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660		#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[3]
661		#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662	<	#define  SWIGTYPE_p_BossTask swig_types[5]
663	<	#define  SWIGTYPE_p_BossTaskException swig_types[6]
664	<	#define  SWIGTYPE_p_std__ostream swig_types[7]
665	<	#define  SWIGTYPE_p_BossAttributeContainer swig_types[8]
666	<	#define  SWIGTYPE_p_printOption swig_types[9]
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_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_BossTask__job_iterator swig_types[16]
674	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[17]
673	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[17]
675		#define  SWIGTYPE_p_jobStates swig_types[18]
676		static swig_type_info *swig_types[20];
677
#	Line 917 | Line 917 | void std_vectorlstd_string_g___delslice_
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 928 | Line 930 | void std_vectorlstd_string_g___delslice_
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 954 | Line 957 | PyObject *BossSession_schedulers(BossSes
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){
960	>	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout,bool keepfile){
961		std::vector<std::string> my_vec = self->listMatch( scheduler,
962		schclassad,
963		keepfile,
964		taskid,
965	<	jobid);
965	>	jobid,
966	>	timeout);
967		return BossSession_show( self, my_vec );
968		}
969	<	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,bool avoidCheck){
969	>	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,unsigned int timeout,bool avoidCheck){
970		if ( !avoidCheck ) {
971		self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
972	<	type, user, after, before);
972	>	type, user, after, before, timeout );
973		}
974		PyObject * job_dict = PyList_New(0);
975		std::vector <std::string>
#	Line 1086 | Line 1090 | static PyObject *_wrap_new_objectMap__SW
1090		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1091
1092		}catch (const BossSchedFailure & e) {
1093	<	SWIG_exception(SWIG_ValueError, e.what());
1093	>	PyErr_SetString ( SchedulerError, e.what() );
1094	>	return NULL;
1095		}catch (const std::exception& e) {
1096	<	SWIG_exception(SWIG_RuntimeError, e.what());
1096	>	PyErr_SetString ( BossError, e.what() );
1097	>	return NULL;
1098		}
1099		}
1100		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1147 | Line 1153 | static PyObject *_wrap_new_objectMap__SW
1153		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1154
1155		}catch (const BossSchedFailure & e) {
1156	<	SWIG_exception(SWIG_ValueError, e.what());
1156	>	PyErr_SetString ( SchedulerError, e.what() );
1157	>	return NULL;
1158		}catch (const std::exception& e) {
1159	<	SWIG_exception(SWIG_RuntimeError, e.what());
1159	>	PyErr_SetString ( BossError, e.what() );
1160	>	return NULL;
1161		}
1162		}
1163		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1264 | Line 1272 | static PyObject *_wrap_objectMap___len__
1272		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1273
1274		}catch (const BossSchedFailure & e) {
1275	<	SWIG_exception(SWIG_ValueError, e.what());
1275	>	PyErr_SetString ( SchedulerError, e.what() );
1276	>	return NULL;
1277		}catch (const std::exception& e) {
1278	<	SWIG_exception(SWIG_RuntimeError, e.what());
1278	>	PyErr_SetString ( BossError, e.what() );
1279	>	return NULL;
1280		}
1281		}
1282		resultobj = PyInt_FromLong((long)result);
#	Line 1288 | Line 1298 | static PyObject *_wrap_objectMap_clear(P
1298		(arg1)->clear();
1299
1300		}catch (const BossSchedFailure & e) {
1301	<	SWIG_exception(SWIG_ValueError, e.what());
1301	>	PyErr_SetString ( SchedulerError, e.what() );
1302	>	return NULL;
1303		}catch (const std::exception& e) {
1304	<	SWIG_exception(SWIG_RuntimeError, e.what());
1304	>	PyErr_SetString ( BossError, e.what() );
1305	>	return NULL;
1306		}
1307		}
1308		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1313 | Line 1325 | static PyObject *_wrap_objectMap___nonze
1325		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1326
1327		}catch (const BossSchedFailure & e) {
1328	<	SWIG_exception(SWIG_ValueError, e.what());
1328	>	PyErr_SetString ( SchedulerError, e.what() );
1329	>	return NULL;
1330		}catch (const std::exception& e) {
1331	<	SWIG_exception(SWIG_RuntimeError, e.what());
1331	>	PyErr_SetString ( BossError, e.what() );
1332	>	return NULL;
1333		}
1334		}
1335		resultobj = PyInt_FromLong((long)result);
#	Line 1387 | Line 1401 | static PyObject *_wrap_objectMap___setit
1401		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1402
1403		}catch (const BossSchedFailure & e) {
1404	<	SWIG_exception(SWIG_ValueError, e.what());
1404	>	PyErr_SetString ( SchedulerError, e.what() );
1405	>	return NULL;
1406		}catch (const std::exception& e) {
1407	<	SWIG_exception(SWIG_RuntimeError, e.what());
1407	>	PyErr_SetString ( BossError, e.what() );
1408	>	return NULL;
1409		}
1410		}
1411		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1451 | Line 1467 | static PyObject *_wrap_objectMap_has_key
1467		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1468
1469		}catch (const BossSchedFailure & e) {
1470	<	SWIG_exception(SWIG_ValueError, e.what());
1470	>	PyErr_SetString ( SchedulerError, e.what() );
1471	>	return NULL;
1472		}catch (const std::exception& e) {
1473	<	SWIG_exception(SWIG_RuntimeError, e.what());
1473	>	PyErr_SetString ( BossError, e.what() );
1474	>	return NULL;
1475		}
1476		}
1477		resultobj = PyInt_FromLong((long)result);
#	Line 1476 | Line 1494 | static PyObject *_wrap_objectMap_keys(Py
1494		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1495
1496		}catch (const BossSchedFailure & e) {
1497	<	SWIG_exception(SWIG_ValueError, e.what());
1497	>	PyErr_SetString ( SchedulerError, e.what() );
1498	>	return NULL;
1499		}catch (const std::exception& e) {
1500	<	SWIG_exception(SWIG_RuntimeError, e.what());
1500	>	PyErr_SetString ( BossError, e.what() );
1501	>	return NULL;
1502		}
1503		}
1504		resultobj = result;
#	Line 1501 | Line 1521 | static PyObject *_wrap_objectMap_values(
1521		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1522
1523		}catch (const BossSchedFailure & e) {
1524	<	SWIG_exception(SWIG_ValueError, e.what());
1524	>	PyErr_SetString ( SchedulerError, e.what() );
1525	>	return NULL;
1526		}catch (const std::exception& e) {
1527	<	SWIG_exception(SWIG_RuntimeError, e.what());
1527	>	PyErr_SetString ( BossError, e.what() );
1528	>	return NULL;
1529		}
1530		}
1531		resultobj = result;
#	Line 1526 | Line 1548 | static PyObject *_wrap_objectMap_items(P
1548		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1549
1550		}catch (const BossSchedFailure & e) {
1551	<	SWIG_exception(SWIG_ValueError, e.what());
1551	>	PyErr_SetString ( SchedulerError, e.what() );
1552	>	return NULL;
1553		}catch (const std::exception& e) {
1554	<	SWIG_exception(SWIG_RuntimeError, e.what());
1554	>	PyErr_SetString ( BossError, e.what() );
1555	>	return NULL;
1556		}
1557		}
1558		resultobj = result;
#	Line 1559 | Line 1583 | static PyObject *_wrap_objectMap___conta
1583		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1584
1585		}catch (const BossSchedFailure & e) {
1586	<	SWIG_exception(SWIG_ValueError, e.what());
1586	>	PyErr_SetString ( SchedulerError, e.what() );
1587	>	return NULL;
1588		}catch (const std::exception& e) {
1589	<	SWIG_exception(SWIG_RuntimeError, e.what());
1589	>	PyErr_SetString ( BossError, e.what() );
1590	>	return NULL;
1591		}
1592		}
1593		resultobj = PyInt_FromLong((long)result);
#	Line 1607 | Line 1633 | static PyObject *_wrap_delete_objectMap(
1633		delete arg1;
1634
1635		}catch (const BossSchedFailure & e) {
1636	<	SWIG_exception(SWIG_ValueError, e.what());
1636	>	PyErr_SetString ( SchedulerError, e.what() );
1637	>	return NULL;
1638		}catch (const std::exception& e) {
1639	<	SWIG_exception(SWIG_RuntimeError, e.what());
1639	>	PyErr_SetString ( BossError, e.what() );
1640	>	return NULL;
1641		}
1642		}
1643		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1642 | Line 1670 | static PyObject *_wrap_new_vector_string
1670		result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1671
1672		}catch (const BossSchedFailure & e) {
1673	<	SWIG_exception(SWIG_ValueError, e.what());
1673	>	PyErr_SetString ( SchedulerError, e.what() );
1674	>	return NULL;
1675		}catch (const std::exception& e) {
1676	<	SWIG_exception(SWIG_RuntimeError, e.what());
1676	>	PyErr_SetString ( BossError, e.what() );
1677	>	return NULL;
1678		}
1679		}
1680		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1679 | Line 1709 | static PyObject *_wrap_new_vector_string
1709		result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1710
1711		}catch (const BossSchedFailure & e) {
1712	<	SWIG_exception(SWIG_ValueError, e.what());
1712	>	PyErr_SetString ( SchedulerError, e.what() );
1713	>	return NULL;
1714		}catch (const std::exception& e) {
1715	<	SWIG_exception(SWIG_RuntimeError, e.what());
1715	>	PyErr_SetString ( BossError, e.what() );
1716	>	return NULL;
1717		}
1718		}
1719		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1733 | Line 1765 | static PyObject *_wrap_new_vector_string
1765		result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1766
1767		}catch (const BossSchedFailure & e) {
1768	<	SWIG_exception(SWIG_ValueError, e.what());
1768	>	PyErr_SetString ( SchedulerError, e.what() );
1769	>	return NULL;
1770		}catch (const std::exception& e) {
1771	<	SWIG_exception(SWIG_RuntimeError, e.what());
1771	>	PyErr_SetString ( BossError, e.what() );
1772	>	return NULL;
1773		}
1774		}
1775		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1862 | Line 1896 | static PyObject *_wrap_vector_string___l
1896		result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1897
1898		}catch (const BossSchedFailure & e) {
1899	<	SWIG_exception(SWIG_ValueError, e.what());
1899	>	PyErr_SetString ( SchedulerError, e.what() );
1900	>	return NULL;
1901		}catch (const std::exception& e) {
1902	<	SWIG_exception(SWIG_RuntimeError, e.what());
1902	>	PyErr_SetString ( BossError, e.what() );
1903	>	return NULL;
1904		}
1905		}
1906		resultobj = PyInt_FromLong((long)result);
#	Line 1916 | Line 1952 | static PyObject *_wrap_vector_string___n
1952		result = (bool)((std::vector<std::string > const *)arg1)->empty();
1953
1954		}catch (const BossSchedFailure & e) {
1955	<	SWIG_exception(SWIG_ValueError, e.what());
1955	>	PyErr_SetString ( SchedulerError, e.what() );
1956	>	return NULL;
1957		}catch (const std::exception& e) {
1958	<	SWIG_exception(SWIG_RuntimeError, e.what());
1958	>	PyErr_SetString ( BossError, e.what() );
1959	>	return NULL;
1960		}
1961		}
1962		resultobj = PyInt_FromLong((long)result);
#	Line 1940 | Line 1978 | static PyObject *_wrap_vector_string_cle
1978		(arg1)->clear();
1979
1980		}catch (const BossSchedFailure & e) {
1981	<	SWIG_exception(SWIG_ValueError, e.what());
1981	>	PyErr_SetString ( SchedulerError, e.what() );
1982	>	return NULL;
1983		}catch (const std::exception& e) {
1984	<	SWIG_exception(SWIG_RuntimeError, e.what());
1984	>	PyErr_SetString ( BossError, e.what() );
1985	>	return NULL;
1986		}
1987		}
1988		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1972 | Line 2012 | static PyObject *_wrap_vector_string_app
2012		(arg1)->push_back(arg2);
2013
2014		}catch (const BossSchedFailure & e) {
2015	<	SWIG_exception(SWIG_ValueError, e.what());
2015	>	PyErr_SetString ( SchedulerError, e.what() );
2016	>	return NULL;
2017		}catch (const std::exception& e) {
2018	<	SWIG_exception(SWIG_RuntimeError, e.what());
2018	>	PyErr_SetString ( BossError, e.what() );
2019	>	return NULL;
2020		}
2021		}
2022		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2050 | Line 2092 | static PyObject *_wrap_vector_string___g
2092		result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2093
2094		}catch (const BossSchedFailure & e) {
2095	<	SWIG_exception(SWIG_ValueError, e.what());
2095	>	PyErr_SetString ( SchedulerError, e.what() );
2096	>	return NULL;
2097		}catch (const std::exception& e) {
2098	<	SWIG_exception(SWIG_RuntimeError, e.what());
2098	>	PyErr_SetString ( BossError, e.what() );
2099	>	return NULL;
2100		}
2101		}
2102		{
#	Line 2144 | Line 2188 | static PyObject *_wrap_vector_string___s
2188		std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2189
2190		}catch (const BossSchedFailure & e) {
2191	<	SWIG_exception(SWIG_ValueError, e.what());
2191	>	PyErr_SetString ( SchedulerError, e.what() );
2192	>	return NULL;
2193		}catch (const std::exception& e) {
2194	<	SWIG_exception(SWIG_RuntimeError, e.what());
2194	>	PyErr_SetString ( BossError, e.what() );
2195	>	return NULL;
2196		}
2197		}
2198		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2193 | Line 2239 | static PyObject *_wrap_vector_string___d
2239		std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2240
2241		}catch (const BossSchedFailure & e) {
2242	<	SWIG_exception(SWIG_ValueError, e.what());
2242	>	PyErr_SetString ( SchedulerError, e.what() );
2243	>	return NULL;
2244		}catch (const std::exception& e) {
2245	<	SWIG_exception(SWIG_RuntimeError, e.what());
2245	>	PyErr_SetString ( BossError, e.what() );
2246	>	return NULL;
2247		}
2248		}
2249		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2217 | Line 2265 | static PyObject *_wrap_delete_vector_str
2265		delete arg1;
2266
2267		}catch (const BossSchedFailure & e) {
2268	<	SWIG_exception(SWIG_ValueError, e.what());
2268	>	PyErr_SetString ( SchedulerError, e.what() );
2269	>	return NULL;
2270		}catch (const std::exception& e) {
2271	<	SWIG_exception(SWIG_RuntimeError, e.what());
2271	>	PyErr_SetString ( BossError, e.what() );
2272	>	return NULL;
2273		}
2274		}
2275		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2236 | Line 2286 | static PyObject * vector_string_swigregi
2286		Py_INCREF(obj);
2287		return Py_BuildValue((char *)"");
2288		}
2289	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
2289	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2290		PyObject *resultobj;
2291	<	BossSession *arg1 = (BossSession *) 0 ;
2292	<	std::vector<std::string > *arg2 = 0 ;
2293	<	PyObject *result;
2291	>	std::string arg1 = (std::string) "" ;
2292	>	std::string arg2 = (std::string) "2" ;
2293	>	std::string arg3 = (std::string) "" ;
2294	>	std::string arg4 = (std::string) "" ;
2295	>	BossSession *result;
2296		PyObject * obj0 = 0 ;
2297		PyObject * obj1 = 0 ;
2298	+	PyObject * obj2 = 0 ;
2299	+	PyObject * obj3 = 0 ;
2300
2301	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2302	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2303	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2304	<	if (arg2 == NULL) {
2305	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2301	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2302	>	if (obj0) {
2303	>	{
2304	>	if (PyString_Check(obj0))
2305	>	arg1 = std::string(PyString_AsString(obj0));
2306	>	else
2307	>	SWIG_exception(SWIG_TypeError, "string expected");
2308	>	}
2309		}
2310	<	{
2311	<	try {
2312	<	result = (PyObject *)BossSession_show(arg1,*arg2);
2313	<
2314	<	}catch (const BossSchedFailure & e) {
2315	<	SWIG_exception(SWIG_ValueError, e.what());
2316	<	}catch (const std::exception& e) {
2317	<	SWIG_exception(SWIG_RuntimeError, e.what());
2310	>	if (obj1) {
2311	>	{
2312	>	if (PyString_Check(obj1))
2313	>	arg2 = std::string(PyString_AsString(obj1));
2314	>	else
2315	>	SWIG_exception(SWIG_TypeError, "string expected");
2316	>	}
2317	>	}
2318	>	if (obj2) {
2319	>	{
2320	>	if (PyString_Check(obj2))
2321	>	arg3 = std::string(PyString_AsString(obj2));
2322	>	else
2323	>	SWIG_exception(SWIG_TypeError, "string expected");
2324	>	}
2325	>	}
2326	>	if (obj3) {
2327	>	{
2328	>	if (PyString_Check(obj3))
2329	>	arg4 = std::string(PyString_AsString(obj3));
2330	>	else
2331	>	SWIG_exception(SWIG_TypeError, "string expected");
2332		}
2333		}
2263	–	resultobj = result;
2264	–	return resultobj;
2265	–	fail:
2266	–	return NULL;
2267	–	}
2268	–
2269	–
2270	–	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
2271	–	PyObject *resultobj;
2272	–	BossSession *arg1 = (BossSession *) 0 ;
2273	–	PyObject *result;
2274	–	PyObject * obj0 = 0 ;
2275	–
2276	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2277	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2334		{
2335		try {
2336	<	result = (PyObject *)BossSession_CHTools(arg1);
2336	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2337
2338		}catch (const BossSchedFailure & e) {
2339	<	SWIG_exception(SWIG_ValueError, e.what());
2339	>	PyErr_SetString ( SchedulerError, e.what() );
2340	>	return NULL;
2341		}catch (const std::exception& e) {
2342	<	SWIG_exception(SWIG_RuntimeError, e.what());
2342	>	PyErr_SetString ( BossError, e.what() );
2343	>	return NULL;
2344		}
2345		}
2346	<	resultobj = result;
2346	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2347		return resultobj;
2348		fail:
2349		return NULL;
2350		}
2351
2352
2353	<	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
2353	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2354		PyObject *resultobj;
2355		BossSession *arg1 = (BossSession *) 0 ;
2298	–	PyObject *result;
2356		PyObject * obj0 = 0 ;
2357
2358	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2358	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2359		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2360		{
2361		try {
2362	<	result = (PyObject *)BossSession_ProgramTypes(arg1);
2362	>	delete arg1;
2363
2364		}catch (const BossSchedFailure & e) {
2365	<	SWIG_exception(SWIG_ValueError, e.what());
2365	>	PyErr_SetString ( SchedulerError, e.what() );
2366	>	return NULL;
2367		}catch (const std::exception& e) {
2368	<	SWIG_exception(SWIG_RuntimeError, e.what());
2368	>	PyErr_SetString ( BossError, e.what() );
2369	>	return NULL;
2370		}
2371		}
2372	<	resultobj = result;
2372	>	Py_INCREF(Py_None); resultobj = Py_None;
2373		return resultobj;
2374		fail:
2375		return NULL;
2376		}
2377
2378
2379	<	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
2379	>	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2380		PyObject *resultobj;
2381		BossSession *arg1 = (BossSession *) 0 ;
2323	–	PyObject *result;
2382		PyObject * obj0 = 0 ;
2383
2384	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2384	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2385		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2386		{
2387		try {
2388	<	result = (PyObject *)BossSession_RTMons(arg1);
2388	>	(arg1)->resetDB();
2389
2390		}catch (const BossSchedFailure & e) {
2391	<	SWIG_exception(SWIG_ValueError, e.what());
2391	>	PyErr_SetString ( SchedulerError, e.what() );
2392	>	return NULL;
2393		}catch (const std::exception& e) {
2394	<	SWIG_exception(SWIG_RuntimeError, e.what());
2394	>	PyErr_SetString ( BossError, e.what() );
2395	>	return NULL;
2396		}
2397		}
2398	<	resultobj = result;
2398	>	Py_INCREF(Py_None); resultobj = Py_None;
2399		return resultobj;
2400		fail:
2401		return NULL;
2402		}
2403
2404
2405	<	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
2405	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2406		PyObject *resultobj;
2407		BossSession *arg1 = (BossSession *) 0 ;
2348	–	PyObject *result;
2408		PyObject * obj0 = 0 ;
2409
2410	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2410	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2411		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2412		{
2413		try {
2414	<	result = (PyObject *)BossSession_schedulers(arg1);
2414	>	(arg1)->clear();
2415
2416		}catch (const BossSchedFailure & e) {
2417	<	SWIG_exception(SWIG_ValueError, e.what());
2417	>	PyErr_SetString ( SchedulerError, e.what() );
2418	>	return NULL;
2419		}catch (const std::exception& e) {
2420	<	SWIG_exception(SWIG_RuntimeError, e.what());
2420	>	PyErr_SetString ( BossError, e.what() );
2421	>	return NULL;
2422		}
2423		}
2424	<	resultobj = result;
2424	>	Py_INCREF(Py_None); resultobj = Py_None;
2425		return resultobj;
2426		fail:
2427		return NULL;
2428		}
2429
2430
2431	<	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
2431	>	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2432		PyObject *resultobj;
2433		BossSession *arg1 = (BossSession *) 0 ;
2434	<	std::string *arg2 = 0 ;
2435	<	std::string *arg3 = 0 ;
2436	<	std::string const &arg4_defvalue = "" ;
2376	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
2377	<	std::string const &arg5_defvalue = "" ;
2378	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2379	<	bool arg6 = (bool) false ;
2380	<	PyObject *result;
2434	>	std::string const &arg2_defvalue = "" ;
2435	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
2436	>	BossTask *result;
2437		std::string temp2 ;
2382	–	std::string temp3 ;
2383	–	std::string temp4 ;
2384	–	std::string temp5 ;
2438		PyObject * obj0 = 0 ;
2439		PyObject * obj1 = 0 ;
2387	–	PyObject * obj2 = 0 ;
2388	–	PyObject * obj3 = 0 ;
2389	–	PyObject * obj4 = 0 ;
2390	–	PyObject * obj5 = 0 ;
2440
2441	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2441	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2442		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2443	<	{
2395	<	if (PyString_Check(obj1)) {
2396	<	temp2 = std::string(PyString_AsString(obj1));
2397	<	arg2 = &temp2;
2398	<	}else {
2399	<	SWIG_exception(SWIG_TypeError, "string expected");
2400	<	}
2401	<	}
2402	<	{
2403	<	if (PyString_Check(obj2)) {
2404	<	temp3 = std::string(PyString_AsString(obj2));
2405	<	arg3 = &temp3;
2406	<	}else {
2407	<	SWIG_exception(SWIG_TypeError, "string expected");
2408	<	}
2409	<	}
2410	<	if (obj3) {
2411	<	{
2412	<	if (PyString_Check(obj3)) {
2413	<	temp4 = std::string(PyString_AsString(obj3));
2414	<	arg4 = &temp4;
2415	<	}else {
2416	<	SWIG_exception(SWIG_TypeError, "string expected");
2417	<	}
2418	<	}
2419	<	}
2420	<	if (obj4) {
2443	>	if (obj1) {
2444		{
2445	<	if (PyString_Check(obj4)) {
2446	<	temp5 = std::string(PyString_AsString(obj4));
2447	<	arg5 = &temp5;
2445	>	if (PyString_Check(obj1)) {
2446	>	temp2 = std::string(PyString_AsString(obj1));
2447	>	arg2 = &temp2;
2448		}else {
2449		SWIG_exception(SWIG_TypeError, "string expected");
2450		}
2451		}
2452		}
2430	–	if (obj5) {
2431	–	arg6 = PyInt_AsLong(obj5) ? true : false;
2432	–	if (PyErr_Occurred()) SWIG_fail;
2433	–	}
2453		{
2454		try {
2455	<	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
2455	>	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2456
2457		}catch (const BossSchedFailure & e) {
2458	<	SWIG_exception(SWIG_ValueError, e.what());
2458	>	PyErr_SetString ( SchedulerError, e.what() );
2459	>	return NULL;
2460		}catch (const std::exception& e) {
2461	<	SWIG_exception(SWIG_RuntimeError, e.what());
2461	>	PyErr_SetString ( BossError, e.what() );
2462	>	return NULL;
2463		}
2464		}
2465	<	resultobj = result;
2465	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2466		return resultobj;
2467		fail:
2468		return NULL;
2469		}
2470
2471
2472	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2472	>	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2473		PyObject *resultobj;
2474		BossSession *arg1 = (BossSession *) 0 ;
2475	<	int arg2 = (int) SCHEDULED ;
2455	<	std::string const &arg3_defvalue = "all" ;
2456	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
2457	<	std::string const &arg4_defvalue = "all" ;
2458	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
2459	<	std::string const &arg5_defvalue = "" ;
2460	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2461	<	std::string arg6 = (std::string) "" ;
2462	<	std::string arg7 = (std::string) "" ;
2463	<	std::string arg8 = (std::string) "" ;
2464	<	std::string arg9 = (std::string) "" ;
2465	<	bool arg10 = (bool) false ;
2466	<	PyObject *result;
2467	<	std::string temp3 ;
2468	<	std::string temp4 ;
2469	<	std::string temp5 ;
2470	<	PyObject * obj0 = 0 ;
2471	<	PyObject * obj2 = 0 ;
2472	<	PyObject * obj3 = 0 ;
2473	<	PyObject * obj4 = 0 ;
2474	<	PyObject * obj5 = 0 ;
2475	<	PyObject * obj6 = 0 ;
2476	<	PyObject * obj7 = 0 ;
2477	<	PyObject * obj8 = 0 ;
2478	<	PyObject * obj9 = 0 ;
2479	<
2480	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2481	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2482	<	if (obj2) {
2483	<	{
2484	<	if (PyString_Check(obj2)) {
2485	<	temp3 = std::string(PyString_AsString(obj2));
2486	<	arg3 = &temp3;
2487	<	}else {
2488	<	SWIG_exception(SWIG_TypeError, "string expected");
2489	<	}
2490	<	}
2491	<	}
2492	<	if (obj3) {
2493	<	{
2494	<	if (PyString_Check(obj3)) {
2495	<	temp4 = std::string(PyString_AsString(obj3));
2496	<	arg4 = &temp4;
2497	<	}else {
2498	<	SWIG_exception(SWIG_TypeError, "string expected");
2499	<	}
2500	<	}
2501	<	}
2502	<	if (obj4) {
2503	<	{
2504	<	if (PyString_Check(obj4)) {
2505	<	temp5 = std::string(PyString_AsString(obj4));
2506	<	arg5 = &temp5;
2507	<	}else {
2508	<	SWIG_exception(SWIG_TypeError, "string expected");
2509	<	}
2510	<	}
2511	<	}
2512	<	if (obj5) {
2513	<	{
2514	<	if (PyString_Check(obj5))
2515	<	arg6 = std::string(PyString_AsString(obj5));
2516	<	else
2517	<	SWIG_exception(SWIG_TypeError, "string expected");
2518	<	}
2519	<	}
2520	<	if (obj6) {
2521	<	{
2522	<	if (PyString_Check(obj6))
2523	<	arg7 = std::string(PyString_AsString(obj6));
2524	<	else
2525	<	SWIG_exception(SWIG_TypeError, "string expected");
2526	<	}
2527	<	}
2528	<	if (obj7) {
2529	<	{
2530	<	if (PyString_Check(obj7))
2531	<	arg8 = std::string(PyString_AsString(obj7));
2532	<	else
2533	<	SWIG_exception(SWIG_TypeError, "string expected");
2534	<	}
2535	<	}
2536	<	if (obj8) {
2537	<	{
2538	<	if (PyString_Check(obj8))
2539	<	arg9 = std::string(PyString_AsString(obj8));
2540	<	else
2541	<	SWIG_exception(SWIG_TypeError, "string expected");
2542	<	}
2543	<	}
2544	<	if (obj9) {
2545	<	arg10 = PyInt_AsLong(obj9) ? true : false;
2546	<	if (PyErr_Occurred()) SWIG_fail;
2547	<	}
2548	<	{
2549	<	try {
2550	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2551	<
2552	<	}catch (const BossSchedFailure & e) {
2553	<	SWIG_exception(SWIG_ValueError, e.what());
2554	<	}catch (const std::exception& e) {
2555	<	SWIG_exception(SWIG_RuntimeError, e.what());
2556	<	}
2557	<	}
2558	<	resultobj = result;
2559	<	return resultobj;
2560	<	fail:
2561	<	return NULL;
2562	<	}
2563	<
2564	<
2565	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2566	<	PyObject *resultobj;
2567	<	std::string arg1 = (std::string) "" ;
2568	<	std::string arg2 = (std::string) "2" ;
2569	<	std::string arg3 = (std::string) "" ;
2570	<	std::string arg4 = (std::string) "" ;
2571	<	BossSession *result;
2475	>	BossTask *arg2 = (BossTask *) 0 ;
2476		PyObject * obj0 = 0 ;
2477		PyObject * obj1 = 0 ;
2574	–	PyObject * obj2 = 0 ;
2575	–	PyObject * obj3 = 0 ;
2576	–
2577	–	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2578	–	if (obj0) {
2579	–	{
2580	–	if (PyString_Check(obj0))
2581	–	arg1 = std::string(PyString_AsString(obj0));
2582	–	else
2583	–	SWIG_exception(SWIG_TypeError, "string expected");
2584	–	}
2585	–	}
2586	–	if (obj1) {
2587	–	{
2588	–	if (PyString_Check(obj1))
2589	–	arg2 = std::string(PyString_AsString(obj1));
2590	–	else
2591	–	SWIG_exception(SWIG_TypeError, "string expected");
2592	–	}
2593	–	}
2594	–	if (obj2) {
2595	–	{
2596	–	if (PyString_Check(obj2))
2597	–	arg3 = std::string(PyString_AsString(obj2));
2598	–	else
2599	–	SWIG_exception(SWIG_TypeError, "string expected");
2600	–	}
2601	–	}
2602	–	if (obj3) {
2603	–	{
2604	–	if (PyString_Check(obj3))
2605	–	arg4 = std::string(PyString_AsString(obj3));
2606	–	else
2607	–	SWIG_exception(SWIG_TypeError, "string expected");
2608	–	}
2609	–	}
2610	–	{
2611	–	try {
2612	–	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2613	–
2614	–	}catch (const BossSchedFailure & e) {
2615	–	SWIG_exception(SWIG_ValueError, e.what());
2616	–	}catch (const std::exception& e) {
2617	–	SWIG_exception(SWIG_RuntimeError, e.what());
2618	–	}
2619	–	}
2620	–	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2621	–	return resultobj;
2622	–	fail:
2623	–	return NULL;
2624	–	}
2625	–
2626	–
2627	–	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2628	–	PyObject *resultobj;
2629	–	BossSession *arg1 = (BossSession *) 0 ;
2630	–	PyObject * obj0 = 0 ;
2478
2479	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2479	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2480		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2481	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2482		{
2483		try {
2484	<	delete arg1;
2484	>	(arg1)->destroyBossTask(arg2);
2485
2486		}catch (const BossSchedFailure & e) {
2487	<	SWIG_exception(SWIG_ValueError, e.what());
2487	>	PyErr_SetString ( SchedulerError, e.what() );
2488	>	return NULL;
2489		}catch (const std::exception& e) {
2490	<	SWIG_exception(SWIG_RuntimeError, e.what());
2490	>	PyErr_SetString ( BossError, e.what() );
2491	>	return NULL;
2492		}
2493		}
2494		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2648 | Line 2498 | static PyObject *_wrap_delete_BossSessio
2498		}
2499
2500
2501	<	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2501	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2502		PyObject *resultobj;
2503		BossSession *arg1 = (BossSession *) 0 ;
2504	+	std::vector<std::string > result;
2505		PyObject * obj0 = 0 ;
2506
2507	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2507	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2508		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2509		{
2510		try {
2511	<	(arg1)->resetDB();
2511	>	result = (arg1)->showCHTools();
2512
2513		}catch (const BossSchedFailure & e) {
2514	<	SWIG_exception(SWIG_ValueError, e.what());
2514	>	PyErr_SetString ( SchedulerError, e.what() );
2515	>	return NULL;
2516		}catch (const std::exception& e) {
2517	<	SWIG_exception(SWIG_RuntimeError, e.what());
2517	>	PyErr_SetString ( BossError, e.what() );
2518	>	return NULL;
2519		}
2520		}
2521	<	Py_INCREF(Py_None); resultobj = Py_None;
2521	>	{
2522	>	resultobj = PyTuple_New((&result)->size());
2523	>	for (unsigned int i=0; i<(&result)->size(); i++)
2524	>	PyTuple_SetItem(resultobj,i,
2525	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2526	>	}
2527		return resultobj;
2528		fail:
2529		return NULL;
2530		}
2531
2532
2533	<	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2533	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2534		PyObject *resultobj;
2535		BossSession *arg1 = (BossSession *) 0 ;
2536	+	std::vector<std::string > result;
2537		PyObject * obj0 = 0 ;
2538
2539	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2539	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2540		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2541		{
2542		try {
2543	<	(arg1)->clear();
2543	>	result = (arg1)->showProgramTypes();
2544
2545		}catch (const BossSchedFailure & e) {
2546	<	SWIG_exception(SWIG_ValueError, e.what());
2546	>	PyErr_SetString ( SchedulerError, e.what() );
2547	>	return NULL;
2548		}catch (const std::exception& e) {
2549	<	SWIG_exception(SWIG_RuntimeError, e.what());
2549	>	PyErr_SetString ( BossError, e.what() );
2550	>	return NULL;
2551		}
2552		}
2553	<	Py_INCREF(Py_None); resultobj = Py_None;
2553	>	{
2554	>	resultobj = PyTuple_New((&result)->size());
2555	>	for (unsigned int i=0; i<(&result)->size(); i++)
2556	>	PyTuple_SetItem(resultobj,i,
2557	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2558	>	}
2559		return resultobj;
2560		fail:
2561		return NULL;
2562		}
2563
2564
2565	<	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2565	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2566		PyObject *resultobj;
2567		BossSession *arg1 = (BossSession *) 0 ;
2568	<	std::string const &arg2_defvalue = "" ;
2703	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2704	<	BossTask *result;
2705	<	std::string temp2 ;
2568	>	std::vector<std::string > result;
2569		PyObject * obj0 = 0 ;
2707	–	PyObject * obj1 = 0 ;
2570
2571	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2571	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2572		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2711	–	if (obj1) {
2712	–	{
2713	–	if (PyString_Check(obj1)) {
2714	–	temp2 = std::string(PyString_AsString(obj1));
2715	–	arg2 = &temp2;
2716	–	}else {
2717	–	SWIG_exception(SWIG_TypeError, "string expected");
2718	–	}
2719	–	}
2720	–	}
2573		{
2574		try {
2575	<	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2575	>	result = (arg1)->showRTMon();
2576
2577		}catch (const BossSchedFailure & e) {
2578	<	SWIG_exception(SWIG_ValueError, e.what());
2578	>	PyErr_SetString ( SchedulerError, e.what() );
2579	>	return NULL;
2580		}catch (const std::exception& e) {
2581	<	SWIG_exception(SWIG_RuntimeError, e.what());
2581	>	PyErr_SetString ( BossError, e.what() );
2582	>	return NULL;
2583		}
2584		}
2585	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2585	>	{
2586	>	resultobj = PyTuple_New((&result)->size());
2587	>	for (unsigned int i=0; i<(&result)->size(); i++)
2588	>	PyTuple_SetItem(resultobj,i,
2589	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2590	>	}
2591		return resultobj;
2592		fail:
2593		return NULL;
2594		}
2595
2596
2597	<	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2597	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2598		PyObject *resultobj;
2599		BossSession *arg1 = (BossSession *) 0 ;
2600	<	BossTask *arg2 = (BossTask *) 0 ;
2600	>	std::vector<std::string > result;
2601		PyObject * obj0 = 0 ;
2743	–	PyObject * obj1 = 0 ;
2602
2603	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2603	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2604		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2747	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2605		{
2606		try {
2607	<	(arg1)->destroyBossTask(arg2);
2607	>	result = (arg1)->showSchedulers();
2608
2609		}catch (const BossSchedFailure & e) {
2610	<	SWIG_exception(SWIG_ValueError, e.what());
2610	>	PyErr_SetString ( SchedulerError, e.what() );
2611	>	return NULL;
2612		}catch (const std::exception& e) {
2613	<	SWIG_exception(SWIG_RuntimeError, e.what());
2613	>	PyErr_SetString ( BossError, e.what() );
2614	>	return NULL;
2615		}
2616		}
2617	<	Py_INCREF(Py_None); resultobj = Py_None;
2617	>	{
2618	>	resultobj = PyTuple_New((&result)->size());
2619	>	for (unsigned int i=0; i<(&result)->size(); i++)
2620	>	PyTuple_SetItem(resultobj,i,
2621	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2622	>	}
2623		return resultobj;
2624		fail:
2625		return NULL;
#	Line 2775 | Line 2639 | static PyObject *_wrap_BossSession_defau
2639		result = (arg1)->defaultCHTool();
2640
2641		}catch (const BossSchedFailure & e) {
2642	<	SWIG_exception(SWIG_ValueError, e.what());
2642	>	PyErr_SetString ( SchedulerError, e.what() );
2643	>	return NULL;
2644		}catch (const std::exception& e) {
2645	<	SWIG_exception(SWIG_RuntimeError, e.what());
2645	>	PyErr_SetString ( BossError, e.what() );
2646	>	return NULL;
2647		}
2648		}
2649		{
#	Line 2802 | Line 2668 | static PyObject *_wrap_BossSession_defau
2668		result = (arg1)->defaultProgramType();
2669
2670		}catch (const BossSchedFailure & e) {
2671	<	SWIG_exception(SWIG_ValueError, e.what());
2671	>	PyErr_SetString ( SchedulerError, e.what() );
2672	>	return NULL;
2673		}catch (const std::exception& e) {
2674	<	SWIG_exception(SWIG_RuntimeError, e.what());
2674	>	PyErr_SetString ( BossError, e.what() );
2675	>	return NULL;
2676		}
2677		}
2678		{
#	Line 2829 | Line 2697 | static PyObject *_wrap_BossSession_defau
2697		result = (arg1)->defaultRTMon();
2698
2699		}catch (const BossSchedFailure & e) {
2700	<	SWIG_exception(SWIG_ValueError, e.what());
2700	>	PyErr_SetString ( SchedulerError, e.what() );
2701	>	return NULL;
2702		}catch (const std::exception& e) {
2703	<	SWIG_exception(SWIG_RuntimeError, e.what());
2703	>	PyErr_SetString ( BossError, e.what() );
2704	>	return NULL;
2705		}
2706		}
2707		{
#	Line 2856 | Line 2726 | static PyObject *_wrap_BossSession_defau
2726		result = (arg1)->defaultScheduler();
2727
2728		}catch (const BossSchedFailure & e) {
2729	<	SWIG_exception(SWIG_ValueError, e.what());
2729	>	PyErr_SetString ( SchedulerError, e.what() );
2730	>	return NULL;
2731		}catch (const std::exception& e) {
2732	<	SWIG_exception(SWIG_RuntimeError, e.what());
2732	>	PyErr_SetString ( BossError, e.what() );
2733	>	return NULL;
2734		}
2735		}
2736		{
#	Line 2883 | Line 2755 | static PyObject *_wrap_BossSession_versi
2755		result = (arg1)->version();
2756
2757		}catch (const BossSchedFailure & e) {
2758	<	SWIG_exception(SWIG_ValueError, e.what());
2758	>	PyErr_SetString ( SchedulerError, e.what() );
2759	>	return NULL;
2760		}catch (const std::exception& e) {
2761	<	SWIG_exception(SWIG_RuntimeError, e.what());
2761	>	PyErr_SetString ( BossError, e.what() );
2762	>	return NULL;
2763		}
2764		}
2765		{
#	Line 2910 | Line 2784 | static PyObject *_wrap_BossSession_clien
2784		result = (arg1)->clientID();
2785
2786		}catch (const BossSchedFailure & e) {
2787	<	SWIG_exception(SWIG_ValueError, e.what());
2787	>	PyErr_SetString ( SchedulerError, e.what() );
2788	>	return NULL;
2789		}catch (const std::exception& e) {
2790	<	SWIG_exception(SWIG_RuntimeError, e.what());
2790	>	PyErr_SetString ( BossError, e.what() );
2791	>	return NULL;
2792		}
2793		}
2794		{
#	Line 2943 | Line 2819 | static PyObject *_wrap_BossSession_showC
2819		result = (int)(arg1)->showConfigs(arg2);
2820
2821		}catch (const BossSchedFailure & e) {
2822	<	SWIG_exception(SWIG_ValueError, e.what());
2822	>	PyErr_SetString ( SchedulerError, e.what() );
2823	>	return NULL;
2824		}catch (const std::exception& e) {
2825	<	SWIG_exception(SWIG_RuntimeError, e.what());
2825	>	PyErr_SetString ( BossError, e.what() );
2826	>	return NULL;
2827		}
2828		}
2829		resultobj = PyInt_FromLong((long)result);
#	Line 2998 | Line 2876 | static PyObject *_wrap_BossSession_RTupd
2876		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2877
2878		}catch (const BossSchedFailure & e) {
2879	<	SWIG_exception(SWIG_ValueError, e.what());
2879	>	PyErr_SetString ( SchedulerError, e.what() );
2880	>	return NULL;
2881		}catch (const std::exception& e) {
2882	<	SWIG_exception(SWIG_RuntimeError, e.what());
2882	>	PyErr_SetString ( BossError, e.what() );
2883	>	return NULL;
2884		}
2885		}
2886		resultobj = PyInt_FromLong((long)result);
#	Line 3020 | Line 2900 | static PyObject *_wrap_BossSession_listM
2900		std::string *arg5 = (std::string *) &arg5_defvalue ;
2901		std::string const &arg6_defvalue = "" ;
2902		std::string *arg6 = (std::string *) &arg6_defvalue ;
2903	+	unsigned int arg7 = (unsigned int) 0 ;
2904		std::vector<std::string > result;
2905		std::string temp2 ;
2906		std::string temp3 ;
#	Line 3031 | Line 2912 | static PyObject *_wrap_BossSession_listM
2912		PyObject * obj3 = 0 ;
2913		PyObject * obj4 = 0 ;
2914		PyObject * obj5 = 0 ;
2915	+	PyObject * obj6 = 0 ;
2916
2917	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2917	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2918		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2919		{
2920		if (PyString_Check(obj1)) {
#	Line 3074 | Line 2956 | static PyObject *_wrap_BossSession_listM
2956		}
2957		}
2958		}
2959	+	if (obj6) {
2960	+	arg7 = (unsigned int) PyInt_AsLong(obj6);
2961	+	if (PyErr_Occurred()) SWIG_fail;
2962	+	}
2963		{
2964		try {
2965	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2965	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
2966
2967		}catch (const BossSchedFailure & e) {
2968	<	SWIG_exception(SWIG_ValueError, e.what());
2968	>	PyErr_SetString ( SchedulerError, e.what() );
2969	>	return NULL;
2970		}catch (const std::exception& e) {
2971	<	SWIG_exception(SWIG_RuntimeError, e.what());
2971	>	PyErr_SetString ( BossError, e.what() );
2972	>	return NULL;
2973		}
2974		}
2975		{
#	Line 3110 | Line 2998 | static PyObject *_wrap_BossSession_sched
2998		std::string arg7 = (std::string) "" ;
2999		std::string arg8 = (std::string) "" ;
3000		std::string arg9 = (std::string) "" ;
3001	+	unsigned int arg10 = (unsigned int) 0 ;
3002		std::string temp3 ;
3003		std::string temp4 ;
3004		std::string temp5 ;
#	Line 3121 | Line 3010 | static PyObject *_wrap_BossSession_sched
3010		PyObject * obj6 = 0 ;
3011		PyObject * obj7 = 0 ;
3012		PyObject * obj8 = 0 ;
3013	+	PyObject * obj9 = 0 ;
3014
3015	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3015	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3016		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3017		if (obj2) {
3018		{
#	Line 3186 | Line 3076 | static PyObject *_wrap_BossSession_sched
3076		SWIG_exception(SWIG_TypeError, "string expected");
3077		}
3078		}
3079	+	if (obj9) {
3080	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3081	+	if (PyErr_Occurred()) SWIG_fail;
3082	+	}
3083		{
3084		try {
3085	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3085	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3086
3087		}catch (const BossSchedFailure & e) {
3088	<	SWIG_exception(SWIG_ValueError, e.what());
3088	>	PyErr_SetString ( SchedulerError, e.what() );
3089	>	return NULL;
3090		}catch (const std::exception& e) {
3091	<	SWIG_exception(SWIG_RuntimeError, e.what());
3091	>	PyErr_SetString ( BossError, e.what() );
3092	>	return NULL;
3093		}
3094		}
3095		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3272 | Line 3168 | static PyObject *_wrap_BossSession_selec
3168		result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3169
3170		}catch (const BossSchedFailure & e) {
3171	<	SWIG_exception(SWIG_ValueError, e.what());
3171	>	PyErr_SetString ( SchedulerError, e.what() );
3172	>	return NULL;
3173		}catch (const std::exception& e) {
3174	<	SWIG_exception(SWIG_RuntimeError, e.what());
3174	>	PyErr_SetString ( BossError, e.what() );
3175	>	return NULL;
3176		}
3177		}
3178		{
#	Line 3303 | Line 3201 | static PyObject *_wrap_BossSession_query
3201		std::string arg7 = (std::string) "" ;
3202		std::string arg8 = (std::string) "" ;
3203		std::string arg9 = (std::string) "" ;
3204	<	bool arg10 = (bool) false ;
3204	>	unsigned int arg10 = (unsigned int) 0 ;
3205	>	bool arg11 = (bool) false ;
3206		SwigValueWrapper< std::vector<BossTask * > > result;
3207		std::string temp3 ;
3208		std::string temp4 ;
#	Line 3317 | Line 3216 | static PyObject *_wrap_BossSession_query
3216		PyObject * obj7 = 0 ;
3217		PyObject * obj8 = 0 ;
3218		PyObject * obj9 = 0 ;
3219	+	PyObject * obj10 = 0 ;
3220
3221	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3221	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3222		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3223		if (obj2) {
3224		{
#	Line 3383 | Line 3283 | static PyObject *_wrap_BossSession_query
3283		}
3284		}
3285		if (obj9) {
3286	<	arg10 = PyInt_AsLong(obj9) ? true : false;
3286	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3287	>	if (PyErr_Occurred()) SWIG_fail;
3288	>	}
3289	>	if (obj10) {
3290	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3291		if (PyErr_Occurred()) SWIG_fail;
3292		}
3293		{
3294		try {
3295	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3295	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3296
3297		}catch (const BossSchedFailure & e) {
3298	<	SWIG_exception(SWIG_ValueError, e.what());
3298	>	PyErr_SetString ( SchedulerError, e.what() );
3299	>	return NULL;
3300		}catch (const std::exception& e) {
3301	<	SWIG_exception(SWIG_RuntimeError, e.what());
3301	>	PyErr_SetString ( BossError, e.what() );
3302	>	return NULL;
3303		}
3304		}
3305		{
#	Line 3407 | Line 3313 | static PyObject *_wrap_BossSession_query
3313		}
3314
3315
3316	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3411	<	PyObject *obj;
3412	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3413	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3414	<	Py_INCREF(obj);
3415	<	return Py_BuildValue((char *)"");
3416	<	}
3417	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3316	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3317		PyObject *resultobj;
3318	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3319	<	char *arg2 ;
3318	>	BossSession *arg1 = (BossSession *) 0 ;
3319	>	std::vector<std::string > *arg2 = 0 ;
3320	>	PyObject *result;
3321		PyObject * obj0 = 0 ;
3322	+	PyObject * obj1 = 0 ;
3323
3324	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3325	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3324	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3325	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3326	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3327	>	if (arg2 == NULL) {
3328	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3329	>	}
3330		{
3331	<	if (arg2) {
3332	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3333	<	strcpy((char *) arg1->key,arg2);
3334	<	}else {
3335	<	arg1->key = 0;
3331	>	try {
3332	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3333	>
3334	>	}catch (const BossSchedFailure & e) {
3335	>	PyErr_SetString ( SchedulerError, e.what() );
3336	>	return NULL;
3337	>	}catch (const std::exception& e) {
3338	>	PyErr_SetString ( BossError, e.what() );
3339	>	return NULL;
3340		}
3341		}
3342	<	Py_INCREF(Py_None); resultobj = Py_None;
3342	>	resultobj = result;
3343		return resultobj;
3344		fail:
3345		return NULL;
3346		}
3347
3348
3349	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3349	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3350		PyObject *resultobj;
3351	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3352	<	char *result;
3351	>	BossSession *arg1 = (BossSession *) 0 ;
3352	>	PyObject *result;
3353		PyObject * obj0 = 0 ;
3354
3355	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3356	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3357	<	result = (char *) ((arg1)->key);
3358	<
3359	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3355	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3356	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3357	>	{
3358	>	try {
3359	>	result = (PyObject *)BossSession_CHTools(arg1);
3360	>
3361	>	}catch (const BossSchedFailure & e) {
3362	>	PyErr_SetString ( SchedulerError, e.what() );
3363	>	return NULL;
3364	>	}catch (const std::exception& e) {
3365	>	PyErr_SetString ( BossError, e.what() );
3366	>	return NULL;
3367	>	}
3368	>	}
3369	>	resultobj = result;
3370		return resultobj;
3371		fail:
3372		return NULL;
3373		}
3374
3375
3376	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3376	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3377		PyObject *resultobj;
3378	<	char *arg1 ;
3379	<	BossTaskException *result;
3378	>	BossSession *arg1 = (BossSession *) 0 ;
3379	>	PyObject *result;
3380	>	PyObject * obj0 = 0 ;
3381
3382	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3382	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3383	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3384		{
3385		try {
3386	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3386	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3387
3388		}catch (const BossSchedFailure & e) {
3389	<	SWIG_exception(SWIG_ValueError, e.what());
3389	>	PyErr_SetString ( SchedulerError, e.what() );
3390	>	return NULL;
3391		}catch (const std::exception& e) {
3392	<	SWIG_exception(SWIG_RuntimeError, e.what());
3392	>	PyErr_SetString ( BossError, e.what() );
3393	>	return NULL;
3394		}
3395		}
3396	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3396	>	resultobj = result;
3397		return resultobj;
3398		fail:
3399		return NULL;
3400		}
3401
3402
3403	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3403	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3404		PyObject *resultobj;
3405	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3406	<	char *result;
3405	>	BossSession *arg1 = (BossSession *) 0 ;
3406	>	PyObject *result;
3407		PyObject * obj0 = 0 ;
3408
3409	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3410	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3409	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3410	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3411		{
3412		try {
3413	<	result = (char *)((BossTaskException const *)arg1)->what();
3413	>	result = (PyObject *)BossSession_RTMons(arg1);
3414
3415		}catch (const BossSchedFailure & e) {
3416	<	SWIG_exception(SWIG_ValueError, e.what());
3416	>	PyErr_SetString ( SchedulerError, e.what() );
3417	>	return NULL;
3418		}catch (const std::exception& e) {
3419	<	SWIG_exception(SWIG_RuntimeError, e.what());
3419	>	PyErr_SetString ( BossError, e.what() );
3420	>	return NULL;
3421		}
3422		}
3423	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3423	>	resultobj = result;
3424		return resultobj;
3425		fail:
3426		return NULL;
3427		}
3428
3429
3430	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3430	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3431		PyObject *resultobj;
3432	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3432	>	BossSession *arg1 = (BossSession *) 0 ;
3433	>	PyObject *result;
3434		PyObject * obj0 = 0 ;
3435
3436	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3437	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3436	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3437	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3438		{
3439		try {
3440	<	delete arg1;
3440	>	result = (PyObject *)BossSession_schedulers(arg1);
3441
3442		}catch (const BossSchedFailure & e) {
3443	<	SWIG_exception(SWIG_ValueError, e.what());
3443	>	PyErr_SetString ( SchedulerError, e.what() );
3444	>	return NULL;
3445		}catch (const std::exception& e) {
3446	<	SWIG_exception(SWIG_RuntimeError, e.what());
3446	>	PyErr_SetString ( BossError, e.what() );
3447	>	return NULL;
3448		}
3449		}
3450	<	Py_INCREF(Py_None); resultobj = Py_None;
3450	>	resultobj = result;
3451		return resultobj;
3452		fail:
3453		return NULL;
3454		}
3455
3456
3457	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3530	<	PyObject *obj;
3531	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3532	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3533	<	Py_INCREF(obj);
3534	<	return Py_BuildValue((char *)"");
3535	<	}
3536	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3457	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3458		PyObject *resultobj;
3459	<	BossTask *arg1 = (BossTask *) 0 ;
3460	<	PyObject *arg2 = (PyObject *) 0 ;
3461	<	BossAttributeContainer *arg3 = 0 ;
3459	>	BossSession *arg1 = (BossSession *) 0 ;
3460	>	std::string *arg2 = 0 ;
3461	>	std::string *arg3 = 0 ;
3462	>	std::string const &arg4_defvalue = "" ;
3463	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3464	>	std::string const &arg5_defvalue = "" ;
3465	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3466	>	unsigned int arg6 = (unsigned int) 0 ;
3467	>	bool arg7 = (bool) false ;
3468		PyObject *result;
3469	+	std::string temp2 ;
3470	+	std::string temp3 ;
3471	+	std::string temp4 ;
3472	+	std::string temp5 ;
3473		PyObject * obj0 = 0 ;
3474		PyObject * obj1 = 0 ;
3475		PyObject * obj2 = 0 ;
3476	+	PyObject * obj3 = 0 ;
3477	+	PyObject * obj4 = 0 ;
3478	+	PyObject * obj5 = 0 ;
3479	+	PyObject * obj6 = 0 ;
3480
3481	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3482	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3483	<	arg2 = obj1;
3484	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3485	<	if (arg3 == NULL) {
3486	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3481	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3482	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3483	>	{
3484	>	if (PyString_Check(obj1)) {
3485	>	temp2 = std::string(PyString_AsString(obj1));
3486	>	arg2 = &temp2;
3487	>	}else {
3488	>	SWIG_exception(SWIG_TypeError, "string expected");
3489	>	}
3490	>	}
3491	>	{
3492	>	if (PyString_Check(obj2)) {
3493	>	temp3 = std::string(PyString_AsString(obj2));
3494	>	arg3 = &temp3;
3495	>	}else {
3496	>	SWIG_exception(SWIG_TypeError, "string expected");
3497	>	}
3498	>	}
3499	>	if (obj3) {
3500	>	{
3501	>	if (PyString_Check(obj3)) {
3502	>	temp4 = std::string(PyString_AsString(obj3));
3503	>	arg4 = &temp4;
3504	>	}else {
3505	>	SWIG_exception(SWIG_TypeError, "string expected");
3506	>	}
3507	>	}
3508	>	}
3509	>	if (obj4) {
3510	>	{
3511	>	if (PyString_Check(obj4)) {
3512	>	temp5 = std::string(PyString_AsString(obj4));
3513	>	arg5 = &temp5;
3514	>	}else {
3515	>	SWIG_exception(SWIG_TypeError, "string expected");
3516	>	}
3517	>	}
3518	>	}
3519	>	if (obj5) {
3520	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3521	>	if (PyErr_Occurred()) SWIG_fail;
3522	>	}
3523	>	if (obj6) {
3524	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3525	>	if (PyErr_Occurred()) SWIG_fail;
3526		}
3527		{
3528		try {
3529	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3529	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3530
3531		}catch (const BossSchedFailure & e) {
3532	<	SWIG_exception(SWIG_ValueError, e.what());
3532	>	PyErr_SetString ( SchedulerError, e.what() );
3533	>	return NULL;
3534		}catch (const std::exception& e) {
3535	<	SWIG_exception(SWIG_RuntimeError, e.what());
3535	>	PyErr_SetString ( BossError, e.what() );
3536	>	return NULL;
3537		}
3538		}
3539		resultobj = result;
#	Line 3567 | Line 3543 | static PyObject *_wrap_BossTask_appendTo
3543		}
3544
3545
3546	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3546	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3547		PyObject *resultobj;
3548	<	BossTask *arg1 = (BossTask *) 0 ;
3549	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3548	>	BossSession *arg1 = (BossSession *) 0 ;
3549	>	int arg2 = (int) SCHEDULED ;
3550	>	std::string const &arg3_defvalue = "all" ;
3551	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3552	>	std::string const &arg4_defvalue = "all" ;
3553	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3554	>	std::string const &arg5_defvalue = "" ;
3555	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3556	>	std::string arg6 = (std::string) "" ;
3557	>	std::string arg7 = (std::string) "" ;
3558	>	std::string arg8 = (std::string) "" ;
3559	>	std::string arg9 = (std::string) "" ;
3560	>	unsigned int arg10 = (unsigned int) 0 ;
3561	>	bool arg11 = (bool) false ;
3562		PyObject *result;
3563	+	std::string temp3 ;
3564	+	std::string temp4 ;
3565	+	std::string temp5 ;
3566		PyObject * obj0 = 0 ;
3567	<	PyObject * obj1 = 0 ;
3567	>	PyObject * obj2 = 0 ;
3568	>	PyObject * obj3 = 0 ;
3569	>	PyObject * obj4 = 0 ;
3570	>	PyObject * obj5 = 0 ;
3571	>	PyObject * obj6 = 0 ;
3572	>	PyObject * obj7 = 0 ;
3573	>	PyObject * obj8 = 0 ;
3574	>	PyObject * obj9 = 0 ;
3575	>	PyObject * obj10 = 0 ;
3576
3577	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3578	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3579	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3580	<	if (arg2 == NULL) {
3581	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3577	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3578	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3579	>	if (obj2) {
3580	>	{
3581	>	if (PyString_Check(obj2)) {
3582	>	temp3 = std::string(PyString_AsString(obj2));
3583	>	arg3 = &temp3;
3584	>	}else {
3585	>	SWIG_exception(SWIG_TypeError, "string expected");
3586	>	}
3587	>	}
3588	>	}
3589	>	if (obj3) {
3590	>	{
3591	>	if (PyString_Check(obj3)) {
3592	>	temp4 = std::string(PyString_AsString(obj3));
3593	>	arg4 = &temp4;
3594	>	}else {
3595	>	SWIG_exception(SWIG_TypeError, "string expected");
3596	>	}
3597	>	}
3598	>	}
3599	>	if (obj4) {
3600	>	{
3601	>	if (PyString_Check(obj4)) {
3602	>	temp5 = std::string(PyString_AsString(obj4));
3603	>	arg5 = &temp5;
3604	>	}else {
3605	>	SWIG_exception(SWIG_TypeError, "string expected");
3606	>	}
3607	>	}
3608	>	}
3609	>	if (obj5) {
3610	>	{
3611	>	if (PyString_Check(obj5))
3612	>	arg6 = std::string(PyString_AsString(obj5));
3613	>	else
3614	>	SWIG_exception(SWIG_TypeError, "string expected");
3615	>	}
3616	>	}
3617	>	if (obj6) {
3618	>	{
3619	>	if (PyString_Check(obj6))
3620	>	arg7 = std::string(PyString_AsString(obj6));
3621	>	else
3622	>	SWIG_exception(SWIG_TypeError, "string expected");
3623	>	}
3624	>	}
3625	>	if (obj7) {
3626	>	{
3627	>	if (PyString_Check(obj7))
3628	>	arg8 = std::string(PyString_AsString(obj7));
3629	>	else
3630	>	SWIG_exception(SWIG_TypeError, "string expected");
3631	>	}
3632	>	}
3633	>	if (obj8) {
3634	>	{
3635	>	if (PyString_Check(obj8))
3636	>	arg9 = std::string(PyString_AsString(obj8));
3637	>	else
3638	>	SWIG_exception(SWIG_TypeError, "string expected");
3639	>	}
3640	>	}
3641	>	if (obj9) {
3642	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3643	>	if (PyErr_Occurred()) SWIG_fail;
3644	>	}
3645	>	if (obj10) {
3646	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3647	>	if (PyErr_Occurred()) SWIG_fail;
3648		}
3649		{
3650		try {
3651	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3651	>	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3652
3653		}catch (const BossSchedFailure & e) {
3654	<	SWIG_exception(SWIG_ValueError, e.what());
3654	>	PyErr_SetString ( SchedulerError, e.what() );
3655	>	return NULL;
3656		}catch (const std::exception& e) {
3657	<	SWIG_exception(SWIG_RuntimeError, e.what());
3657	>	PyErr_SetString ( BossError, e.what() );
3658	>	return NULL;
3659		}
3660		}
3661		resultobj = result;
#	Line 3598 | Line 3665 | static PyObject *_wrap_BossTask_jobDict(
3665		}
3666
3667
3668	<	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
3668	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3669	>	PyObject *obj;
3670	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3671	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3672	>	Py_INCREF(obj);
3673	>	return Py_BuildValue((char *)"");
3674	>	}
3675	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3676		PyObject *resultobj;
3677	<	BossTask *arg1 = (BossTask *) 0 ;
3678	<	PyObject *result;
3677	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3678	>	char *arg2 ;
3679		PyObject * obj0 = 0 ;
3680
3681	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3682	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3681	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3682	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3683	>	{
3684	>	if (arg2) {
3685	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3686	>	strcpy((char *) arg1->key,arg2);
3687	>	}else {
3688	>	arg1->key = 0;
3689	>	}
3690	>	}
3691	>	Py_INCREF(Py_None); resultobj = Py_None;
3692	>	return resultobj;
3693	>	fail:
3694	>	return NULL;
3695	>	}
3696	>
3697	>
3698	>	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3699	>	PyObject *resultobj;
3700	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3701	>	char *result;
3702	>	PyObject * obj0 = 0 ;
3703	>
3704	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3705	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3706	>	result = (char *) ((arg1)->key);
3707	>
3708	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3709	>	return resultobj;
3710	>	fail:
3711	>	return NULL;
3712	>	}
3713	>
3714	>
3715	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3716	>	PyObject *resultobj;
3717	>	char *arg1 ;
3718	>	BossTaskException *result;
3719	>
3720	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3721		{
3722		try {
3723	<	result = (PyObject *)BossTask_jobsDict(arg1);
3723	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3724
3725		}catch (const BossSchedFailure & e) {
3726	<	SWIG_exception(SWIG_ValueError, e.what());
3726	>	PyErr_SetString ( SchedulerError, e.what() );
3727	>	return NULL;
3728		}catch (const std::exception& e) {
3729	<	SWIG_exception(SWIG_RuntimeError, e.what());
3729	>	PyErr_SetString ( BossError, e.what() );
3730	>	return NULL;
3731		}
3732		}
3733	<	resultobj = result;
3733	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3734		return resultobj;
3735		fail:
3736		return NULL;
3737		}
3738
3739
3740	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3740	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3741		PyObject *resultobj;
3742	<	BossTask *arg1 = (BossTask *) 0 ;
3743	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3630	<	PyObject *result;
3742	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3743	>	char *result;
3744		PyObject * obj0 = 0 ;
3632	–	PyObject * obj1 = 0 ;
3745
3746	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3747	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3636	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3637	<	if (arg2 == NULL) {
3638	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3639	<	}
3746	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3747	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3748		{
3749		try {
3750	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3750	>	result = (char *)((BossTaskException const *)arg1)->what();
3751
3752		}catch (const BossSchedFailure & e) {
3753	<	SWIG_exception(SWIG_ValueError, e.what());
3753	>	PyErr_SetString ( SchedulerError, e.what() );
3754	>	return NULL;
3755		}catch (const std::exception& e) {
3756	<	SWIG_exception(SWIG_RuntimeError, e.what());
3756	>	PyErr_SetString ( BossError, e.what() );
3757	>	return NULL;
3758		}
3759		}
3760	<	resultobj = result;
3760	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3761		return resultobj;
3762		fail:
3763		return NULL;
3764		}
3765
3766
3767	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
3767	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3768		PyObject *resultobj;
3769	<	BossTask *arg1 = (BossTask *) 0 ;
3660	<	std::string *arg2 = 0 ;
3661	<	PyObject *result;
3662	<	std::string temp2 ;
3769	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3770		PyObject * obj0 = 0 ;
3664	–	PyObject * obj1 = 0 ;
3771
3772	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3773	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3668	<	{
3669	<	if (PyString_Check(obj1)) {
3670	<	temp2 = std::string(PyString_AsString(obj1));
3671	<	arg2 = &temp2;
3672	<	}else {
3673	<	SWIG_exception(SWIG_TypeError, "string expected");
3674	<	}
3675	<	}
3772	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3773	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3774		{
3775		try {
3776	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3776	>	delete arg1;
3777
3778		}catch (const BossSchedFailure & e) {
3779	<	SWIG_exception(SWIG_ValueError, e.what());
3779	>	PyErr_SetString ( SchedulerError, e.what() );
3780	>	return NULL;
3781		}catch (const std::exception& e) {
3782	<	SWIG_exception(SWIG_RuntimeError, e.what());
3782	>	PyErr_SetString ( BossError, e.what() );
3783	>	return NULL;
3784		}
3785		}
3786	<	resultobj = result;
3786	>	Py_INCREF(Py_None); resultobj = Py_None;
3787		return resultobj;
3788		fail:
3789		return NULL;
3790		}
3791
3792
3793	+	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3794	+	PyObject *obj;
3795	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3796	+	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3797	+	Py_INCREF(obj);
3798	+	return Py_BuildValue((char *)"");
3799	+	}
3800		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3801		PyObject *resultobj;
3802		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 3703 | Line 3810 | static PyObject *_wrap_new_BossTask__SWI
3810		result = (BossTask *)new BossTask(arg1);
3811
3812		}catch (const BossSchedFailure & e) {
3813	<	SWIG_exception(SWIG_ValueError, e.what());
3813	>	PyErr_SetString ( SchedulerError, e.what() );
3814	>	return NULL;
3815		}catch (const std::exception& e) {
3816	<	SWIG_exception(SWIG_RuntimeError, e.what());
3816	>	PyErr_SetString ( BossError, e.what() );
3817	>	return NULL;
3818		}
3819		}
3820		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3739 | Line 3848 | static PyObject *_wrap_new_BossTask__SWI
3848		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3849
3850		}catch (const BossSchedFailure & e) {
3851	<	SWIG_exception(SWIG_ValueError, e.what());
3851	>	PyErr_SetString ( SchedulerError, e.what() );
3852	>	return NULL;
3853		}catch (const std::exception& e) {
3854	<	SWIG_exception(SWIG_RuntimeError, e.what());
3854	>	PyErr_SetString ( BossError, e.what() );
3855	>	return NULL;
3856		}
3857		}
3858		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3763 | Line 3874 | static PyObject *_wrap_delete_BossTask(P
3874		delete arg1;
3875
3876		}catch (const BossSchedFailure & e) {
3877	<	SWIG_exception(SWIG_ValueError, e.what());
3877	>	PyErr_SetString ( SchedulerError, e.what() );
3878	>	return NULL;
3879		}catch (const std::exception& e) {
3880	<	SWIG_exception(SWIG_RuntimeError, e.what());
3880	>	PyErr_SetString ( BossError, e.what() );
3881	>	return NULL;
3882		}
3883		}
3884		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3791 | Line 3904 | static PyObject *_wrap_new_BossTask__SWI
3904		result = (BossTask *)new BossTask((BossTask const &)*arg1);
3905
3906		}catch (const BossSchedFailure & e) {
3907	<	SWIG_exception(SWIG_ValueError, e.what());
3907	>	PyErr_SetString ( SchedulerError, e.what() );
3908	>	return NULL;
3909		}catch (const std::exception& e) {
3910	<	SWIG_exception(SWIG_RuntimeError, e.what());
3910	>	PyErr_SetString ( BossError, e.what() );
3911	>	return NULL;
3912		}
3913		}
3914		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3884 | Line 3999 | static PyObject *_wrap_BossTask_id(PyObj
3999		}
4000
4001		}catch (const BossSchedFailure & e) {
4002	<	SWIG_exception(SWIG_ValueError, e.what());
4002	>	PyErr_SetString ( SchedulerError, e.what() );
4003	>	return NULL;
4004		}catch (const std::exception& e) {
4005	<	SWIG_exception(SWIG_RuntimeError, e.what());
4005	>	PyErr_SetString ( BossError, e.what() );
4006	>	return NULL;
4007		}
4008		}
4009		{
#	Line 3914 | Line 4031 | static PyObject *_wrap_BossTask_name(PyO
4031		}
4032
4033		}catch (const BossSchedFailure & e) {
4034	<	SWIG_exception(SWIG_ValueError, e.what());
4034	>	PyErr_SetString ( SchedulerError, e.what() );
4035	>	return NULL;
4036		}catch (const std::exception& e) {
4037	<	SWIG_exception(SWIG_RuntimeError, e.what());
4037	>	PyErr_SetString ( BossError, e.what() );
4038	>	return NULL;
4039		}
4040		}
4041		{
#	Line 3941 | Line 4060 | static PyObject *_wrap_BossTask_taskMap(
4060		result = ((BossTask const *)arg1)->taskMap();
4061
4062		}catch (const BossSchedFailure & e) {
4063	<	SWIG_exception(SWIG_ValueError, e.what());
4063	>	PyErr_SetString ( SchedulerError, e.what() );
4064	>	return NULL;
4065		}catch (const std::exception& e) {
4066	<	SWIG_exception(SWIG_RuntimeError, e.what());
4066	>	PyErr_SetString ( BossError, e.what() );
4067	>	return NULL;
4068		}
4069		}
4070		{
#	Line 3973 | Line 4094 | static PyObject *_wrap_BossTask_job_begi
4094		result = ((BossTask const *)arg1)->job_begin();
4095
4096		}catch (const BossSchedFailure & e) {
4097	<	SWIG_exception(SWIG_ValueError, e.what());
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 4002 | Line 4125 | static PyObject *_wrap_BossTask_job_end(
4125		result = ((BossTask const *)arg1)->job_end();
4126
4127		}catch (const BossSchedFailure & e) {
4128	<	SWIG_exception(SWIG_ValueError, e.what());
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 4031 | Line 4156 | static PyObject *_wrap_BossTask_jobsMap(
4156		result = ((BossTask const *)arg1)->jobsMap();
4157
4158		}catch (const BossSchedFailure & e) {
4159	<	SWIG_exception(SWIG_ValueError, e.what());
4159	>	PyErr_SetString ( SchedulerError, e.what() );
4160	>	return NULL;
4161		}catch (const std::exception& e) {
4162	<	SWIG_exception(SWIG_RuntimeError, e.what());
4162	>	PyErr_SetString ( BossError, e.what() );
4163	>	return NULL;
4164		}
4165		}
4166		{
#	Line 4071 | Line 4198 | static PyObject *_wrap_BossTask_jobMap__
4198		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4199
4200		}catch (const BossSchedFailure & e) {
4201	<	SWIG_exception(SWIG_ValueError, e.what());
4201	>	PyErr_SetString ( SchedulerError, e.what() );
4202	>	return NULL;
4203		}catch (const std::exception& e) {
4204	<	SWIG_exception(SWIG_RuntimeError, e.what());
4204	>	PyErr_SetString ( BossError, e.what() );
4205	>	return NULL;
4206		}
4207		}
4208		{
#	Line 4102 | Line 4231 | static PyObject *_wrap_BossTask_jobMap__
4231		result = ((BossTask const *)arg1)->jobMap(arg2);
4232
4233		}catch (const BossSchedFailure & e) {
4234	<	SWIG_exception(SWIG_ValueError, e.what());
4234	>	PyErr_SetString ( SchedulerError, e.what() );
4235	>	return NULL;
4236		}catch (const std::exception& e) {
4237	<	SWIG_exception(SWIG_RuntimeError, e.what());
4237	>	PyErr_SetString ( BossError, e.what() );
4238	>	return NULL;
4239		}
4240		}
4241		{
#	Line 4209 | Line 4340 | static PyObject *_wrap_BossTask_programs
4340		result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4341
4342		}catch (const BossSchedFailure & e) {
4343	<	SWIG_exception(SWIG_ValueError, e.what());
4343	>	PyErr_SetString ( SchedulerError, e.what() );
4344	>	return NULL;
4345		}catch (const std::exception& e) {
4346	<	SWIG_exception(SWIG_RuntimeError, e.what());
4346	>	PyErr_SetString ( BossError, e.what() );
4347	>	return NULL;
4348		}
4349		}
4350		{
#	Line 4241 | Line 4374 | static PyObject *_wrap_BossTask_queryJob
4374		result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4375
4376		}catch (const BossSchedFailure & e) {
4377	<	SWIG_exception(SWIG_ValueError, e.what());
4377	>	PyErr_SetString ( SchedulerError, e.what() );
4378	>	return NULL;
4379		}catch (const std::exception& e) {
4380	<	SWIG_exception(SWIG_RuntimeError, e.what());
4380	>	PyErr_SetString ( BossError, e.what() );
4381	>	return NULL;
4382		}
4383		}
4384		{
#	Line 4294 | Line 4429 | static PyObject *_wrap_BossTask_declare_
4429		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4430
4431		}catch (const BossSchedFailure & e) {
4432	<	SWIG_exception(SWIG_ValueError, e.what());
4432	>	PyErr_SetString ( SchedulerError, e.what() );
4433	>	return NULL;
4434		}catch (const std::exception& e) {
4435	<	SWIG_exception(SWIG_RuntimeError, e.what());
4435	>	PyErr_SetString ( BossError, e.what() );
4436	>	return NULL;
4437		}
4438		}
4439		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4335 | Line 4472 | static PyObject *_wrap_BossTask_declare_
4472		(arg1)->declare(arg2,(std::string const &)*arg3);
4473
4474		}catch (const BossSchedFailure & e) {
4475	<	SWIG_exception(SWIG_ValueError, e.what());
4475	>	PyErr_SetString ( SchedulerError, e.what() );
4476	>	return NULL;
4477		}catch (const std::exception& e) {
4478	<	SWIG_exception(SWIG_RuntimeError, e.what());
4478	>	PyErr_SetString ( BossError, e.what() );
4479	>	return NULL;
4480		}
4481		}
4482		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4436 | Line 4575 | static PyObject *_wrap_BossTask_remove(P
4575		(arg1)->remove();
4576
4577		}catch (const BossSchedFailure & e) {
4578	<	SWIG_exception(SWIG_ValueError, e.what());
4578	>	PyErr_SetString ( SchedulerError, e.what() );
4579	>	return NULL;
4580		}catch (const std::exception& e) {
4581	<	SWIG_exception(SWIG_RuntimeError, e.what());
4581	>	PyErr_SetString ( BossError, e.what() );
4582	>	return NULL;
4583		}
4584		}
4585		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4474 | Line 4615 | static PyObject *_wrap_BossTask_archive(
4615		(arg1)->archive((std::string const &)*arg2);
4616
4617		}catch (const BossSchedFailure & e) {
4618	<	SWIG_exception(SWIG_ValueError, e.what());
4618	>	PyErr_SetString ( SchedulerError, e.what() );
4619	>	return NULL;
4620		}catch (const std::exception& e) {
4621	<	SWIG_exception(SWIG_RuntimeError, e.what());
4621	>	PyErr_SetString ( BossError, e.what() );
4622	>	return NULL;
4623		}
4624		}
4625		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4499 | Line 4642 | static PyObject *_wrap_BossTask_submit(P
4642		std::string *arg5 = (std::string *) &arg5_defvalue ;
4643		std::string const &arg6_defvalue = "" ;
4644		std::string *arg6 = (std::string *) &arg6_defvalue ;
4645	<	bool arg7 = (bool) false ;
4645	>	unsigned int arg7 = (unsigned int) 0 ;
4646	>	bool arg8 = (bool) false ;
4647		int result;
4648		std::string temp2 ;
4649		std::string temp3 ;
#	Line 4513 | Line 4657 | static PyObject *_wrap_BossTask_submit(P
4657		PyObject * obj4 = 0 ;
4658		PyObject * obj5 = 0 ;
4659		PyObject * obj6 = 0 ;
4660	+	PyObject * obj7 = 0 ;
4661
4662	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4662	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4663		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4664		if (obj1) {
4665		{
#	Line 4567 | Line 4712 | static PyObject *_wrap_BossTask_submit(P
4712		}
4713		}
4714		if (obj6) {
4715	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4715	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4716	>	if (PyErr_Occurred()) SWIG_fail;
4717	>	}
4718	>	if (obj7) {
4719	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4720		if (PyErr_Occurred()) SWIG_fail;
4721		}
4722		{
4723		try {
4724	<	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
4724	>	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7,arg8);
4725
4726		}catch (const BossSchedFailure & e) {
4727	<	SWIG_exception(SWIG_ValueError, e.what());
4727	>	PyErr_SetString ( SchedulerError, e.what() );
4728	>	return NULL;
4729		}catch (const std::exception& e) {
4730	<	SWIG_exception(SWIG_RuntimeError, e.what());
4730	>	PyErr_SetString ( BossError, e.what() );
4731	>	return NULL;
4732		}
4733		}
4734		resultobj = PyInt_FromLong((long)result);
#	Line 4617 | Line 4768 | static PyObject *_wrap_BossTask_reSubmit
4768		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4769
4770		}catch (const BossSchedFailure & e) {
4771	<	SWIG_exception(SWIG_ValueError, e.what());
4771	>	PyErr_SetString ( SchedulerError, e.what() );
4772	>	return NULL;
4773		}catch (const std::exception& e) {
4774	<	SWIG_exception(SWIG_RuntimeError, e.what());
4774	>	PyErr_SetString ( BossError, e.what() );
4775	>	return NULL;
4776		}
4777		}
4778		resultobj = PyInt_FromLong((long)result);
#	Line 4633 | Line 4786 | static PyObject *_wrap_BossTask_kill(PyO
4786		PyObject *resultobj;
4787		BossTask *arg1 = (BossTask *) 0 ;
4788		std::string *arg2 = 0 ;
4789	<	bool arg3 = (bool) false ;
4789	>	unsigned int arg3 = (unsigned int) 0 ;
4790	>	bool arg4 = (bool) false ;
4791		int result;
4792		std::string temp2 ;
4793		PyObject * obj0 = 0 ;
4794		PyObject * obj1 = 0 ;
4795		PyObject * obj2 = 0 ;
4796	+	PyObject * obj3 = 0 ;
4797
4798	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4798	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
4799		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4800		{
4801		if (PyString_Check(obj1)) {
#	Line 4651 | Line 4806 | static PyObject *_wrap_BossTask_kill(PyO
4806		}
4807		}
4808		if (obj2) {
4809	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4809	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
4810	>	if (PyErr_Occurred()) SWIG_fail;
4811	>	}
4812	>	if (obj3) {
4813	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4814		if (PyErr_Occurred()) SWIG_fail;
4815		}
4816		{
4817		try {
4818	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4818	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
4819
4820		}catch (const BossSchedFailure & e) {
4821	<	SWIG_exception(SWIG_ValueError, e.what());
4821	>	PyErr_SetString ( SchedulerError, e.what() );
4822	>	return NULL;
4823		}catch (const std::exception& e) {
4824	<	SWIG_exception(SWIG_RuntimeError, e.what());
4824	>	PyErr_SetString ( BossError, e.what() );
4825	>	return NULL;
4826		}
4827		}
4828		resultobj = PyInt_FromLong((long)result);
#	Line 4678 | Line 4839 | static PyObject *_wrap_BossTask_getOutpu
4839		std::string *arg2 = (std::string *) &arg2_defvalue ;
4840		std::string const &arg3_defvalue = "" ;
4841		std::string *arg3 = (std::string *) &arg3_defvalue ;
4842	<	bool arg4 = (bool) false ;
4842	>	unsigned int arg4 = (unsigned int) 0 ;
4843		bool arg5 = (bool) false ;
4844	+	bool arg6 = (bool) false ;
4845		int result;
4846		std::string temp2 ;
4847		std::string temp3 ;
#	Line 4688 | Line 4850 | static PyObject *_wrap_BossTask_getOutpu
4850		PyObject * obj2 = 0 ;
4851		PyObject * obj3 = 0 ;
4852		PyObject * obj4 = 0 ;
4853	+	PyObject * obj5 = 0 ;
4854
4855	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4855	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
4856		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4857		if (obj1) {
4858		{
#	Line 4712 | Line 4875 | static PyObject *_wrap_BossTask_getOutpu
4875		}
4876		}
4877		if (obj3) {
4878	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4878	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
4879		if (PyErr_Occurred()) SWIG_fail;
4880		}
4881		if (obj4) {
4882		arg5 = PyInt_AsLong(obj4) ? true : false;
4883		if (PyErr_Occurred()) SWIG_fail;
4884		}
4885	+	if (obj5) {
4886	+	arg6 = PyInt_AsLong(obj5) ? true : false;
4887	+	if (PyErr_Occurred()) SWIG_fail;
4888	+	}
4889		{
4890		try {
4891	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4891	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
4892
4893		}catch (const BossSchedFailure & e) {
4894	<	SWIG_exception(SWIG_ValueError, e.what());
4894	>	PyErr_SetString ( SchedulerError, e.what() );
4895	>	return NULL;
4896		}catch (const std::exception& e) {
4897	<	SWIG_exception(SWIG_RuntimeError, e.what());
4897	>	PyErr_SetString ( BossError, e.what() );
4898	>	return NULL;
4899		}
4900		}
4901		resultobj = PyInt_FromLong((long)result);
#	Line 4818 | Line 4987 | static PyObject *_wrap_BossTask_load(PyO
4987		result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4988
4989		}catch (const BossSchedFailure & e) {
4990	<	SWIG_exception(SWIG_ValueError, e.what());
4990	>	PyErr_SetString ( SchedulerError, e.what() );
4991	>	return NULL;
4992		}catch (const std::exception& e) {
4993	<	SWIG_exception(SWIG_RuntimeError, e.what());
4993	>	PyErr_SetString ( BossError, e.what() );
4994	>	return NULL;
4995		}
4996		}
4997		resultobj = PyInt_FromLong((long)result);
#	Line 4842 | Line 5013 | static PyObject *_wrap_BossTask_query(Py
5013		std::string arg6 = (std::string) "" ;
5014		std::string arg7 = (std::string) "" ;
5015		std::string arg8 = (std::string) "" ;
5016	<	bool arg9 = (bool) false ;
5016	>	unsigned int arg9 = (unsigned int) 0 ;
5017	>	bool arg10 = (bool) false ;
5018		int result;
5019		std::string temp3 ;
5020		std::string temp4 ;
#	Line 4854 | Line 5026 | static PyObject *_wrap_BossTask_query(Py
5026		PyObject * obj6 = 0 ;
5027		PyObject * obj7 = 0 ;
5028		PyObject * obj8 = 0 ;
5029	+	PyObject * obj9 = 0 ;
5030
5031	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5031	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5032		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5033		if (obj2) {
5034		{
#	Line 4910 | Line 5083 | static PyObject *_wrap_BossTask_query(Py
5083		}
5084		}
5085		if (obj8) {
5086	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5086	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5087	>	if (PyErr_Occurred()) SWIG_fail;
5088	>	}
5089	>	if (obj9) {
5090	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5091		if (PyErr_Occurred()) SWIG_fail;
5092		}
5093		{
5094		try {
5095	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5095	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5096
5097		}catch (const BossSchedFailure & e) {
5098	<	SWIG_exception(SWIG_ValueError, e.what());
5098	>	PyErr_SetString ( SchedulerError, e.what() );
5099	>	return NULL;
5100		}catch (const std::exception& e) {
5101	<	SWIG_exception(SWIG_RuntimeError, e.what());
5101	>	PyErr_SetString ( BossError, e.what() );
5102	>	return NULL;
5103		}
5104		}
5105		resultobj = PyInt_FromLong((long)result);
#	Line 4979 | Line 5158 | static PyObject *_wrap_BossTask_query_ou
5158		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5159
5160		}catch (const BossSchedFailure & e) {
5161	<	SWIG_exception(SWIG_ValueError, e.what());
5161	>	PyErr_SetString ( SchedulerError, e.what() );
5162	>	return NULL;
5163		}catch (const std::exception& e) {
5164	<	SWIG_exception(SWIG_RuntimeError, e.what());
5164	>	PyErr_SetString ( BossError, e.what() );
5165	>	return NULL;
5166		}
5167		}
5168		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5003 | Line 5184 | static PyObject *_wrap_BossTask_clear(Py
5184		(arg1)->clear();
5185
5186		}catch (const BossSchedFailure & e) {
5187	<	SWIG_exception(SWIG_ValueError, e.what());
5187	>	PyErr_SetString ( SchedulerError, e.what() );
5188	>	return NULL;
5189		}catch (const std::exception& e) {
5190	<	SWIG_exception(SWIG_RuntimeError, e.what());
5190	>	PyErr_SetString ( BossError, e.what() );
5191	>	return NULL;
5192		}
5193		}
5194		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5015 | Line 5198 | static PyObject *_wrap_BossTask_clear(Py
5198		}
5199
5200
5201	+	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5202	+	PyObject *resultobj;
5203	+	BossTask *arg1 = (BossTask *) 0 ;
5204	+	PyObject *arg2 = (PyObject *) 0 ;
5205	+	BossAttributeContainer *arg3 = 0 ;
5206	+	PyObject *result;
5207	+	PyObject * obj0 = 0 ;
5208	+	PyObject * obj1 = 0 ;
5209	+	PyObject * obj2 = 0 ;
5210	+
5211	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5212	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5213	+	arg2 = obj1;
5214	+	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5215	+	if (arg3 == NULL) {
5216	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5217	+	}
5218	+	{
5219	+	try {
5220	+	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5221	+
5222	+	}catch (const BossSchedFailure & e) {
5223	+	PyErr_SetString ( SchedulerError, e.what() );
5224	+	return NULL;
5225	+	}catch (const std::exception& e) {
5226	+	PyErr_SetString ( BossError, e.what() );
5227	+	return NULL;
5228	+	}
5229	+	}
5230	+	resultobj = result;
5231	+	return resultobj;
5232	+	fail:
5233	+	return NULL;
5234	+	}
5235	+
5236	+
5237	+	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5238	+	PyObject *resultobj;
5239	+	BossTask *arg1 = (BossTask *) 0 ;
5240	+	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5241	+	PyObject *result;
5242	+	PyObject * obj0 = 0 ;
5243	+	PyObject * obj1 = 0 ;
5244	+
5245	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5246	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5247	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5248	+	if (arg2 == NULL) {
5249	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5250	+	}
5251	+	{
5252	+	try {
5253	+	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5254	+
5255	+	}catch (const BossSchedFailure & e) {
5256	+	PyErr_SetString ( SchedulerError, e.what() );
5257	+	return NULL;
5258	+	}catch (const std::exception& e) {
5259	+	PyErr_SetString ( BossError, e.what() );
5260	+	return NULL;
5261	+	}
5262	+	}
5263	+	resultobj = result;
5264	+	return resultobj;
5265	+	fail:
5266	+	return NULL;
5267	+	}
5268	+
5269	+
5270	+	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5271	+	PyObject *resultobj;
5272	+	BossTask *arg1 = (BossTask *) 0 ;
5273	+	PyObject *result;
5274	+	PyObject * obj0 = 0 ;
5275	+
5276	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5277	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5278	+	{
5279	+	try {
5280	+	result = (PyObject *)BossTask_jobsDict(arg1);
5281	+
5282	+	}catch (const BossSchedFailure & e) {
5283	+	PyErr_SetString ( SchedulerError, e.what() );
5284	+	return NULL;
5285	+	}catch (const std::exception& e) {
5286	+	PyErr_SetString ( BossError, e.what() );
5287	+	return NULL;
5288	+	}
5289	+	}
5290	+	resultobj = result;
5291	+	return resultobj;
5292	+	fail:
5293	+	return NULL;
5294	+	}
5295	+
5296	+
5297	+	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5298	+	PyObject *resultobj;
5299	+	BossTask *arg1 = (BossTask *) 0 ;
5300	+	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5301	+	PyObject *result;
5302	+	PyObject * obj0 = 0 ;
5303	+	PyObject * obj1 = 0 ;
5304	+
5305	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5306	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5307	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5308	+	if (arg2 == NULL) {
5309	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5310	+	}
5311	+	{
5312	+	try {
5313	+	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5314	+
5315	+	}catch (const BossSchedFailure & e) {
5316	+	PyErr_SetString ( SchedulerError, e.what() );
5317	+	return NULL;
5318	+	}catch (const std::exception& e) {
5319	+	PyErr_SetString ( BossError, e.what() );
5320	+	return NULL;
5321	+	}
5322	+	}
5323	+	resultobj = result;
5324	+	return resultobj;
5325	+	fail:
5326	+	return NULL;
5327	+	}
5328	+
5329	+
5330	+	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5331	+	PyObject *resultobj;
5332	+	BossTask *arg1 = (BossTask *) 0 ;
5333	+	std::string *arg2 = 0 ;
5334	+	PyObject *result;
5335	+	std::string temp2 ;
5336	+	PyObject * obj0 = 0 ;
5337	+	PyObject * obj1 = 0 ;
5338	+
5339	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5340	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5341	+	{
5342	+	if (PyString_Check(obj1)) {
5343	+	temp2 = std::string(PyString_AsString(obj1));
5344	+	arg2 = &temp2;
5345	+	}else {
5346	+	SWIG_exception(SWIG_TypeError, "string expected");
5347	+	}
5348	+	}
5349	+	{
5350	+	try {
5351	+	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5352	+
5353	+	}catch (const BossSchedFailure & e) {
5354	+	PyErr_SetString ( SchedulerError, e.what() );
5355	+	return NULL;
5356	+	}catch (const std::exception& e) {
5357	+	PyErr_SetString ( BossError, e.what() );
5358	+	return NULL;
5359	+	}
5360	+	}
5361	+	resultobj = result;
5362	+	return resultobj;
5363	+	fail:
5364	+	return NULL;
5365	+	}
5366	+
5367	+
5368		static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5369		PyObject *obj;
5370		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 5078 | Line 5428 | static PyObject *_wrap_new_BossAdministr
5428		result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5429
5430		}catch (const BossSchedFailure & e) {
5431	<	SWIG_exception(SWIG_ValueError, e.what());
5431	>	PyErr_SetString ( SchedulerError, e.what() );
5432	>	return NULL;
5433		}catch (const std::exception& e) {
5434	<	SWIG_exception(SWIG_RuntimeError, e.what());
5434	>	PyErr_SetString ( BossError, e.what() );
5435	>	return NULL;
5436		}
5437		}
5438		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 5102 | Line 5454 | static PyObject *_wrap_delete_BossAdmini
5454		delete arg1;
5455
5456		}catch (const BossSchedFailure & e) {
5457	<	SWIG_exception(SWIG_ValueError, e.what());
5457	>	PyErr_SetString ( SchedulerError, e.what() );
5458	>	return NULL;
5459		}catch (const std::exception& e) {
5460	<	SWIG_exception(SWIG_RuntimeError, e.what());
5460	>	PyErr_SetString ( BossError, e.what() );
5461	>	return NULL;
5462		}
5463		}
5464		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5127 | Line 5481 | static PyObject *_wrap_BossAdministrator
5481		result = (int)(arg1)->configureDB();
5482
5483		}catch (const BossSchedFailure & e) {
5484	<	SWIG_exception(SWIG_ValueError, e.what());
5484	>	PyErr_SetString ( SchedulerError, e.what() );
5485	>	return NULL;
5486		}catch (const std::exception& e) {
5487	<	SWIG_exception(SWIG_RuntimeError, e.what());
5487	>	PyErr_SetString ( BossError, e.what() );
5488	>	return NULL;
5489		}
5490		}
5491		resultobj = PyInt_FromLong((long)result);
#	Line 5163 | Line 5519 | static PyObject *_wrap_BossAdministrator
5519		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5520
5521		}catch (const BossSchedFailure & e) {
5522	<	SWIG_exception(SWIG_ValueError, e.what());
5522	>	PyErr_SetString ( SchedulerError, e.what() );
5523	>	return NULL;
5524		}catch (const std::exception& e) {
5525	<	SWIG_exception(SWIG_RuntimeError, e.what());
5525	>	PyErr_SetString ( BossError, e.what() );
5526	>	return NULL;
5527		}
5528		}
5529		resultobj = PyInt_FromLong((long)result);
#	Line 5199 | Line 5557 | static PyObject *_wrap_BossAdministrator
5557		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5558
5559		}catch (const BossSchedFailure & e) {
5560	<	SWIG_exception(SWIG_ValueError, e.what());
5560	>	PyErr_SetString ( SchedulerError, e.what() );
5561	>	return NULL;
5562		}catch (const std::exception& e) {
5563	<	SWIG_exception(SWIG_RuntimeError, e.what());
5563	>	PyErr_SetString ( BossError, e.what() );
5564	>	return NULL;
5565		}
5566		}
5567		resultobj = PyInt_FromLong((long)result);
#	Line 5235 | Line 5595 | static PyObject *_wrap_BossAdministrator
5595		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5596
5597		}catch (const BossSchedFailure & e) {
5598	<	SWIG_exception(SWIG_ValueError, e.what());
5598	>	PyErr_SetString ( SchedulerError, e.what() );
5599	>	return NULL;
5600		}catch (const std::exception& e) {
5601	<	SWIG_exception(SWIG_RuntimeError, e.what());
5601	>	PyErr_SetString ( BossError, e.what() );
5602	>	return NULL;
5603		}
5604		}
5605		resultobj = PyInt_FromLong((long)result);
#	Line 5271 | Line 5633 | static PyObject *_wrap_BossAdministrator
5633		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5634
5635		}catch (const BossSchedFailure & e) {
5636	<	SWIG_exception(SWIG_ValueError, e.what());
5636	>	PyErr_SetString ( SchedulerError, e.what() );
5637	>	return NULL;
5638		}catch (const std::exception& e) {
5639	<	SWIG_exception(SWIG_RuntimeError, e.what());
5639	>	PyErr_SetString ( BossError, e.what() );
5640	>	return NULL;
5641		}
5642		}
5643		resultobj = PyInt_FromLong((long)result);
#	Line 5307 | Line 5671 | static PyObject *_wrap_BossAdministrator
5671		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5672
5673		}catch (const BossSchedFailure & e) {
5674	<	SWIG_exception(SWIG_ValueError, e.what());
5674	>	PyErr_SetString ( SchedulerError, e.what() );
5675	>	return NULL;
5676		}catch (const std::exception& e) {
5677	<	SWIG_exception(SWIG_RuntimeError, e.what());
5677	>	PyErr_SetString ( BossError, e.what() );
5678	>	return NULL;
5679		}
5680		}
5681		resultobj = PyInt_FromLong((long)result);
#	Line 5375 | Line 5741 | static PyObject *_wrap_BossAdministrator
5741		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5742
5743		}catch (const BossSchedFailure & e) {
5744	<	SWIG_exception(SWIG_ValueError, e.what());
5744	>	PyErr_SetString ( SchedulerError, e.what() );
5745	>	return NULL;
5746		}catch (const std::exception& e) {
5747	<	SWIG_exception(SWIG_RuntimeError, e.what());
5747	>	PyErr_SetString ( BossError, e.what() );
5748	>	return NULL;
5749		}
5750		}
5751		resultobj = PyInt_FromLong((long)result);
#	Line 5467 | Line 5835 | static PyObject *_wrap_BossAdministrator
5835		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5836
5837		}catch (const BossSchedFailure & e) {
5838	<	SWIG_exception(SWIG_ValueError, e.what());
5838	>	PyErr_SetString ( SchedulerError, e.what() );
5839	>	return NULL;
5840		}catch (const std::exception& e) {
5841	<	SWIG_exception(SWIG_RuntimeError, e.what());
5841	>	PyErr_SetString ( BossError, e.what() );
5842	>	return NULL;
5843		}
5844		}
5845		resultobj = PyInt_FromLong((long)result);
#	Line 5545 | Line 5915 | static PyObject *_wrap_BossAdministrator
5915		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5916
5917		}catch (const BossSchedFailure & e) {
5918	<	SWIG_exception(SWIG_ValueError, e.what());
5918	>	PyErr_SetString ( SchedulerError, e.what() );
5919	>	return NULL;
5920		}catch (const std::exception& e) {
5921	<	SWIG_exception(SWIG_RuntimeError, e.what());
5921	>	PyErr_SetString ( BossError, e.what() );
5922	>	return NULL;
5923		}
5924		}
5925		resultobj = PyInt_FromLong((long)result);
#	Line 5719 | Line 6091 | static PyObject *_wrap_BossAdministrator
6091		result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15,arg16,arg17);
6092
6093		}catch (const BossSchedFailure & e) {
6094	<	SWIG_exception(SWIG_ValueError, e.what());
6094	>	PyErr_SetString ( SchedulerError, e.what() );
6095	>	return NULL;
6096		}catch (const std::exception& e) {
6097	<	SWIG_exception(SWIG_RuntimeError, e.what());
6097	>	PyErr_SetString ( BossError, e.what() );
6098	>	return NULL;
6099		}
6100		}
6101		resultobj = PyInt_FromLong((long)result);
#	Line 5744 | Line 6118 | static PyObject *_wrap_BossAdministrator
6118		result = (arg1)->help();
6119
6120		}catch (const BossSchedFailure & e) {
6121	<	SWIG_exception(SWIG_ValueError, e.what());
6121	>	PyErr_SetString ( SchedulerError, e.what() );
6122	>	return NULL;
6123		}catch (const std::exception& e) {
6124	<	SWIG_exception(SWIG_RuntimeError, e.what());
6124	>	PyErr_SetString ( BossError, e.what() );
6125	>	return NULL;
6126		}
6127		}
6128		{
#	Line 5785 | Line 6161 | static PyObject *_wrap_BossAdministrator
6161		result = (arg1)->SQL(arg2,arg3);
6162
6163		}catch (const BossSchedFailure & e) {
6164	<	SWIG_exception(SWIG_ValueError, e.what());
6164	>	PyErr_SetString ( SchedulerError, e.what() );
6165	>	return NULL;
6166		}catch (const std::exception& e) {
6167	<	SWIG_exception(SWIG_RuntimeError, e.what());
6167	>	PyErr_SetString ( BossError, e.what() );
6168	>	return NULL;
6169		}
6170		}
6171		{
#	Line 5859 | Line 6237 | static PyObject *_wrap_BossAdministrator
6237		result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6238
6239		}catch (const BossSchedFailure & e) {
6240	<	SWIG_exception(SWIG_ValueError, e.what());
6240	>	PyErr_SetString ( SchedulerError, e.what() );
6241	>	return NULL;
6242		}catch (const std::exception& e) {
6243	<	SWIG_exception(SWIG_RuntimeError, e.what());
6243	>	PyErr_SetString ( BossError, e.what() );
6244	>	return NULL;
6245		}
6246		}
6247		resultobj = PyInt_FromLong((long)result);
#	Line 5892 | Line 6272 | static PyObject *_wrap_BossAdministrator
6272		result = (int)(arg1)->registerPlugins(arg2);
6273
6274		}catch (const BossSchedFailure & e) {
6275	<	SWIG_exception(SWIG_ValueError, e.what());
6275	>	PyErr_SetString ( SchedulerError, e.what() );
6276	>	return NULL;
6277		}catch (const std::exception& e) {
6278	<	SWIG_exception(SWIG_RuntimeError, e.what());
6278	>	PyErr_SetString ( BossError, e.what() );
6279	>	return NULL;
6280		}
6281		}
6282		resultobj = PyInt_FromLong((long)result);
#	Line 5941 | Line 6323 | static PyMethodDef SwigMethods[] = {
6323		{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6324		{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6325		{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5944	–	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5945	–	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5946	–	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5947	–	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5948	–	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5949	–	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5950	–	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6326		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6327		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6328		{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6329		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6330		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6331		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6332	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6333	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6334	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6335	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6336		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6337		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6338		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5966 | Line 6345 | static PyMethodDef SwigMethods[] = {
6345		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6346		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6347		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6348	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6349	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6350	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6351	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6352	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6353	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6354	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6355		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6356		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6357		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5973 | Line 6359 | static PyMethodDef SwigMethods[] = {
6359		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6360		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6361		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5976	–	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5977	–	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5978	–	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
5979	–	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5980	–	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6362		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6363		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6364		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
#	Line 6000 | Line 6381 | static PyMethodDef SwigMethods[] = {
6381		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6382		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6383		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6384	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6385	+	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6386	+	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6387	+	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6388	+	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6389		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6390		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6391		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 6024 | Line 6410 | static PyMethodDef SwigMethods[] = {
6410
6411		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6412
6413	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6414		static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t", 0, "std::vector<std::pair<BossProgram,BossProgramExec > > *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t"},{0}};
6415		static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator", 0, "std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator"},{0}};
6029	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6416		static swig_type_info _swigt__p_std__vectorTBossTask_p_t[] = {{"_p_std__vectorTBossTask_p_t", 0, "std::vector<BossTask * > *", 0},{"_p_std__vectorTBossTask_p_t"},{0}};
6417		static swig_type_info _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t[] = {{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t", 0, "std::map<std::string,std::map<std::string,std::string > > *", 0},{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t"},{0}};
6418	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6419		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6420		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
6034	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6035	–	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6421		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6422	+	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6423		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6424		static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6425		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6426		static swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0},{"_p_std__vectorTstd__string_t"},{0}};
6427		static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
6428		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
6043	–	static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
6429		static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
6430	+	static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
6431		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6432
6433		static swig_type_info *swig_types_initial[] = {
6434	+	_swigt__p_XMLDoc,
6435		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6436		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6050	–	_swigt__p_XMLDoc,
6437		_swigt__p_std__vectorTBossTask_p_t,
6438		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6439	+	_swigt__p_std__ostream,
6440		_swigt__p_BossTask,
6441		_swigt__p_BossTaskException,
6055	–	_swigt__p_std__ostream,
6056	–	_swigt__p_BossAttributeContainer,
6442		_swigt__p_printOption,
6443	+	_swigt__p_BossAttributeContainer,
6444		_swigt__p_BossJob,
6445		_swigt__p_BossDatabase,
6446		_swigt__p_BossSession,
6447		_swigt__p_std__vectorTstd__string_t,
6448		_swigt__p_std__mapTstd__string_std__string_t,
6449		_swigt__p_BossAdministratorSession,
6064	–	_swigt__p_BossTask__job_iterator,
6450		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6451	+	_swigt__p_BossTask__job_iterator,
6452		_swigt__p_jobStates,
6453		0
6454		};
#	Line 6106 | Line 6492 | SWIGEXPORT(void) SWIG_init(void) {
6492		}
6493		SWIG_InstallConstants(d,swig_const_table);
6494
6495	+
6496	+	// define custom exceptions
6497	+	PyObject *e;
6498	+	PyMethodDef tp_methods = {
6499	+	NULL, NULL, 0, NULL
6500	+	};
6501	+	e = Py_InitModule("BossSession", &tp_methods);
6502	+	// generic BOSS exception
6503	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6504	+	Py_INCREF(BossError);
6505	+	PyModule_AddObject(e, "BossError", BossError);
6506	+	// scheduler interaction BOSS exception
6507	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6508	+	Py_INCREF(SchedulerError);
6509	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6510	+
6511		}
6512

Diff Legend

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