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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.13 by gcodispo, Fri Nov 3 15:03:10 2006 UTC vs.
Revision 1.19 by gcodispo, Wed Dec 13 18:26:33 2006 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 927 \| Line 929 \| void std_vectorlstd_string_g___delslice_
929		#include "BossProgram.h"
930		#include "BossProgramExec.h"
931		#include "BossDatabase.h"
932	+	#include "BossScheduler.h"
933	+	#include "BossDeclaration.h"
934
935		PyObject BossSession_show(BossSession self,std::vector<std::string > &my_vec){
936		PyObject * my_list = PyList_New( my_vec.size());
#	Line 1084 \| Line 1088 \| *static PyObject _wrap_new_objectMap__SW**
1088		try {
1089		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1090
1091	+	}catch (const BossSchedFailure & e) {
1092	+	PyErr_SetString ( SchedulerError, e.what() );
1093	+	return NULL;
1094		}catch (const std::exception& e) {
1095	<	SWIG_exception(SWIG_RuntimeError, e.what());
1095	>	PyErr_SetString ( BossError, e.what() );
1096	>	return NULL;
1097		}
1098		}
1099		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1143 \| Line 1151 \| *static PyObject _wrap_new_objectMap__SW**
1151		try {
1152		result = (std::map<std::string,std::string > )new std::map<std::string,std::string >((std::map<std::string,std::string > const &)arg1);
1153
1154	+	}catch (const BossSchedFailure & e) {
1155	+	PyErr_SetString ( SchedulerError, e.what() );
1156	+	return NULL;
1157		}catch (const std::exception& e) {
1158	<	SWIG_exception(SWIG_RuntimeError, e.what());
1158	>	PyErr_SetString ( BossError, e.what() );
1159	>	return NULL;
1160		}
1161		}
1162		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1258 \| Line 1270 \| *static PyObject _wrap_objectMap___len__**
1270		try {
1271		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1272
1273	+	}catch (const BossSchedFailure & e) {
1274	+	PyErr_SetString ( SchedulerError, e.what() );
1275	+	return NULL;
1276		}catch (const std::exception& e) {
1277	<	SWIG_exception(SWIG_RuntimeError, e.what());
1277	>	PyErr_SetString ( BossError, e.what() );
1278	>	return NULL;
1279		}
1280		}
1281		resultobj = PyInt_FromLong((long)result);
#	Line 1280 \| Line 1296 \| *static PyObject _wrap_objectMap_clear(P**
1296		try {
1297		(arg1)->clear();
1298
1299	+	}catch (const BossSchedFailure & e) {
1300	+	PyErr_SetString ( SchedulerError, e.what() );
1301	+	return NULL;
1302		}catch (const std::exception& e) {
1303	<	SWIG_exception(SWIG_RuntimeError, e.what());
1303	>	PyErr_SetString ( BossError, e.what() );
1304	>	return NULL;
1305		}
1306		}
1307		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1303 \| Line 1323 \| *static PyObject _wrap_objectMap___nonze**
1323		try {
1324		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1325
1326	+	}catch (const BossSchedFailure & e) {
1327	+	PyErr_SetString ( SchedulerError, e.what() );
1328	+	return NULL;
1329		}catch (const std::exception& e) {
1330	<	SWIG_exception(SWIG_RuntimeError, e.what());
1330	>	PyErr_SetString ( BossError, e.what() );
1331	>	return NULL;
1332		}
1333		}
1334		resultobj = PyInt_FromLong((long)result);
#	Line 1375 \| Line 1399 \| *static PyObject _wrap_objectMap___setit**
1399		try {
1400		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1401
1402	+	}catch (const BossSchedFailure & e) {
1403	+	PyErr_SetString ( SchedulerError, e.what() );
1404	+	return NULL;
1405		}catch (const std::exception& e) {
1406	<	SWIG_exception(SWIG_RuntimeError, e.what());
1406	>	PyErr_SetString ( BossError, e.what() );
1407	>	return NULL;
1408		}
1409		}
1410		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1437 \| Line 1465 \| *static PyObject _wrap_objectMap_has_key**
1465		try {
1466		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1467
1468	+	}catch (const BossSchedFailure & e) {
1469	+	PyErr_SetString ( SchedulerError, e.what() );
1470	+	return NULL;
1471		}catch (const std::exception& e) {
1472	<	SWIG_exception(SWIG_RuntimeError, e.what());
1472	>	PyErr_SetString ( BossError, e.what() );
1473	>	return NULL;
1474		}
1475		}
1476		resultobj = PyInt_FromLong((long)result);
#	Line 1460 \| Line 1492 \| *static PyObject _wrap_objectMap_keys(Py**
1492		try {
1493		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1494
1495	+	}catch (const BossSchedFailure & e) {
1496	+	PyErr_SetString ( SchedulerError, e.what() );
1497	+	return NULL;
1498		}catch (const std::exception& e) {
1499	<	SWIG_exception(SWIG_RuntimeError, e.what());
1499	>	PyErr_SetString ( BossError, e.what() );
1500	>	return NULL;
1501		}
1502		}
1503		resultobj = result;
#	Line 1483 \| Line 1519 \| *static PyObject _wrap_objectMap_values(**
1519		try {
1520		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1521
1522	+	}catch (const BossSchedFailure & e) {
1523	+	PyErr_SetString ( SchedulerError, e.what() );
1524	+	return NULL;
1525		}catch (const std::exception& e) {
1526	<	SWIG_exception(SWIG_RuntimeError, e.what());
1526	>	PyErr_SetString ( BossError, e.what() );
1527	>	return NULL;
1528		}
1529		}
1530		resultobj = result;
#	Line 1506 \| Line 1546 \| *static PyObject _wrap_objectMap_items(P**
1546		try {
1547		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1548
1549	+	}catch (const BossSchedFailure & e) {
1550	+	PyErr_SetString ( SchedulerError, e.what() );
1551	+	return NULL;
1552		}catch (const std::exception& e) {
1553	<	SWIG_exception(SWIG_RuntimeError, e.what());
1553	>	PyErr_SetString ( BossError, e.what() );
1554	>	return NULL;
1555		}
1556		}
1557		resultobj = result;
#	Line 1537 \| Line 1581 \| *static PyObject _wrap_objectMap___conta**
1581		try {
1582		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1583
1584	+	}catch (const BossSchedFailure & e) {
1585	+	PyErr_SetString ( SchedulerError, e.what() );
1586	+	return NULL;
1587		}catch (const std::exception& e) {
1588	<	SWIG_exception(SWIG_RuntimeError, e.what());
1588	>	PyErr_SetString ( BossError, e.what() );
1589	>	return NULL;
1590		}
1591		}
1592		resultobj = PyInt_FromLong((long)result);
#	Line 1583 \| Line 1631 \| *static PyObject _wrap_delete_objectMap(**
1631		try {
1632		delete arg1;
1633
1634	+	}catch (const BossSchedFailure & e) {
1635	+	PyErr_SetString ( SchedulerError, e.what() );
1636	+	return NULL;
1637		}catch (const std::exception& e) {
1638	<	SWIG_exception(SWIG_RuntimeError, e.what());
1638	>	PyErr_SetString ( BossError, e.what() );
1639	>	return NULL;
1640		}
1641		}
1642		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1616 \| Line 1668 \| *static PyObject _wrap_new_vector_string**
1668		try {
1669		result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1670
1671	+	}catch (const BossSchedFailure & e) {
1672	+	PyErr_SetString ( SchedulerError, e.what() );
1673	+	return NULL;
1674		}catch (const std::exception& e) {
1675	<	SWIG_exception(SWIG_RuntimeError, e.what());
1675	>	PyErr_SetString ( BossError, e.what() );
1676	>	return NULL;
1677		}
1678		}
1679		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1651 \| Line 1707 \| *static PyObject _wrap_new_vector_string**
1707		try {
1708		result = (std::vector<std::string > )new std::vector<std::string >(arg1,(std::string const &)arg2);
1709
1710	+	}catch (const BossSchedFailure & e) {
1711	+	PyErr_SetString ( SchedulerError, e.what() );
1712	+	return NULL;
1713		}catch (const std::exception& e) {
1714	<	SWIG_exception(SWIG_RuntimeError, e.what());
1714	>	PyErr_SetString ( BossError, e.what() );
1715	>	return NULL;
1716		}
1717		}
1718		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1703 \| Line 1763 \| *static PyObject _wrap_new_vector_string**
1763		try {
1764		result = (std::vector<std::string > )new std::vector<std::string >((std::vector<std::string > const &)arg1);
1765
1766	+	}catch (const BossSchedFailure & e) {
1767	+	PyErr_SetString ( SchedulerError, e.what() );
1768	+	return NULL;
1769		}catch (const std::exception& e) {
1770	<	SWIG_exception(SWIG_RuntimeError, e.what());
1770	>	PyErr_SetString ( BossError, e.what() );
1771	>	return NULL;
1772		}
1773		}
1774		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1830 \| Line 1894 \| *static PyObject _wrap_vector_string___l**
1894		try {
1895		result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1896
1897	+	}catch (const BossSchedFailure & e) {
1898	+	PyErr_SetString ( SchedulerError, e.what() );
1899	+	return NULL;
1900		}catch (const std::exception& e) {
1901	<	SWIG_exception(SWIG_RuntimeError, e.what());
1901	>	PyErr_SetString ( BossError, e.what() );
1902	>	return NULL;
1903		}
1904		}
1905		resultobj = PyInt_FromLong((long)result);
#	Line 1882 \| Line 1950 \| *static PyObject _wrap_vector_string___n**
1950		try {
1951		result = (bool)((std::vector<std::string > const *)arg1)->empty();
1952
1953	+	}catch (const BossSchedFailure & e) {
1954	+	PyErr_SetString ( SchedulerError, e.what() );
1955	+	return NULL;
1956		}catch (const std::exception& e) {
1957	<	SWIG_exception(SWIG_RuntimeError, e.what());
1957	>	PyErr_SetString ( BossError, e.what() );
1958	>	return NULL;
1959		}
1960		}
1961		resultobj = PyInt_FromLong((long)result);
#	Line 1904 \| Line 1976 \| *static PyObject _wrap_vector_string_cle**
1976		try {
1977		(arg1)->clear();
1978
1979	+	}catch (const BossSchedFailure & e) {
1980	+	PyErr_SetString ( SchedulerError, e.what() );
1981	+	return NULL;
1982		}catch (const std::exception& e) {
1983	<	SWIG_exception(SWIG_RuntimeError, e.what());
1983	>	PyErr_SetString ( BossError, e.what() );
1984	>	return NULL;
1985		}
1986		}
1987		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1934 \| Line 2010 \| *static PyObject _wrap_vector_string_app**
2010		try {
2011		(arg1)->push_back(arg2);
2012
2013	+	}catch (const BossSchedFailure & e) {
2014	+	PyErr_SetString ( SchedulerError, e.what() );
2015	+	return NULL;
2016		}catch (const std::exception& e) {
2017	<	SWIG_exception(SWIG_RuntimeError, e.what());
2017	>	PyErr_SetString ( BossError, e.what() );
2018	>	return NULL;
2019		}
2020		}
2021		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2010 \| Line 2090 \| *static PyObject _wrap_vector_string___g**
2090		try {
2091		result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2092
2093	+	}catch (const BossSchedFailure & e) {
2094	+	PyErr_SetString ( SchedulerError, e.what() );
2095	+	return NULL;
2096		}catch (const std::exception& e) {
2097	<	SWIG_exception(SWIG_RuntimeError, e.what());
2097	>	PyErr_SetString ( BossError, e.what() );
2098	>	return NULL;
2099		}
2100		}
2101		{
#	Line 2102 \| Line 2186 \| *static PyObject _wrap_vector_string___s**
2186		try {
2187		std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2188
2189	+	}catch (const BossSchedFailure & e) {
2190	+	PyErr_SetString ( SchedulerError, e.what() );
2191	+	return NULL;
2192		}catch (const std::exception& e) {
2193	<	SWIG_exception(SWIG_RuntimeError, e.what());
2193	>	PyErr_SetString ( BossError, e.what() );
2194	>	return NULL;
2195		}
2196		}
2197		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2149 \| Line 2237 \| *static PyObject _wrap_vector_string___d**
2237		try {
2238		std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2239
2240	+	}catch (const BossSchedFailure & e) {
2241	+	PyErr_SetString ( SchedulerError, e.what() );
2242	+	return NULL;
2243		}catch (const std::exception& e) {
2244	<	SWIG_exception(SWIG_RuntimeError, e.what());
2244	>	PyErr_SetString ( BossError, e.what() );
2245	>	return NULL;
2246		}
2247		}
2248		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2171 \| Line 2263 \| *static PyObject _wrap_delete_vector_str**
2263		try {
2264		delete arg1;
2265
2266	+	}catch (const BossSchedFailure & e) {
2267	+	PyErr_SetString ( SchedulerError, e.what() );
2268	+	return NULL;
2269		}catch (const std::exception& e) {
2270	<	SWIG_exception(SWIG_RuntimeError, e.what());
2270	>	PyErr_SetString ( BossError, e.what() );
2271	>	return NULL;
2272		}
2273		}
2274		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2189 \| Line 2285 \| *static PyObject vector_string_swigregi**
2285		Py_INCREF(obj);
2286		return Py_BuildValue((char *)"");
2287		}
2288	<	static PyObject _wrap_BossSession_show(PyObject self, PyObject *args) {
2288	>	static PyObject _wrap_new_BossSession(PyObject self, PyObject *args) {
2289		PyObject *resultobj;
2290	<	BossSession arg1 = (BossSession ) 0 ;
2291	<	std::vector<std::string > *arg2 = 0 ;
2292	<	PyObject *result;
2290	>	std::string arg1 = (std::string) "" ;
2291	>	std::string arg2 = (std::string) "2" ;
2292	>	std::string arg3 = (std::string) "" ;
2293	>	std::string arg4 = (std::string) "" ;
2294	>	BossSession *result;
2295		PyObject * obj0 = 0 ;
2296		PyObject * obj1 = 0 ;
2297	+	PyObject * obj2 = 0 ;
2298	+	PyObject * obj3 = 0 ;
2299
2300	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2301	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2302	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2303	<	if (arg2 == NULL) {
2304	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2300	>	if(!PyArg_ParseTuple(args,(char *)"\|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2301	>	if (obj0) {
2302	>	{
2303	>	if (PyString_Check(obj0))
2304	>	arg1 = std::string(PyString_AsString(obj0));
2305	>	else
2306	>	SWIG_exception(SWIG_TypeError, "string expected");
2307	>	}
2308		}
2309	<	{
2310	<	try {
2311	<	result = (PyObject )BossSession_show(arg1,arg2);
2312	<
2313	<	}catch (const std::exception& e) {
2314	<	SWIG_exception(SWIG_RuntimeError, e.what());
2309	>	if (obj1) {
2310	>	{
2311	>	if (PyString_Check(obj1))
2312	>	arg2 = std::string(PyString_AsString(obj1));
2313	>	else
2314	>	SWIG_exception(SWIG_TypeError, "string expected");
2315	>	}
2316	>	}
2317	>	if (obj2) {
2318	>	{
2319	>	if (PyString_Check(obj2))
2320	>	arg3 = std::string(PyString_AsString(obj2));
2321	>	else
2322	>	SWIG_exception(SWIG_TypeError, "string expected");
2323	>	}
2324	>	}
2325	>	if (obj3) {
2326	>	{
2327	>	if (PyString_Check(obj3))
2328	>	arg4 = std::string(PyString_AsString(obj3));
2329	>	else
2330	>	SWIG_exception(SWIG_TypeError, "string expected");
2331		}
2332		}
2214	–	resultobj = result;
2215	–	return resultobj;
2216	–	fail:
2217	–	return NULL;
2218	–	}
2219	–
2220	–
2221	–	static PyObject _wrap_BossSession_CHTools(PyObject self, PyObject *args) {
2222	–	PyObject *resultobj;
2223	–	BossSession arg1 = (BossSession ) 0 ;
2224	–	PyObject *result;
2225	–	PyObject * obj0 = 0 ;
2226	–
2227	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2228	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2333		{
2334		try {
2335	<	result = (PyObject *)BossSession_CHTools(arg1);
2335	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2336
2337	+	}catch (const BossSchedFailure & e) {
2338	+	PyErr_SetString ( SchedulerError, e.what() );
2339	+	return NULL;
2340		}catch (const std::exception& e) {
2341	<	SWIG_exception(SWIG_RuntimeError, e.what());
2341	>	PyErr_SetString ( BossError, e.what() );
2342	>	return NULL;
2343		}
2344		}
2345	<	resultobj = result;
2345	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2346		return resultobj;
2347		fail:
2348		return NULL;
2349		}
2350
2351
2352	<	static PyObject _wrap_BossSession_ProgramTypes(PyObject self, PyObject *args) {
2352	>	static PyObject _wrap_delete_BossSession(PyObject self, PyObject *args) {
2353		PyObject *resultobj;
2354		BossSession arg1 = (BossSession ) 0 ;
2247	–	PyObject *result;
2355		PyObject * obj0 = 0 ;
2356
2357	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2357	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2358		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2359		{
2360		try {
2361	<	result = (PyObject *)BossSession_ProgramTypes(arg1);
2361	>	delete arg1;
2362
2363	+	}catch (const BossSchedFailure & e) {
2364	+	PyErr_SetString ( SchedulerError, e.what() );
2365	+	return NULL;
2366		}catch (const std::exception& e) {
2367	<	SWIG_exception(SWIG_RuntimeError, e.what());
2367	>	PyErr_SetString ( BossError, e.what() );
2368	>	return NULL;
2369		}
2370		}
2371	<	resultobj = result;
2371	>	Py_INCREF(Py_None); resultobj = Py_None;
2372		return resultobj;
2373		fail:
2374		return NULL;
2375		}
2376
2377
2378	<	static PyObject _wrap_BossSession_RTMons(PyObject self, PyObject *args) {
2378	>	static PyObject _wrap_BossSession_resetDB(PyObject self, PyObject *args) {
2379		PyObject *resultobj;
2380		BossSession arg1 = (BossSession ) 0 ;
2270	–	PyObject *result;
2381		PyObject * obj0 = 0 ;
2382
2383	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2383	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2384		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2385		{
2386		try {
2387	<	result = (PyObject *)BossSession_RTMons(arg1);
2387	>	(arg1)->resetDB();
2388
2389	+	}catch (const BossSchedFailure & e) {
2390	+	PyErr_SetString ( SchedulerError, e.what() );
2391	+	return NULL;
2392		}catch (const std::exception& e) {
2393	<	SWIG_exception(SWIG_RuntimeError, e.what());
2393	>	PyErr_SetString ( BossError, e.what() );
2394	>	return NULL;
2395		}
2396		}
2397	<	resultobj = result;
2397	>	Py_INCREF(Py_None); resultobj = Py_None;
2398		return resultobj;
2399		fail:
2400		return NULL;
2401		}
2402
2403
2404	<	static PyObject _wrap_BossSession_schedulers(PyObject self, PyObject *args) {
2404	>	static PyObject _wrap_BossSession_clear(PyObject self, PyObject *args) {
2405		PyObject *resultobj;
2406		BossSession arg1 = (BossSession ) 0 ;
2293	–	PyObject *result;
2407		PyObject * obj0 = 0 ;
2408
2409	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2409	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2410		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2411		{
2412		try {
2413	<	result = (PyObject *)BossSession_schedulers(arg1);
2413	>	(arg1)->clear();
2414
2415	+	}catch (const BossSchedFailure & e) {
2416	+	PyErr_SetString ( SchedulerError, e.what() );
2417	+	return NULL;
2418		}catch (const std::exception& e) {
2419	<	SWIG_exception(SWIG_RuntimeError, e.what());
2419	>	PyErr_SetString ( BossError, e.what() );
2420	>	return NULL;
2421		}
2422		}
2423	<	resultobj = result;
2423	>	Py_INCREF(Py_None); resultobj = Py_None;
2424		return resultobj;
2425		fail:
2426		return NULL;
2427		}
2428
2429
2430	<	static PyObject _wrap_BossSession_schedListMatch(PyObject self, PyObject *args) {
2430	>	static PyObject _wrap_BossSession_makeBossTask(PyObject self, PyObject *args) {
2431		PyObject *resultobj;
2432		BossSession arg1 = (BossSession ) 0 ;
2433	<	std::string *arg2 = 0 ;
2434	<	std::string *arg3 = 0 ;
2435	<	std::string const &arg4_defvalue = "" ;
2319	<	std::string arg4 = (std::string ) &arg4_defvalue ;
2320	<	std::string const &arg5_defvalue = "" ;
2321	<	std::string arg5 = (std::string ) &arg5_defvalue ;
2322	<	bool arg6 = (bool) false ;
2323	<	PyObject *result;
2433	>	std::string const &arg2_defvalue = "" ;
2434	>	std::string arg2 = (std::string ) &arg2_defvalue ;
2435	>	BossTask *result;
2436		std::string temp2 ;
2325	–	std::string temp3 ;
2326	–	std::string temp4 ;
2327	–	std::string temp5 ;
2437		PyObject * obj0 = 0 ;
2438		PyObject * obj1 = 0 ;
2330	–	PyObject * obj2 = 0 ;
2331	–	PyObject * obj3 = 0 ;
2332	–	PyObject * obj4 = 0 ;
2333	–	PyObject * obj5 = 0 ;
2439
2440	<	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2440	>	if(!PyArg_ParseTuple(args,(char *)"O\|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2441		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2442	<	{
2338	<	if (PyString_Check(obj1)) {
2339	<	temp2 = std::string(PyString_AsString(obj1));
2340	<	arg2 = &temp2;
2341	<	}else {
2342	<	SWIG_exception(SWIG_TypeError, "string expected");
2343	<	}
2344	<	}
2345	<	{
2346	<	if (PyString_Check(obj2)) {
2347	<	temp3 = std::string(PyString_AsString(obj2));
2348	<	arg3 = &temp3;
2349	<	}else {
2350	<	SWIG_exception(SWIG_TypeError, "string expected");
2351	<	}
2352	<	}
2353	<	if (obj3) {
2354	<	{
2355	<	if (PyString_Check(obj3)) {
2356	<	temp4 = std::string(PyString_AsString(obj3));
2357	<	arg4 = &temp4;
2358	<	}else {
2359	<	SWIG_exception(SWIG_TypeError, "string expected");
2360	<	}
2361	<	}
2362	<	}
2363	<	if (obj4) {
2442	>	if (obj1) {
2443		{
2444	<	if (PyString_Check(obj4)) {
2445	<	temp5 = std::string(PyString_AsString(obj4));
2446	<	arg5 = &temp5;
2444	>	if (PyString_Check(obj1)) {
2445	>	temp2 = std::string(PyString_AsString(obj1));
2446	>	arg2 = &temp2;
2447		}else {
2448		SWIG_exception(SWIG_TypeError, "string expected");
2449		}
2450		}
2451		}
2373	–	if (obj5) {
2374	–	arg6 = PyInt_AsLong(obj5) ? true : false;
2375	–	if (PyErr_Occurred()) SWIG_fail;
2376	–	}
2452		{
2453		try {
2454	<	result = (PyObject )BossSession_schedListMatch(arg1,(std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6);
2454	>	result = (BossTask )(arg1)->makeBossTask((std::string const &)arg2);
2455
2456	+	}catch (const BossSchedFailure & e) {
2457	+	PyErr_SetString ( SchedulerError, e.what() );
2458	+	return NULL;
2459		}catch (const std::exception& e) {
2460	<	SWIG_exception(SWIG_RuntimeError, e.what());
2460	>	PyErr_SetString ( BossError, e.what() );
2461	>	return NULL;
2462		}
2463		}
2464	<	resultobj = result;
2464	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2465		return resultobj;
2466		fail:
2467		return NULL;
2468		}
2469
2470
2471	<	static PyObject _wrap_BossSession_queryTasks(PyObject self, PyObject *args) {
2471	>	static PyObject _wrap_BossSession_destroyBossTask(PyObject self, PyObject *args) {
2472		PyObject *resultobj;
2473		BossSession arg1 = (BossSession ) 0 ;
2474	<	int arg2 = (int) SCHEDULED ;
2396	<	std::string const &arg3_defvalue = "all" ;
2397	<	std::string arg3 = (std::string ) &arg3_defvalue ;
2398	<	std::string const &arg4_defvalue = "all" ;
2399	<	std::string arg4 = (std::string ) &arg4_defvalue ;
2400	<	std::string const &arg5_defvalue = "" ;
2401	<	std::string arg5 = (std::string ) &arg5_defvalue ;
2402	<	std::string arg6 = (std::string) "" ;
2403	<	std::string arg7 = (std::string) "" ;
2404	<	std::string arg8 = (std::string) "" ;
2405	<	std::string arg9 = (std::string) "" ;
2406	<	bool arg10 = (bool) false ;
2407	<	PyObject *result;
2408	<	std::string temp3 ;
2409	<	std::string temp4 ;
2410	<	std::string temp5 ;
2474	>	BossTask arg2 = (BossTask ) 0 ;
2475		PyObject * obj0 = 0 ;
2476	<	PyObject * obj2 = 0 ;
2413	<	PyObject * obj3 = 0 ;
2414	<	PyObject * obj4 = 0 ;
2415	<	PyObject * obj5 = 0 ;
2416	<	PyObject * obj6 = 0 ;
2417	<	PyObject * obj7 = 0 ;
2418	<	PyObject * obj8 = 0 ;
2419	<	PyObject * obj9 = 0 ;
2476	>	PyObject * obj1 = 0 ;
2477
2478	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2478	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2479		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2480	<	if (obj2) {
2424	<	{
2425	<	if (PyString_Check(obj2)) {
2426	<	temp3 = std::string(PyString_AsString(obj2));
2427	<	arg3 = &temp3;
2428	<	}else {
2429	<	SWIG_exception(SWIG_TypeError, "string expected");
2430	<	}
2431	<	}
2432	<	}
2433	<	if (obj3) {
2434	<	{
2435	<	if (PyString_Check(obj3)) {
2436	<	temp4 = std::string(PyString_AsString(obj3));
2437	<	arg4 = &temp4;
2438	<	}else {
2439	<	SWIG_exception(SWIG_TypeError, "string expected");
2440	<	}
2441	<	}
2442	<	}
2443	<	if (obj4) {
2444	<	{
2445	<	if (PyString_Check(obj4)) {
2446	<	temp5 = std::string(PyString_AsString(obj4));
2447	<	arg5 = &temp5;
2448	<	}else {
2449	<	SWIG_exception(SWIG_TypeError, "string expected");
2450	<	}
2451	<	}
2452	<	}
2453	<	if (obj5) {
2454	<	{
2455	<	if (PyString_Check(obj5))
2456	<	arg6 = std::string(PyString_AsString(obj5));
2457	<	else
2458	<	SWIG_exception(SWIG_TypeError, "string expected");
2459	<	}
2460	<	}
2461	<	if (obj6) {
2462	<	{
2463	<	if (PyString_Check(obj6))
2464	<	arg7 = std::string(PyString_AsString(obj6));
2465	<	else
2466	<	SWIG_exception(SWIG_TypeError, "string expected");
2467	<	}
2468	<	}
2469	<	if (obj7) {
2470	<	{
2471	<	if (PyString_Check(obj7))
2472	<	arg8 = std::string(PyString_AsString(obj7));
2473	<	else
2474	<	SWIG_exception(SWIG_TypeError, "string expected");
2475	<	}
2476	<	}
2477	<	if (obj8) {
2478	<	{
2479	<	if (PyString_Check(obj8))
2480	<	arg9 = std::string(PyString_AsString(obj8));
2481	<	else
2482	<	SWIG_exception(SWIG_TypeError, "string expected");
2483	<	}
2484	<	}
2485	<	if (obj9) {
2486	<	arg10 = PyInt_AsLong(obj9) ? true : false;
2487	<	if (PyErr_Occurred()) SWIG_fail;
2488	<	}
2489	<	{
2490	<	try {
2491	<	result = (PyObject )BossSession_queryTasks(arg1,arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5,arg6,arg7,arg8,arg9,arg10);
2492	<
2493	<	}catch (const std::exception& e) {
2494	<	SWIG_exception(SWIG_RuntimeError, e.what());
2495	<	}
2496	<	}
2497	<	resultobj = result;
2498	<	return resultobj;
2499	<	fail:
2500	<	return NULL;
2501	<	}
2502	<
2503	<
2504	<	static PyObject _wrap_new_BossSession(PyObject self, PyObject *args) {
2505	<	PyObject *resultobj;
2506	<	std::string arg1 = (std::string) "" ;
2507	<	BossSession *result;
2508	<	PyObject * obj0 = 0 ;
2509	<
2510	<	if(!PyArg_ParseTuple(args,(char *)"\|O:new_BossSession",&obj0)) goto fail;
2511	<	if (obj0) {
2512	<	{
2513	<	if (PyString_Check(obj0))
2514	<	arg1 = std::string(PyString_AsString(obj0));
2515	<	else
2516	<	SWIG_exception(SWIG_TypeError, "string expected");
2517	<	}
2518	<	}
2480	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2481		{
2482		try {
2483	<	result = (BossSession *)new BossSession(arg1);
2483	>	(arg1)->destroyBossTask(arg2);
2484
2485	+	}catch (const BossSchedFailure & e) {
2486	+	PyErr_SetString ( SchedulerError, e.what() );
2487	+	return NULL;
2488		}catch (const std::exception& e) {
2489	<	SWIG_exception(SWIG_RuntimeError, e.what());
2489	>	PyErr_SetString ( BossError, e.what() );
2490	>	return NULL;
2491		}
2492		}
2493	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2493	>	Py_INCREF(Py_None); resultobj = Py_None;
2494		return resultobj;
2495		fail:
2496		return NULL;
2497		}
2498
2499
2500	<	static PyObject _wrap_delete_BossSession(PyObject self, PyObject *args) {
2500	>	static PyObject _wrap_BossSession_showCHTools(PyObject self, PyObject *args) {
2501		PyObject *resultobj;
2502		BossSession arg1 = (BossSession ) 0 ;
2503	+	std::vector<std::string > result;
2504		PyObject * obj0 = 0 ;
2505
2506	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2506	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2507		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2508		{
2509		try {
2510	<	delete arg1;
2510	>	result = (arg1)->showCHTools();
2511
2512	+	}catch (const BossSchedFailure & e) {
2513	+	PyErr_SetString ( SchedulerError, e.what() );
2514	+	return NULL;
2515		}catch (const std::exception& e) {
2516	<	SWIG_exception(SWIG_RuntimeError, e.what());
2516	>	PyErr_SetString ( BossError, e.what() );
2517	>	return NULL;
2518		}
2519		}
2549	–	Py_INCREF(Py_None); resultobj = Py_None;
2550	–	return resultobj;
2551	–	fail:
2552	–	return NULL;
2553	–	}
2554	–
2555	–
2556	–	static PyObject _wrap_BossSession_resetDB(PyObject self, PyObject *args) {
2557	–	PyObject *resultobj;
2558	–	BossSession arg1 = (BossSession ) 0 ;
2559	–	PyObject * obj0 = 0 ;
2560	–
2561	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2562	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2520		{
2521	<	try {
2522	<	(arg1)->resetDB();
2523	<
2524	<	}catch (const std::exception& e) {
2568	<	SWIG_exception(SWIG_RuntimeError, e.what());
2569	<	}
2521	>	resultobj = PyTuple_New((&result)->size());
2522	>	for (unsigned int i=0; i<(&result)->size(); i++)
2523	>	PyTuple_SetItem(resultobj,i,
2524	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2525		}
2571	–	Py_INCREF(Py_None); resultobj = Py_None;
2526		return resultobj;
2527		fail:
2528		return NULL;
2529		}
2530
2531
2532	<	static PyObject _wrap_BossSession_clear(PyObject self, PyObject *args) {
2532	>	static PyObject _wrap_BossSession_showProgramTypes(PyObject self, PyObject *args) {
2533		PyObject *resultobj;
2534		BossSession arg1 = (BossSession ) 0 ;
2535	+	std::vector<std::string > result;
2536		PyObject * obj0 = 0 ;
2537
2538	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2538	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2539		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2540		{
2541		try {
2542	<	(arg1)->clear();
2542	>	result = (arg1)->showProgramTypes();
2543
2544	+	}catch (const BossSchedFailure & e) {
2545	+	PyErr_SetString ( SchedulerError, e.what() );
2546	+	return NULL;
2547		}catch (const std::exception& e) {
2548	<	SWIG_exception(SWIG_RuntimeError, e.what());
2548	>	PyErr_SetString ( BossError, e.what() );
2549	>	return NULL;
2550		}
2551		}
2552	<	Py_INCREF(Py_None); resultobj = Py_None;
2552	>	{
2553	>	resultobj = PyTuple_New((&result)->size());
2554	>	for (unsigned int i=0; i<(&result)->size(); i++)
2555	>	PyTuple_SetItem(resultobj,i,
2556	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2557	>	}
2558		return resultobj;
2559		fail:
2560		return NULL;
2561		}
2562
2563
2564	<	static PyObject _wrap_BossSession_makeBossTask(PyObject self, PyObject *args) {
2564	>	static PyObject _wrap_BossSession_showRTMon(PyObject self, PyObject *args) {
2565		PyObject *resultobj;
2566		BossSession arg1 = (BossSession ) 0 ;
2567	<	std::string const &arg2_defvalue = "" ;
2604	<	std::string arg2 = (std::string ) &arg2_defvalue ;
2605	<	BossTask *result;
2606	<	std::string temp2 ;
2567	>	std::vector<std::string > result;
2568		PyObject * obj0 = 0 ;
2608	–	PyObject * obj1 = 0 ;
2569
2570	<	if(!PyArg_ParseTuple(args,(char *)"O\|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2570	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2571		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2612	–	if (obj1) {
2613	–	{
2614	–	if (PyString_Check(obj1)) {
2615	–	temp2 = std::string(PyString_AsString(obj1));
2616	–	arg2 = &temp2;
2617	–	}else {
2618	–	SWIG_exception(SWIG_TypeError, "string expected");
2619	–	}
2620	–	}
2621	–	}
2572		{
2573		try {
2574	<	result = (BossTask )(arg1)->makeBossTask((std::string const &)arg2);
2574	>	result = (arg1)->showRTMon();
2575
2576	+	}catch (const BossSchedFailure & e) {
2577	+	PyErr_SetString ( SchedulerError, e.what() );
2578	+	return NULL;
2579		}catch (const std::exception& e) {
2580	<	SWIG_exception(SWIG_RuntimeError, e.what());
2580	>	PyErr_SetString ( BossError, e.what() );
2581	>	return NULL;
2582		}
2583		}
2584	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2584	>	{
2585	>	resultobj = PyTuple_New((&result)->size());
2586	>	for (unsigned int i=0; i<(&result)->size(); i++)
2587	>	PyTuple_SetItem(resultobj,i,
2588	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2589	>	}
2590		return resultobj;
2591		fail:
2592		return NULL;
2593		}
2594
2595
2596	<	static PyObject _wrap_BossSession_destroyBossTask(PyObject self, PyObject *args) {
2596	>	static PyObject _wrap_BossSession_showSchedulers(PyObject self, PyObject *args) {
2597		PyObject *resultobj;
2598		BossSession arg1 = (BossSession ) 0 ;
2599	<	BossTask arg2 = (BossTask ) 0 ;
2599	>	std::vector<std::string > result;
2600		PyObject * obj0 = 0 ;
2642	–	PyObject * obj1 = 0 ;
2601
2602	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2602	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2603		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2646	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2604		{
2605		try {
2606	<	(arg1)->destroyBossTask(arg2);
2606	>	result = (arg1)->showSchedulers();
2607
2608	+	}catch (const BossSchedFailure & e) {
2609	+	PyErr_SetString ( SchedulerError, e.what() );
2610	+	return NULL;
2611		}catch (const std::exception& e) {
2612	<	SWIG_exception(SWIG_RuntimeError, e.what());
2612	>	PyErr_SetString ( BossError, e.what() );
2613	>	return NULL;
2614		}
2615		}
2616	<	Py_INCREF(Py_None); resultobj = Py_None;
2616	>	{
2617	>	resultobj = PyTuple_New((&result)->size());
2618	>	for (unsigned int i=0; i<(&result)->size(); i++)
2619	>	PyTuple_SetItem(resultobj,i,
2620	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2621	>	}
2622		return resultobj;
2623		fail:
2624		return NULL;
#	Line 2671 \| Line 2637 \| *static PyObject _wrap_BossSession_defau**
2637		try {
2638		result = (arg1)->defaultCHTool();
2639
2640	+	}catch (const BossSchedFailure & e) {
2641	+	PyErr_SetString ( SchedulerError, e.what() );
2642	+	return NULL;
2643		}catch (const std::exception& e) {
2644	<	SWIG_exception(SWIG_RuntimeError, e.what());
2644	>	PyErr_SetString ( BossError, e.what() );
2645	>	return NULL;
2646		}
2647		}
2648		{
#	Line 2696 \| Line 2666 \| *static PyObject _wrap_BossSession_defau**
2666		try {
2667		result = (arg1)->defaultProgramType();
2668
2669	+	}catch (const BossSchedFailure & e) {
2670	+	PyErr_SetString ( SchedulerError, e.what() );
2671	+	return NULL;
2672		}catch (const std::exception& e) {
2673	<	SWIG_exception(SWIG_RuntimeError, e.what());
2673	>	PyErr_SetString ( BossError, e.what() );
2674	>	return NULL;
2675		}
2676		}
2677		{
#	Line 2721 \| Line 2695 \| *static PyObject _wrap_BossSession_defau**
2695		try {
2696		result = (arg1)->defaultRTMon();
2697
2698	+	}catch (const BossSchedFailure & e) {
2699	+	PyErr_SetString ( SchedulerError, e.what() );
2700	+	return NULL;
2701		}catch (const std::exception& e) {
2702	<	SWIG_exception(SWIG_RuntimeError, e.what());
2702	>	PyErr_SetString ( BossError, e.what() );
2703	>	return NULL;
2704		}
2705		}
2706		{
#	Line 2746 \| Line 2724 \| *static PyObject _wrap_BossSession_defau**
2724		try {
2725		result = (arg1)->defaultScheduler();
2726
2727	+	}catch (const BossSchedFailure & e) {
2728	+	PyErr_SetString ( SchedulerError, e.what() );
2729	+	return NULL;
2730		}catch (const std::exception& e) {
2731	<	SWIG_exception(SWIG_RuntimeError, e.what());
2731	>	PyErr_SetString ( BossError, e.what() );
2732	>	return NULL;
2733		}
2734		}
2735		{
#	Line 2771 \| Line 2753 \| *static PyObject _wrap_BossSession_versi**
2753		try {
2754		result = (arg1)->version();
2755
2756	+	}catch (const BossSchedFailure & e) {
2757	+	PyErr_SetString ( SchedulerError, e.what() );
2758	+	return NULL;
2759		}catch (const std::exception& e) {
2760	<	SWIG_exception(SWIG_RuntimeError, e.what());
2760	>	PyErr_SetString ( BossError, e.what() );
2761	>	return NULL;
2762		}
2763		}
2764		{
#	Line 2796 \| Line 2782 \| *static PyObject _wrap_BossSession_clien**
2782		try {
2783		result = (arg1)->clientID();
2784
2785	+	}catch (const BossSchedFailure & e) {
2786	+	PyErr_SetString ( SchedulerError, e.what() );
2787	+	return NULL;
2788		}catch (const std::exception& e) {
2789	<	SWIG_exception(SWIG_RuntimeError, e.what());
2789	>	PyErr_SetString ( BossError, e.what() );
2790	>	return NULL;
2791		}
2792		}
2793		{
#	Line 2827 \| Line 2817 \| *static PyObject _wrap_BossSession_showC**
2817		try {
2818		result = (int)(arg1)->showConfigs(arg2);
2819
2820	+	}catch (const BossSchedFailure & e) {
2821	+	PyErr_SetString ( SchedulerError, e.what() );
2822	+	return NULL;
2823		}catch (const std::exception& e) {
2824	<	SWIG_exception(SWIG_RuntimeError, e.what());
2824	>	PyErr_SetString ( BossError, e.what() );
2825	>	return NULL;
2826		}
2827		}
2828		resultobj = PyInt_FromLong((long)result);
#	Line 2880 \| Line 2874 \| *static PyObject _wrap_BossSession_RTupd**
2874		try {
2875		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2876
2877	+	}catch (const BossSchedFailure & e) {
2878	+	PyErr_SetString ( SchedulerError, e.what() );
2879	+	return NULL;
2880		}catch (const std::exception& e) {
2881	<	SWIG_exception(SWIG_RuntimeError, e.what());
2881	>	PyErr_SetString ( BossError, e.what() );
2882	>	return NULL;
2883		}
2884		}
2885		resultobj = PyInt_FromLong((long)result);
#	Line 2959 \| Line 2957 \| *static PyObject _wrap_BossSession_listM**
2957		try {
2958		result = (arg1)->listMatch((std::string const &)arg2,(std::string const &)arg3,arg4,(std::string const &)arg5,(std::string const &)arg6);
2959
2960	+	}catch (const BossSchedFailure & e) {
2961	+	PyErr_SetString ( SchedulerError, e.what() );
2962	+	return NULL;
2963		}catch (const std::exception& e) {
2964	<	SWIG_exception(SWIG_RuntimeError, e.what());
2964	>	PyErr_SetString ( BossError, e.what() );
2965	>	return NULL;
2966		}
2967		}
2968		{
#	Line 3069 \| Line 3071 \| *static PyObject _wrap_BossSession_sched**
3071		try {
3072		(arg1)->schedulerQuery(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3073
3074	+	}catch (const BossSchedFailure & e) {
3075	+	PyErr_SetString ( SchedulerError, e.what() );
3076	+	return NULL;
3077		}catch (const std::exception& e) {
3078	<	SWIG_exception(SWIG_RuntimeError, e.what());
3078	>	PyErr_SetString ( BossError, e.what() );
3079	>	return NULL;
3080		}
3081		}
3082		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3148 \| Line 3154 \| *static PyObject _wrap_BossSession_selec**
3154		try {
3155		result = (arg1)->selectTasks((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5);
3156
3157	+	}catch (const BossSchedFailure & e) {
3158	+	PyErr_SetString ( SchedulerError, e.what() );
3159	+	return NULL;
3160		}catch (const std::exception& e) {
3161	<	SWIG_exception(SWIG_RuntimeError, e.what());
3161	>	PyErr_SetString ( BossError, e.what() );
3162	>	return NULL;
3163		}
3164		}
3165		{
#	Line 3265 \| Line 3275 \| *static PyObject _wrap_BossSession_query**
3275		try {
3276		result = (arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3277
3278	+	}catch (const BossSchedFailure & e) {
3279	+	PyErr_SetString ( SchedulerError, e.what() );
3280	+	return NULL;
3281		}catch (const std::exception& e) {
3282	<	SWIG_exception(SWIG_RuntimeError, e.what());
3282	>	PyErr_SetString ( BossError, e.what() );
3283	>	return NULL;
3284		}
3285		}
3286		{
#	Line 3280 \| Line 3294 \| *static PyObject _wrap_BossSession_query**
3294		}
3295
3296
3297	<	static PyObject * BossSession_swigregister(PyObject self, PyObject args) {
3284	<	PyObject *obj;
3285	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3286	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3287	<	Py_INCREF(obj);
3288	<	return Py_BuildValue((char *)"");
3289	<	}
3290	<	static PyObject _wrap_BossTaskException_key_set(PyObject self, PyObject *args) {
3297	>	static PyObject _wrap_BossSession_show(PyObject self, PyObject *args) {
3298		PyObject *resultobj;
3299	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3300	<	char *arg2 ;
3299	>	BossSession arg1 = (BossSession ) 0 ;
3300	>	std::vector<std::string > *arg2 = 0 ;
3301	>	PyObject *result;
3302		PyObject * obj0 = 0 ;
3303	+	PyObject * obj1 = 0 ;
3304
3305	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3306	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3305	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3306	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3307	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3308	>	if (arg2 == NULL) {
3309	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3310	>	}
3311		{
3312	<	if (arg2) {
3313	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3314	<	strcpy((char *) arg1->key,arg2);
3315	<	}else {
3316	<	arg1->key = 0;
3312	>	try {
3313	>	result = (PyObject )BossSession_show(arg1,arg2);
3314	>
3315	>	}catch (const BossSchedFailure & e) {
3316	>	PyErr_SetString ( SchedulerError, e.what() );
3317	>	return NULL;
3318	>	}catch (const std::exception& e) {
3319	>	PyErr_SetString ( BossError, e.what() );
3320	>	return NULL;
3321		}
3322		}
3323	<	Py_INCREF(Py_None); resultobj = Py_None;
3323	>	resultobj = result;
3324		return resultobj;
3325		fail:
3326		return NULL;
3327		}
3328
3329
3330	<	static PyObject _wrap_BossTaskException_key_get(PyObject self, PyObject *args) {
3330	>	static PyObject _wrap_BossSession_CHTools(PyObject self, PyObject *args) {
3331		PyObject *resultobj;
3332	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3333	<	char *result;
3332	>	BossSession arg1 = (BossSession ) 0 ;
3333	>	PyObject *result;
3334		PyObject * obj0 = 0 ;
3335
3336	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3337	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3338	<	result = (char *) ((arg1)->key);
3339	<
3340	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3336	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3337	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3338	>	{
3339	>	try {
3340	>	result = (PyObject *)BossSession_CHTools(arg1);
3341	>
3342	>	}catch (const BossSchedFailure & e) {
3343	>	PyErr_SetString ( SchedulerError, e.what() );
3344	>	return NULL;
3345	>	}catch (const std::exception& e) {
3346	>	PyErr_SetString ( BossError, e.what() );
3347	>	return NULL;
3348	>	}
3349	>	}
3350	>	resultobj = result;
3351		return resultobj;
3352		fail:
3353		return NULL;
3354		}
3355
3356
3357	<	static PyObject _wrap_new_BossTaskException(PyObject self, PyObject *args) {
3357	>	static PyObject _wrap_BossSession_ProgramTypes(PyObject self, PyObject *args) {
3358		PyObject *resultobj;
3359	<	char *arg1 ;
3360	<	BossTaskException *result;
3359	>	BossSession arg1 = (BossSession ) 0 ;
3360	>	PyObject *result;
3361	>	PyObject * obj0 = 0 ;
3362
3363	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3363	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3364	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3365		{
3366		try {
3367	<	result = (BossTaskException )new BossTaskException((char const )arg1);
3367	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3368
3369	+	}catch (const BossSchedFailure & e) {
3370	+	PyErr_SetString ( SchedulerError, e.what() );
3371	+	return NULL;
3372		}catch (const std::exception& e) {
3373	<	SWIG_exception(SWIG_RuntimeError, e.what());
3373	>	PyErr_SetString ( BossError, e.what() );
3374	>	return NULL;
3375		}
3376		}
3377	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3377	>	resultobj = result;
3378		return resultobj;
3379		fail:
3380		return NULL;
3381		}
3382
3383
3384	<	static PyObject _wrap_BossTaskException_what(PyObject self, PyObject *args) {
3384	>	static PyObject _wrap_BossSession_RTMons(PyObject self, PyObject *args) {
3385		PyObject *resultobj;
3386	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3387	<	char *result;
3386	>	BossSession arg1 = (BossSession ) 0 ;
3387	>	PyObject *result;
3388		PyObject * obj0 = 0 ;
3389
3390	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3391	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3390	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3391	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3392		{
3393		try {
3394	<	result = (char )((BossTaskException const )arg1)->what();
3394	>	result = (PyObject *)BossSession_RTMons(arg1);
3395
3396	+	}catch (const BossSchedFailure & e) {
3397	+	PyErr_SetString ( SchedulerError, e.what() );
3398	+	return NULL;
3399		}catch (const std::exception& e) {
3400	<	SWIG_exception(SWIG_RuntimeError, e.what());
3400	>	PyErr_SetString ( BossError, e.what() );
3401	>	return NULL;
3402		}
3403		}
3404	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3404	>	resultobj = result;
3405		return resultobj;
3406		fail:
3407		return NULL;
3408		}
3409
3410
3411	<	static PyObject _wrap_delete_BossTaskException(PyObject self, PyObject *args) {
3411	>	static PyObject _wrap_BossSession_schedulers(PyObject self, PyObject *args) {
3412		PyObject *resultobj;
3413	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3413	>	BossSession arg1 = (BossSession ) 0 ;
3414	>	PyObject *result;
3415		PyObject * obj0 = 0 ;
3416
3417	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3418	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3417	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3418	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3419		{
3420		try {
3421	<	delete arg1;
3421	>	result = (PyObject *)BossSession_schedulers(arg1);
3422
3423	+	}catch (const BossSchedFailure & e) {
3424	+	PyErr_SetString ( SchedulerError, e.what() );
3425	+	return NULL;
3426		}catch (const std::exception& e) {
3427	<	SWIG_exception(SWIG_RuntimeError, e.what());
3427	>	PyErr_SetString ( BossError, e.what() );
3428	>	return NULL;
3429		}
3430		}
3431	<	Py_INCREF(Py_None); resultobj = Py_None;
3431	>	resultobj = result;
3432		return resultobj;
3433		fail:
3434		return NULL;
3435		}
3436
3437
3438	<	static PyObject * BossTaskException_swigregister(PyObject self, PyObject args) {
3397	<	PyObject *obj;
3398	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3399	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3400	<	Py_INCREF(obj);
3401	<	return Py_BuildValue((char *)"");
3402	<	}
3403	<	static PyObject _wrap_BossTask_appendToPyDict(PyObject self, PyObject *args) {
3438	>	static PyObject _wrap_BossSession_schedListMatch(PyObject self, PyObject *args) {
3439		PyObject *resultobj;
3440	<	BossTask arg1 = (BossTask ) 0 ;
3441	<	PyObject arg2 = (PyObject ) 0 ;
3442	<	BossAttributeContainer *arg3 = 0 ;
3440	>	BossSession arg1 = (BossSession ) 0 ;
3441	>	std::string *arg2 = 0 ;
3442	>	std::string *arg3 = 0 ;
3443	>	std::string const &arg4_defvalue = "" ;
3444	>	std::string arg4 = (std::string ) &arg4_defvalue ;
3445	>	std::string const &arg5_defvalue = "" ;
3446	>	std::string arg5 = (std::string ) &arg5_defvalue ;
3447	>	bool arg6 = (bool) false ;
3448		PyObject *result;
3449	+	std::string temp2 ;
3450	+	std::string temp3 ;
3451	+	std::string temp4 ;
3452	+	std::string temp5 ;
3453		PyObject * obj0 = 0 ;
3454		PyObject * obj1 = 0 ;
3455		PyObject * obj2 = 0 ;
3456	+	PyObject * obj3 = 0 ;
3457	+	PyObject * obj4 = 0 ;
3458	+	PyObject * obj5 = 0 ;
3459
3460	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3461	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3462	<	arg2 = obj1;
3463	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3464	<	if (arg3 == NULL) {
3465	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3460	>	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3461	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3462	>	{
3463	>	if (PyString_Check(obj1)) {
3464	>	temp2 = std::string(PyString_AsString(obj1));
3465	>	arg2 = &temp2;
3466	>	}else {
3467	>	SWIG_exception(SWIG_TypeError, "string expected");
3468	>	}
3469	>	}
3470	>	{
3471	>	if (PyString_Check(obj2)) {
3472	>	temp3 = std::string(PyString_AsString(obj2));
3473	>	arg3 = &temp3;
3474	>	}else {
3475	>	SWIG_exception(SWIG_TypeError, "string expected");
3476	>	}
3477	>	}
3478	>	if (obj3) {
3479	>	{
3480	>	if (PyString_Check(obj3)) {
3481	>	temp4 = std::string(PyString_AsString(obj3));
3482	>	arg4 = &temp4;
3483	>	}else {
3484	>	SWIG_exception(SWIG_TypeError, "string expected");
3485	>	}
3486	>	}
3487	>	}
3488	>	if (obj4) {
3489	>	{
3490	>	if (PyString_Check(obj4)) {
3491	>	temp5 = std::string(PyString_AsString(obj4));
3492	>	arg5 = &temp5;
3493	>	}else {
3494	>	SWIG_exception(SWIG_TypeError, "string expected");
3495	>	}
3496	>	}
3497	>	}
3498	>	if (obj5) {
3499	>	arg6 = PyInt_AsLong(obj5) ? true : false;
3500	>	if (PyErr_Occurred()) SWIG_fail;
3501		}
3502		{
3503		try {
3504	<	result = (PyObject )BossTask_appendToPyDict((BossTask const )arg1,arg2,(BossAttributeContainer const &)*arg3);
3504	>	result = (PyObject )BossSession_schedListMatch(arg1,(std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6);
3505
3506	+	}catch (const BossSchedFailure & e) {
3507	+	PyErr_SetString ( SchedulerError, e.what() );
3508	+	return NULL;
3509		}catch (const std::exception& e) {
3510	<	SWIG_exception(SWIG_RuntimeError, e.what());
3510	>	PyErr_SetString ( BossError, e.what() );
3511	>	return NULL;
3512		}
3513		}
3514		resultobj = result;
#	Line 3432 \| Line 3518 \| *static PyObject _wrap_BossTask_appendTo**
3518		}
3519
3520
3521	<	static PyObject _wrap_BossTask_jobDict(PyObject self, PyObject *args) {
3521	>	static PyObject _wrap_BossSession_queryTasks(PyObject self, PyObject *args) {
3522		PyObject *resultobj;
3523	<	BossTask arg1 = (BossTask ) 0 ;
3524	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3523	>	BossSession arg1 = (BossSession ) 0 ;
3524	>	int arg2 = (int) SCHEDULED ;
3525	>	std::string const &arg3_defvalue = "all" ;
3526	>	std::string arg3 = (std::string ) &arg3_defvalue ;
3527	>	std::string const &arg4_defvalue = "all" ;
3528	>	std::string arg4 = (std::string ) &arg4_defvalue ;
3529	>	std::string const &arg5_defvalue = "" ;
3530	>	std::string arg5 = (std::string ) &arg5_defvalue ;
3531	>	std::string arg6 = (std::string) "" ;
3532	>	std::string arg7 = (std::string) "" ;
3533	>	std::string arg8 = (std::string) "" ;
3534	>	std::string arg9 = (std::string) "" ;
3535	>	bool arg10 = (bool) false ;
3536		PyObject *result;
3537	+	std::string temp3 ;
3538	+	std::string temp4 ;
3539	+	std::string temp5 ;
3540		PyObject * obj0 = 0 ;
3541	<	PyObject * obj1 = 0 ;
3541	>	PyObject * obj2 = 0 ;
3542	>	PyObject * obj3 = 0 ;
3543	>	PyObject * obj4 = 0 ;
3544	>	PyObject * obj5 = 0 ;
3545	>	PyObject * obj6 = 0 ;
3546	>	PyObject * obj7 = 0 ;
3547	>	PyObject * obj8 = 0 ;
3548	>	PyObject * obj9 = 0 ;
3549
3550	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3551	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3552	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3553	<	if (arg2 == NULL) {
3554	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3550	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3551	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3552	>	if (obj2) {
3553	>	{
3554	>	if (PyString_Check(obj2)) {
3555	>	temp3 = std::string(PyString_AsString(obj2));
3556	>	arg3 = &temp3;
3557	>	}else {
3558	>	SWIG_exception(SWIG_TypeError, "string expected");
3559	>	}
3560	>	}
3561	>	}
3562	>	if (obj3) {
3563	>	{
3564	>	if (PyString_Check(obj3)) {
3565	>	temp4 = std::string(PyString_AsString(obj3));
3566	>	arg4 = &temp4;
3567	>	}else {
3568	>	SWIG_exception(SWIG_TypeError, "string expected");
3569	>	}
3570	>	}
3571	>	}
3572	>	if (obj4) {
3573	>	{
3574	>	if (PyString_Check(obj4)) {
3575	>	temp5 = std::string(PyString_AsString(obj4));
3576	>	arg5 = &temp5;
3577	>	}else {
3578	>	SWIG_exception(SWIG_TypeError, "string expected");
3579	>	}
3580	>	}
3581	>	}
3582	>	if (obj5) {
3583	>	{
3584	>	if (PyString_Check(obj5))
3585	>	arg6 = std::string(PyString_AsString(obj5));
3586	>	else
3587	>	SWIG_exception(SWIG_TypeError, "string expected");
3588	>	}
3589	>	}
3590	>	if (obj6) {
3591	>	{
3592	>	if (PyString_Check(obj6))
3593	>	arg7 = std::string(PyString_AsString(obj6));
3594	>	else
3595	>	SWIG_exception(SWIG_TypeError, "string expected");
3596	>	}
3597	>	}
3598	>	if (obj7) {
3599	>	{
3600	>	if (PyString_Check(obj7))
3601	>	arg8 = std::string(PyString_AsString(obj7));
3602	>	else
3603	>	SWIG_exception(SWIG_TypeError, "string expected");
3604	>	}
3605	>	}
3606	>	if (obj8) {
3607	>	{
3608	>	if (PyString_Check(obj8))
3609	>	arg9 = std::string(PyString_AsString(obj8));
3610	>	else
3611	>	SWIG_exception(SWIG_TypeError, "string expected");
3612	>	}
3613	>	}
3614	>	if (obj9) {
3615	>	arg10 = PyInt_AsLong(obj9) ? true : false;
3616	>	if (PyErr_Occurred()) SWIG_fail;
3617		}
3618		{
3619		try {
3620	<	result = (PyObject )BossTask_jobDict((BossTask const )arg1,*arg2);
3620	>	result = (PyObject )BossSession_queryTasks(arg1,arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5,arg6,arg7,arg8,arg9,arg10);
3621
3622	+	}catch (const BossSchedFailure & e) {
3623	+	PyErr_SetString ( SchedulerError, e.what() );
3624	+	return NULL;
3625		}catch (const std::exception& e) {
3626	<	SWIG_exception(SWIG_RuntimeError, e.what());
3626	>	PyErr_SetString ( BossError, e.what() );
3627	>	return NULL;
3628		}
3629		}
3630		resultobj = result;
#	Line 3461 \| Line 3634 \| *static PyObject _wrap_BossTask_jobDict(**
3634		}
3635
3636
3637	<	static PyObject _wrap_BossTask_jobsDict(PyObject self, PyObject *args) {
3637	>	static PyObject * BossSession_swigregister(PyObject self, PyObject args) {
3638	>	PyObject *obj;
3639	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3640	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3641	>	Py_INCREF(obj);
3642	>	return Py_BuildValue((char *)"");
3643	>	}
3644	>	static PyObject _wrap_BossTaskException_key_set(PyObject self, PyObject *args) {
3645		PyObject *resultobj;
3646	<	BossTask arg1 = (BossTask ) 0 ;
3647	<	PyObject *result;
3646	>	BossTaskException arg1 = (BossTaskException ) 0 ;
3647	>	char *arg2 ;
3648		PyObject * obj0 = 0 ;
3649
3650	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3651	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3650	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3651	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3652		{
3653	<	try {
3654	<	result = (PyObject *)BossTask_jobsDict(arg1);
3655	<
3656	<	}catch (const std::exception& e) {
3657	<	SWIG_exception(SWIG_RuntimeError, e.what());
3653	>	if (arg2) {
3654	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3655	>	strcpy((char *) arg1->key,arg2);
3656	>	}else {
3657	>	arg1->key = 0;
3658		}
3659		}
3660	<	resultobj = result;
3660	>	Py_INCREF(Py_None); resultobj = Py_None;
3661		return resultobj;
3662		fail:
3663		return NULL;
3664		}
3665
3666
3667	<	static PyObject _wrap_BossTask_progDict(PyObject self, PyObject *args) {
3667	>	static PyObject _wrap_BossTaskException_key_get(PyObject self, PyObject *args) {
3668		PyObject *resultobj;
3669	<	BossTask arg1 = (BossTask ) 0 ;
3670	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3491	<	PyObject *result;
3669	>	BossTaskException arg1 = (BossTaskException ) 0 ;
3670	>	char *result;
3671		PyObject * obj0 = 0 ;
3493	–	PyObject * obj1 = 0 ;
3672
3673	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3674	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3675	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3676	<	if (arg2 == NULL) {
3677	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3678	<	}
3673	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3674	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3675	>	result = (char *) ((arg1)->key);
3676	>
3677	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3678	>	return resultobj;
3679	>	fail:
3680	>	return NULL;
3681	>	}
3682	>
3683	>
3684	>	static PyObject _wrap_new_BossTaskException(PyObject self, PyObject *args) {
3685	>	PyObject *resultobj;
3686	>	char *arg1 ;
3687	>	BossTaskException *result;
3688	>
3689	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3690		{
3691		try {
3692	<	result = (PyObject )BossTask_progDict((BossTask const )arg1,*arg2);
3692	>	result = (BossTaskException )new BossTaskException((char const )arg1);
3693
3694	+	}catch (const BossSchedFailure & e) {
3695	+	PyErr_SetString ( SchedulerError, e.what() );
3696	+	return NULL;
3697		}catch (const std::exception& e) {
3698	<	SWIG_exception(SWIG_RuntimeError, e.what());
3698	>	PyErr_SetString ( BossError, e.what() );
3699	>	return NULL;
3700		}
3701		}
3702	<	resultobj = result;
3702	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3703		return resultobj;
3704		fail:
3705		return NULL;
3706		}
3707
3708
3709	<	static PyObject _wrap_BossTask_jobPrograms(PyObject self, PyObject *args) {
3709	>	static PyObject _wrap_BossTaskException_what(PyObject self, PyObject *args) {
3710		PyObject *resultobj;
3711	<	BossTask arg1 = (BossTask ) 0 ;
3712	<	std::string *arg2 = 0 ;
3520	<	PyObject *result;
3521	<	std::string temp2 ;
3711	>	BossTaskException arg1 = (BossTaskException ) 0 ;
3712	>	char *result;
3713		PyObject * obj0 = 0 ;
3523	–	PyObject * obj1 = 0 ;
3714
3715	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3716	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3715	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3716	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3717		{
3718	<	if (PyString_Check(obj1)) {
3719	<	temp2 = std::string(PyString_AsString(obj1));
3720	<	arg2 = &temp2;
3721	<	}else {
3722	<	SWIG_exception(SWIG_TypeError, "string expected");
3718	>	try {
3719	>	result = (char )((BossTaskException const )arg1)->what();
3720	>
3721	>	}catch (const BossSchedFailure & e) {
3722	>	PyErr_SetString ( SchedulerError, e.what() );
3723	>	return NULL;
3724	>	}catch (const std::exception& e) {
3725	>	PyErr_SetString ( BossError, e.what() );
3726	>	return NULL;
3727		}
3728		}
3729	+	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3730	+	return resultobj;
3731	+	fail:
3732	+	return NULL;
3733	+	}
3734	+
3735	+
3736	+	static PyObject _wrap_delete_BossTaskException(PyObject self, PyObject *args) {
3737	+	PyObject *resultobj;
3738	+	BossTaskException arg1 = (BossTaskException ) 0 ;
3739	+	PyObject * obj0 = 0 ;
3740	+
3741	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3742	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3743		{
3744		try {
3745	<	result = (PyObject )BossTask_jobPrograms((BossTask const )arg1,(std::string const &)*arg2);
3745	>	delete arg1;
3746
3747	+	}catch (const BossSchedFailure & e) {
3748	+	PyErr_SetString ( SchedulerError, e.what() );
3749	+	return NULL;
3750		}catch (const std::exception& e) {
3751	<	SWIG_exception(SWIG_RuntimeError, e.what());
3751	>	PyErr_SetString ( BossError, e.what() );
3752	>	return NULL;
3753		}
3754		}
3755	<	resultobj = result;
3755	>	Py_INCREF(Py_None); resultobj = Py_None;
3756		return resultobj;
3757		fail:
3758		return NULL;
3759		}
3760
3761
3762	+	static PyObject * BossTaskException_swigregister(PyObject self, PyObject args) {
3763	+	PyObject *obj;
3764	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3765	+	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3766	+	Py_INCREF(obj);
3767	+	return Py_BuildValue((char *)"");
3768	+	}
3769		static PyObject _wrap_new_BossTask__SWIG_0(PyObject self, PyObject *args) {
3770		PyObject *resultobj;
3771		BossDatabase arg1 = (BossDatabase ) 0 ;
#	Line 3559 \| Line 3778 \| *static PyObject _wrap_new_BossTask__SWI**
3778		try {
3779		result = (BossTask *)new BossTask(arg1);
3780
3781	+	}catch (const BossSchedFailure & e) {
3782	+	PyErr_SetString ( SchedulerError, e.what() );
3783	+	return NULL;
3784		}catch (const std::exception& e) {
3785	<	SWIG_exception(SWIG_RuntimeError, e.what());
3785	>	PyErr_SetString ( BossError, e.what() );
3786	>	return NULL;
3787		}
3788		}
3789		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3593 \| Line 3816 \| *static PyObject _wrap_new_BossTask__SWI**
3816		try {
3817		result = (BossTask )new BossTask(arg1,(std::string const &)arg2);
3818
3819	+	}catch (const BossSchedFailure & e) {
3820	+	PyErr_SetString ( SchedulerError, e.what() );
3821	+	return NULL;
3822		}catch (const std::exception& e) {
3823	<	SWIG_exception(SWIG_RuntimeError, e.what());
3823	>	PyErr_SetString ( BossError, e.what() );
3824	>	return NULL;
3825		}
3826		}
3827		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3615 \| Line 3842 \| *static PyObject _wrap_delete_BossTask(P**
3842		try {
3843		delete arg1;
3844
3845	+	}catch (const BossSchedFailure & e) {
3846	+	PyErr_SetString ( SchedulerError, e.what() );
3847	+	return NULL;
3848		}catch (const std::exception& e) {
3849	<	SWIG_exception(SWIG_RuntimeError, e.what());
3849	>	PyErr_SetString ( BossError, e.what() );
3850	>	return NULL;
3851		}
3852		}
3853		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3641 \| Line 3872 \| *static PyObject _wrap_new_BossTask__SWI**
3872		try {
3873		result = (BossTask )new BossTask((BossTask const &)arg1);
3874
3875	+	}catch (const BossSchedFailure & e) {
3876	+	PyErr_SetString ( SchedulerError, e.what() );
3877	+	return NULL;
3878		}catch (const std::exception& e) {
3879	<	SWIG_exception(SWIG_RuntimeError, e.what());
3879	>	PyErr_SetString ( BossError, e.what() );
3880	>	return NULL;
3881		}
3882		}
3883		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3732 \| Line 3967 \| *static PyObject _wrap_BossTask_id(PyObj**
3967		result = (std::string *) &_result_ref;
3968		}
3969
3970	+	}catch (const BossSchedFailure & e) {
3971	+	PyErr_SetString ( SchedulerError, e.what() );
3972	+	return NULL;
3973		}catch (const std::exception& e) {
3974	<	SWIG_exception(SWIG_RuntimeError, e.what());
3974	>	PyErr_SetString ( BossError, e.what() );
3975	>	return NULL;
3976		}
3977		}
3978		{
#	Line 3760 \| Line 3999 \| *static PyObject _wrap_BossTask_name(PyO**
3999		result = (std::string *) &_result_ref;
4000		}
4001
4002	+	}catch (const BossSchedFailure & e) {
4003	+	PyErr_SetString ( SchedulerError, e.what() );
4004	+	return NULL;
4005		}catch (const std::exception& e) {
4006	<	SWIG_exception(SWIG_RuntimeError, e.what());
4006	>	PyErr_SetString ( BossError, e.what() );
4007	>	return NULL;
4008		}
4009		}
4010		{
#	Line 3785 \| Line 4028 \| *static PyObject _wrap_BossTask_taskMap(**
4028		try {
4029		result = ((BossTask const *)arg1)->taskMap();
4030
4031	+	}catch (const BossSchedFailure & e) {
4032	+	PyErr_SetString ( SchedulerError, e.what() );
4033	+	return NULL;
4034		}catch (const std::exception& e) {
4035	<	SWIG_exception(SWIG_RuntimeError, e.what());
4035	>	PyErr_SetString ( BossError, e.what() );
4036	>	return NULL;
4037		}
4038		}
4039		{
#	Line 3815 \| Line 4062 \| *static PyObject _wrap_BossTask_job_begi**
4062		try {
4063		result = ((BossTask const *)arg1)->job_begin();
4064
4065	+	}catch (const BossSchedFailure & e) {
4066	+	PyErr_SetString ( SchedulerError, e.what() );
4067	+	return NULL;
4068		}catch (const std::exception& e) {
4069	<	SWIG_exception(SWIG_RuntimeError, e.what());
4069	>	PyErr_SetString ( BossError, e.what() );
4070	>	return NULL;
4071		}
4072		}
4073		{
#	Line 3842 \| Line 4093 \| *static PyObject _wrap_BossTask_job_end(**
4093		try {
4094		result = ((BossTask const *)arg1)->job_end();
4095
4096	+	}catch (const BossSchedFailure & e) {
4097	+	PyErr_SetString ( SchedulerError, e.what() );
4098	+	return NULL;
4099		}catch (const std::exception& e) {
4100	<	SWIG_exception(SWIG_RuntimeError, e.what());
4100	>	PyErr_SetString ( BossError, e.what() );
4101	>	return NULL;
4102		}
4103		}
4104		{
#	Line 3869 \| Line 4124 \| *static PyObject _wrap_BossTask_jobsMap(**
4124		try {
4125		result = ((BossTask const *)arg1)->jobsMap();
4126
4127	+	}catch (const BossSchedFailure & e) {
4128	+	PyErr_SetString ( SchedulerError, e.what() );
4129	+	return NULL;
4130		}catch (const std::exception& e) {
4131	<	SWIG_exception(SWIG_RuntimeError, e.what());
4131	>	PyErr_SetString ( BossError, e.what() );
4132	>	return NULL;
4133		}
4134		}
4135		{
#	Line 3907 \| Line 4166 \| *static PyObject _wrap_BossTask_jobMap__**
4166		try {
4167		result = ((BossTask const )arg1)->jobMap(arg2,arg3);
4168
4169	+	}catch (const BossSchedFailure & e) {
4170	+	PyErr_SetString ( SchedulerError, e.what() );
4171	+	return NULL;
4172		}catch (const std::exception& e) {
4173	<	SWIG_exception(SWIG_RuntimeError, e.what());
4173	>	PyErr_SetString ( BossError, e.what() );
4174	>	return NULL;
4175		}
4176		}
4177		{
#	Line 3936 \| Line 4199 \| *static PyObject _wrap_BossTask_jobMap__**
4199		try {
4200		result = ((BossTask const *)arg1)->jobMap(arg2);
4201
4202	+	}catch (const BossSchedFailure & e) {
4203	+	PyErr_SetString ( SchedulerError, e.what() );
4204	+	return NULL;
4205		}catch (const std::exception& e) {
4206	<	SWIG_exception(SWIG_RuntimeError, e.what());
4206	>	PyErr_SetString ( BossError, e.what() );
4207	>	return NULL;
4208		}
4209		}
4210		{
#	Line 4041 \| Line 4308 \| *static PyObject _wrap_BossTask_programs**
4308		try {
4309		result = ((BossTask const )arg1)->programsMap((BossJob const )arg2);
4310
4311	+	}catch (const BossSchedFailure & e) {
4312	+	PyErr_SetString ( SchedulerError, e.what() );
4313	+	return NULL;
4314		}catch (const std::exception& e) {
4315	<	SWIG_exception(SWIG_RuntimeError, e.what());
4315	>	PyErr_SetString ( BossError, e.what() );
4316	>	return NULL;
4317		}
4318		}
4319		{
#	Line 4071 \| Line 4342 \| *static PyObject _wrap_BossTask_queryJob**
4342		try {
4343		result = ((BossTask const )arg1)->queryJobPrograms((BossJob const )arg2);
4344
4345	+	}catch (const BossSchedFailure & e) {
4346	+	PyErr_SetString ( SchedulerError, e.what() );
4347	+	return NULL;
4348		}catch (const std::exception& e) {
4349	<	SWIG_exception(SWIG_RuntimeError, e.what());
4349	>	PyErr_SetString ( BossError, e.what() );
4350	>	return NULL;
4351		}
4352		}
4353		{
#	Line 4122 \| Line 4397 \| *static PyObject _wrap_BossTask_declare_**
4397		try {
4398		(arg1)->declare((std::string const &)arg2,(std::string const &)arg3);
4399
4400	+	}catch (const BossSchedFailure & e) {
4401	+	PyErr_SetString ( SchedulerError, e.what() );
4402	+	return NULL;
4403		}catch (const std::exception& e) {
4404	<	SWIG_exception(SWIG_RuntimeError, e.what());
4404	>	PyErr_SetString ( BossError, e.what() );
4405	>	return NULL;
4406		}
4407		}
4408		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4161 \| Line 4440 \| *static PyObject _wrap_BossTask_declare_**
4440		try {
4441		(arg1)->declare(arg2,(std::string const &)*arg3);
4442
4443	+	}catch (const BossSchedFailure & e) {
4444	+	PyErr_SetString ( SchedulerError, e.what() );
4445	+	return NULL;
4446		}catch (const std::exception& e) {
4447	<	SWIG_exception(SWIG_RuntimeError, e.what());
4447	>	PyErr_SetString ( BossError, e.what() );
4448	>	return NULL;
4449		}
4450		}
4451		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4260 \| Line 4543 \| *static PyObject _wrap_BossTask_remove(P**
4543		try {
4544		(arg1)->remove();
4545
4546	+	}catch (const BossSchedFailure & e) {
4547	+	PyErr_SetString ( SchedulerError, e.what() );
4548	+	return NULL;
4549		}catch (const std::exception& e) {
4550	<	SWIG_exception(SWIG_RuntimeError, e.what());
4550	>	PyErr_SetString ( BossError, e.what() );
4551	>	return NULL;
4552		}
4553		}
4554		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4296 \| Line 4583 \| *static PyObject _wrap_BossTask_archive(**
4583		try {
4584		(arg1)->archive((std::string const &)*arg2);
4585
4586	+	}catch (const BossSchedFailure & e) {
4587	+	PyErr_SetString ( SchedulerError, e.what() );
4588	+	return NULL;
4589		}catch (const std::exception& e) {
4590	<	SWIG_exception(SWIG_RuntimeError, e.what());
4590	>	PyErr_SetString ( BossError, e.what() );
4591	>	return NULL;
4592		}
4593		}
4594		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4395 \| Line 4686 \| *static PyObject _wrap_BossTask_submit(P**
4686		try {
4687		result = (int)(arg1)->submit((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5,(std::string const &)*arg6,arg7);
4688
4689	+	}catch (const BossSchedFailure & e) {
4690	+	PyErr_SetString ( SchedulerError, e.what() );
4691	+	return NULL;
4692		}catch (const std::exception& e) {
4693	<	SWIG_exception(SWIG_RuntimeError, e.what());
4693	>	PyErr_SetString ( BossError, e.what() );
4694	>	return NULL;
4695		}
4696		}
4697		resultobj = PyInt_FromLong((long)result);
#	Line 4435 \| Line 4730 \| *static PyObject _wrap_BossTask_reSubmit**
4730		try {
4731		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4732
4733	+	}catch (const BossSchedFailure & e) {
4734	+	PyErr_SetString ( SchedulerError, e.what() );
4735	+	return NULL;
4736		}catch (const std::exception& e) {
4737	<	SWIG_exception(SWIG_RuntimeError, e.what());
4737	>	PyErr_SetString ( BossError, e.what() );
4738	>	return NULL;
4739		}
4740		}
4741		resultobj = PyInt_FromLong((long)result);
#	Line 4475 \| Line 4774 \| *static PyObject _wrap_BossTask_kill(PyO**
4774		try {
4775		result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4776
4777	+	}catch (const BossSchedFailure & e) {
4778	+	PyErr_SetString ( SchedulerError, e.what() );
4779	+	return NULL;
4780		}catch (const std::exception& e) {
4781	<	SWIG_exception(SWIG_RuntimeError, e.what());
4781	>	PyErr_SetString ( BossError, e.what() );
4782	>	return NULL;
4783		}
4784		}
4785		resultobj = PyInt_FromLong((long)result);
#	Line 4538 \| Line 4841 \| *static PyObject _wrap_BossTask_getOutpu**
4841		try {
4842		result = (int)(arg1)->getOutput((std::string const &)arg2,(std::string const &)arg3,arg4,arg5);
4843
4844	+	}catch (const BossSchedFailure & e) {
4845	+	PyErr_SetString ( SchedulerError, e.what() );
4846	+	return NULL;
4847		}catch (const std::exception& e) {
4848	<	SWIG_exception(SWIG_RuntimeError, e.what());
4849	<	}
4544	<	}
4545	<	resultobj = PyInt_FromLong((long)result);
4546	<	return resultobj;
4547	<	fail:
4548	<	return NULL;
4549	<	}
4550	<
4551	<
4552	<	static PyObject _wrap_BossTask_getAllOutput(PyObject self, PyObject *args) {
4553	<	PyObject *resultobj;
4554	<	BossTask arg1 = (BossTask ) 0 ;
4555	<	std::string const &arg2_defvalue = "" ;
4556	<	std::string arg2 = (std::string ) &arg2_defvalue ;
4557	<	bool arg3 = (bool) false ;
4558	<	bool arg4 = (bool) false ;
4559	<	int result;
4560	<	std::string temp2 ;
4561	<	PyObject * obj0 = 0 ;
4562	<	PyObject * obj1 = 0 ;
4563	<	PyObject * obj2 = 0 ;
4564	<	PyObject * obj3 = 0 ;
4565	<
4566	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4567	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4568	<	if (obj1) {
4569	<	{
4570	<	if (PyString_Check(obj1)) {
4571	<	temp2 = std::string(PyString_AsString(obj1));
4572	<	arg2 = &temp2;
4573	<	}else {
4574	<	SWIG_exception(SWIG_TypeError, "string expected");
4575	<	}
4576	<	}
4577	<	}
4578	<	if (obj2) {
4579	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4580	<	if (PyErr_Occurred()) SWIG_fail;
4581	<	}
4582	<	if (obj3) {
4583	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4584	<	if (PyErr_Occurred()) SWIG_fail;
4585	<	}
4586	<	{
4587	<	try {
4588	<	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3,arg4);
4589	<
4590	<	}catch (const std::exception& e) {
4591	<	SWIG_exception(SWIG_RuntimeError, e.what());
4848	>	PyErr_SetString ( BossError, e.what() );
4849	>	return NULL;
4850		}
4851		}
4852		resultobj = PyInt_FromLong((long)result);
#	Line 4679 \| Line 4937 \| *static PyObject _wrap_BossTask_load(PyO**
4937		try {
4938		result = (int)(arg1)->load(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8);
4939
4940	+	}catch (const BossSchedFailure & e) {
4941	+	PyErr_SetString ( SchedulerError, e.what() );
4942	+	return NULL;
4943		}catch (const std::exception& e) {
4944	<	SWIG_exception(SWIG_RuntimeError, e.what());
4944	>	PyErr_SetString ( BossError, e.what() );
4945	>	return NULL;
4946		}
4947		}
4948		resultobj = PyInt_FromLong((long)result);
#	Line 4777 \| Line 5039 \| *static PyObject _wrap_BossTask_query(Py**
5039		try {
5040		result = (int)(arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9);
5041
5042	+	}catch (const BossSchedFailure & e) {
5043	+	PyErr_SetString ( SchedulerError, e.what() );
5044	+	return NULL;
5045		}catch (const std::exception& e) {
5046	<	SWIG_exception(SWIG_RuntimeError, e.what());
5046	>	PyErr_SetString ( BossError, e.what() );
5047	>	return NULL;
5048		}
5049		}
5050		resultobj = PyInt_FromLong((long)result);
#	Line 4836 \| Line 5102 \| *static PyObject _wrap_BossTask_query_ou**
5102		try {
5103		((BossTask const )arg1)->query_out(arg2,(jobStates const &)arg3,(printOption const &)arg4,arg5);
5104
5105	+	}catch (const BossSchedFailure & e) {
5106	+	PyErr_SetString ( SchedulerError, e.what() );
5107	+	return NULL;
5108		}catch (const std::exception& e) {
5109	<	SWIG_exception(SWIG_RuntimeError, e.what());
5109	>	PyErr_SetString ( BossError, e.what() );
5110	>	return NULL;
5111		}
5112		}
5113		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4858 \| Line 5128 \| *static PyObject _wrap_BossTask_clear(Py**
5128		try {
5129		(arg1)->clear();
5130
5131	+	}catch (const BossSchedFailure & e) {
5132	+	PyErr_SetString ( SchedulerError, e.what() );
5133	+	return NULL;
5134		}catch (const std::exception& e) {
5135	<	SWIG_exception(SWIG_RuntimeError, e.what());
5135	>	PyErr_SetString ( BossError, e.what() );
5136	>	return NULL;
5137		}
5138		}
5139		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4869 \| Line 5143 \| *static PyObject _wrap_BossTask_clear(Py**
5143		}
5144
5145
5146	<	static PyObject * BossTask_swigregister(PyObject self, PyObject args) {
5147	<	PyObject *obj;
5148	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5149	<	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5150	<	Py_INCREF(obj);
5151	<	return Py_BuildValue((char *)"");
5146	>	static PyObject _wrap_BossTask_appendToPyDict(PyObject self, PyObject *args) {
5147	>	PyObject *resultobj;
5148	>	BossTask arg1 = (BossTask ) 0 ;
5149	>	PyObject arg2 = (PyObject ) 0 ;
5150	>	BossAttributeContainer *arg3 = 0 ;
5151	>	PyObject *result;
5152	>	PyObject * obj0 = 0 ;
5153	>	PyObject * obj1 = 0 ;
5154	>	PyObject * obj2 = 0 ;
5155	>
5156	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5157	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5158	>	arg2 = obj1;
5159	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5160	>	if (arg3 == NULL) {
5161	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5162	>	}
5163	>	{
5164	>	try {
5165	>	result = (PyObject )BossTask_appendToPyDict((BossTask const )arg1,arg2,(BossAttributeContainer const &)*arg3);
5166	>
5167	>	}catch (const BossSchedFailure & e) {
5168	>	PyErr_SetString ( SchedulerError, e.what() );
5169	>	return NULL;
5170	>	}catch (const std::exception& e) {
5171	>	PyErr_SetString ( BossError, e.what() );
5172	>	return NULL;
5173	>	}
5174	>	}
5175	>	resultobj = result;
5176	>	return resultobj;
5177	>	fail:
5178	>	return NULL;
5179		}
5180	<	static PyObject _wrap_prompt(PyObject self, PyObject *args) {
5180	>
5181	>
5182	>	static PyObject _wrap_BossTask_jobDict(PyObject self, PyObject *args) {
5183		PyObject *resultobj;
5184	<	std::string *arg1 = 0 ;
5185	<	bool result;
5186	<	std::string temp1 ;
5184	>	BossTask arg1 = (BossTask ) 0 ;
5185	>	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5186	>	PyObject *result;
5187		PyObject * obj0 = 0 ;
5188	+	PyObject * obj1 = 0 ;
5189
5190	<	if(!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) goto fail;
5190	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5191	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5192	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5193	>	if (arg2 == NULL) {
5194	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5195	>	}
5196		{
5197	<	if (PyString_Check(obj0)) {
5198	<	temp1 = std::string(PyString_AsString(obj0));
5199	<	arg1 = &temp1;
5197	>	try {
5198	>	result = (PyObject )BossTask_jobDict((BossTask const )arg1,*arg2);
5199	>
5200	>	}catch (const BossSchedFailure & e) {
5201	>	PyErr_SetString ( SchedulerError, e.what() );
5202	>	return NULL;
5203	>	}catch (const std::exception& e) {
5204	>	PyErr_SetString ( BossError, e.what() );
5205	>	return NULL;
5206	>	}
5207	>	}
5208	>	resultobj = result;
5209	>	return resultobj;
5210	>	fail:
5211	>	return NULL;
5212	>	}
5213	>
5214	>
5215	>	static PyObject _wrap_BossTask_jobsDict(PyObject self, PyObject *args) {
5216	>	PyObject *resultobj;
5217	>	BossTask arg1 = (BossTask ) 0 ;
5218	>	PyObject *result;
5219	>	PyObject * obj0 = 0 ;
5220	>
5221	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5222	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5223	>	{
5224	>	try {
5225	>	result = (PyObject *)BossTask_jobsDict(arg1);
5226	>
5227	>	}catch (const BossSchedFailure & e) {
5228	>	PyErr_SetString ( SchedulerError, e.what() );
5229	>	return NULL;
5230	>	}catch (const std::exception& e) {
5231	>	PyErr_SetString ( BossError, e.what() );
5232	>	return NULL;
5233	>	}
5234	>	}
5235	>	resultobj = result;
5236	>	return resultobj;
5237	>	fail:
5238	>	return NULL;
5239	>	}
5240	>
5241	>
5242	>	static PyObject _wrap_BossTask_progDict(PyObject self, PyObject *args) {
5243	>	PyObject *resultobj;
5244	>	BossTask arg1 = (BossTask ) 0 ;
5245	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5246	>	PyObject *result;
5247	>	PyObject * obj0 = 0 ;
5248	>	PyObject * obj1 = 0 ;
5249	>
5250	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5251	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5252	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5253	>	if (arg2 == NULL) {
5254	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5255	>	}
5256	>	{
5257	>	try {
5258	>	result = (PyObject )BossTask_progDict((BossTask const )arg1,*arg2);
5259	>
5260	>	}catch (const BossSchedFailure & e) {
5261	>	PyErr_SetString ( SchedulerError, e.what() );
5262	>	return NULL;
5263	>	}catch (const std::exception& e) {
5264	>	PyErr_SetString ( BossError, e.what() );
5265	>	return NULL;
5266	>	}
5267	>	}
5268	>	resultobj = result;
5269	>	return resultobj;
5270	>	fail:
5271	>	return NULL;
5272	>	}
5273	>
5274	>
5275	>	static PyObject _wrap_BossTask_jobPrograms(PyObject self, PyObject *args) {
5276	>	PyObject *resultobj;
5277	>	BossTask arg1 = (BossTask ) 0 ;
5278	>	std::string *arg2 = 0 ;
5279	>	PyObject *result;
5280	>	std::string temp2 ;
5281	>	PyObject * obj0 = 0 ;
5282	>	PyObject * obj1 = 0 ;
5283	>
5284	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5285	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5286	>	{
5287	>	if (PyString_Check(obj1)) {
5288	>	temp2 = std::string(PyString_AsString(obj1));
5289	>	arg2 = &temp2;
5290		}else {
5291		SWIG_exception(SWIG_TypeError, "string expected");
5292		}
5293		}
5294		{
5295		try {
5296	<	result = (bool)prompt((std::string const &)*arg1);
5296	>	result = (PyObject )BossTask_jobPrograms((BossTask const )arg1,(std::string const &)*arg2);
5297
5298	+	}catch (const BossSchedFailure & e) {
5299	+	PyErr_SetString ( SchedulerError, e.what() );
5300	+	return NULL;
5301		}catch (const std::exception& e) {
5302	<	SWIG_exception(SWIG_RuntimeError, e.what());
5302	>	PyErr_SetString ( BossError, e.what() );
5303	>	return NULL;
5304		}
5305		}
5306	<	resultobj = PyInt_FromLong((long)result);
5306	>	resultobj = result;
5307		return resultobj;
5308		fail:
5309		return NULL;
5310		}
5311
5312
5313	+	static PyObject * BossTask_swigregister(PyObject self, PyObject args) {
5314	+	PyObject *obj;
5315	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5316	+	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5317	+	Py_INCREF(obj);
5318	+	return Py_BuildValue((char *)"");
5319	+	}
5320		static PyObject _wrap_new_BossAdministratorSession(PyObject self, PyObject *args) {
5321		PyObject *resultobj;
5322		std::string arg1 = (std::string) "" ;
5323	<	bool arg2 = (bool) false ;
5323	>	std::string arg2 = (std::string) "2" ;
5324	>	std::string arg3 = (std::string) "" ;
5325	>	std::string arg4 = (std::string) "" ;
5326	>	bool arg5 = (bool) false ;
5327		BossAdministratorSession *result;
5328		PyObject * obj0 = 0 ;
5329		PyObject * obj1 = 0 ;
5330	+	PyObject * obj2 = 0 ;
5331	+	PyObject * obj3 = 0 ;
5332	+	PyObject * obj4 = 0 ;
5333
5334	<	if(!PyArg_ParseTuple(args,(char *)"\|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
5334	>	if(!PyArg_ParseTuple(args,(char *)"\|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5335		if (obj0) {
5336		{
5337		if (PyString_Check(obj0))
#	Line 4925 \| Line 5341 \| *static PyObject _wrap_new_BossAdministr**
5341		}
5342		}
5343		if (obj1) {
5344	<	arg2 = PyInt_AsLong(obj1) ? true : false;
5344	>	{
5345	>	if (PyString_Check(obj1))
5346	>	arg2 = std::string(PyString_AsString(obj1));
5347	>	else
5348	>	SWIG_exception(SWIG_TypeError, "string expected");
5349	>	}
5350	>	}
5351	>	if (obj2) {
5352	>	{
5353	>	if (PyString_Check(obj2))
5354	>	arg3 = std::string(PyString_AsString(obj2));
5355	>	else
5356	>	SWIG_exception(SWIG_TypeError, "string expected");
5357	>	}
5358	>	}
5359	>	if (obj3) {
5360	>	{
5361	>	if (PyString_Check(obj3))
5362	>	arg4 = std::string(PyString_AsString(obj3));
5363	>	else
5364	>	SWIG_exception(SWIG_TypeError, "string expected");
5365	>	}
5366	>	}
5367	>	if (obj4) {
5368	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5369		if (PyErr_Occurred()) SWIG_fail;
5370		}
5371		{
5372		try {
5373	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
5373	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5374
5375	+	}catch (const BossSchedFailure & e) {
5376	+	PyErr_SetString ( SchedulerError, e.what() );
5377	+	return NULL;
5378		}catch (const std::exception& e) {
5379	<	SWIG_exception(SWIG_RuntimeError, e.what());
5379	>	PyErr_SetString ( BossError, e.what() );
5380	>	return NULL;
5381		}
5382		}
5383		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4954 \| Line 5398 \| *static PyObject _wrap_delete_BossAdmini**
5398		try {
5399		delete arg1;
5400
5401	+	}catch (const BossSchedFailure & e) {
5402	+	PyErr_SetString ( SchedulerError, e.what() );
5403	+	return NULL;
5404		}catch (const std::exception& e) {
5405	<	SWIG_exception(SWIG_RuntimeError, e.what());
5405	>	PyErr_SetString ( BossError, e.what() );
5406	>	return NULL;
5407		}
5408		}
5409		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4977 \| Line 5425 \| *static PyObject _wrap_BossAdministrator**
5425		try {
5426		result = (int)(arg1)->configureDB();
5427
5428	+	}catch (const BossSchedFailure & e) {
5429	+	PyErr_SetString ( SchedulerError, e.what() );
5430	+	return NULL;
5431		}catch (const std::exception& e) {
5432	<	SWIG_exception(SWIG_RuntimeError, e.what());
5432	>	PyErr_SetString ( BossError, e.what() );
5433	>	return NULL;
5434		}
5435		}
5436		resultobj = PyInt_FromLong((long)result);
#	Line 5011 \| Line 5463 \| *static PyObject _wrap_BossAdministrator**
5463		try {
5464		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5465
5466	+	}catch (const BossSchedFailure & e) {
5467	+	PyErr_SetString ( SchedulerError, e.what() );
5468	+	return NULL;
5469		}catch (const std::exception& e) {
5470	<	SWIG_exception(SWIG_RuntimeError, e.what());
5470	>	PyErr_SetString ( BossError, e.what() );
5471	>	return NULL;
5472		}
5473		}
5474		resultobj = PyInt_FromLong((long)result);
#	Line 5045 \| Line 5501 \| *static PyObject _wrap_BossAdministrator**
5501		try {
5502		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5503
5504	+	}catch (const BossSchedFailure & e) {
5505	+	PyErr_SetString ( SchedulerError, e.what() );
5506	+	return NULL;
5507		}catch (const std::exception& e) {
5508	<	SWIG_exception(SWIG_RuntimeError, e.what());
5508	>	PyErr_SetString ( BossError, e.what() );
5509	>	return NULL;
5510		}
5511		}
5512		resultobj = PyInt_FromLong((long)result);
#	Line 5079 \| Line 5539 \| *static PyObject _wrap_BossAdministrator**
5539		try {
5540		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5541
5542	+	}catch (const BossSchedFailure & e) {
5543	+	PyErr_SetString ( SchedulerError, e.what() );
5544	+	return NULL;
5545		}catch (const std::exception& e) {
5546	<	SWIG_exception(SWIG_RuntimeError, e.what());
5546	>	PyErr_SetString ( BossError, e.what() );
5547	>	return NULL;
5548		}
5549		}
5550		resultobj = PyInt_FromLong((long)result);
#	Line 5113 \| Line 5577 \| *static PyObject _wrap_BossAdministrator**
5577		try {
5578		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5579
5580	+	}catch (const BossSchedFailure & e) {
5581	+	PyErr_SetString ( SchedulerError, e.what() );
5582	+	return NULL;
5583		}catch (const std::exception& e) {
5584	<	SWIG_exception(SWIG_RuntimeError, e.what());
5584	>	PyErr_SetString ( BossError, e.what() );
5585	>	return NULL;
5586		}
5587		}
5588		resultobj = PyInt_FromLong((long)result);
#	Line 5147 \| Line 5615 \| *static PyObject _wrap_BossAdministrator**
5615		try {
5616		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5617
5618	+	}catch (const BossSchedFailure & e) {
5619	+	PyErr_SetString ( SchedulerError, e.what() );
5620	+	return NULL;
5621		}catch (const std::exception& e) {
5622	<	SWIG_exception(SWIG_RuntimeError, e.what());
5622	>	PyErr_SetString ( BossError, e.what() );
5623	>	return NULL;
5624		}
5625		}
5626		resultobj = PyInt_FromLong((long)result);
#	Line 5213 \| Line 5685 \| *static PyObject _wrap_BossAdministrator**
5685		try {
5686		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5687
5688	+	}catch (const BossSchedFailure & e) {
5689	+	PyErr_SetString ( SchedulerError, e.what() );
5690	+	return NULL;
5691		}catch (const std::exception& e) {
5692	<	SWIG_exception(SWIG_RuntimeError, e.what());
5692	>	PyErr_SetString ( BossError, e.what() );
5693	>	return NULL;
5694		}
5695		}
5696		resultobj = PyInt_FromLong((long)result);
#	Line 5303 \| Line 5779 \| *static PyObject _wrap_BossAdministrator**
5779		try {
5780		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5781
5782	+	}catch (const BossSchedFailure & e) {
5783	+	PyErr_SetString ( SchedulerError, e.what() );
5784	+	return NULL;
5785		}catch (const std::exception& e) {
5786	<	SWIG_exception(SWIG_RuntimeError, e.what());
5786	>	PyErr_SetString ( BossError, e.what() );
5787	>	return NULL;
5788		}
5789		}
5790		resultobj = PyInt_FromLong((long)result);
#	Line 5379 \| Line 5859 \| *static PyObject _wrap_BossAdministrator**
5859		try {
5860		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5861
5862	+	}catch (const BossSchedFailure & e) {
5863	+	PyErr_SetString ( SchedulerError, e.what() );
5864	+	return NULL;
5865		}catch (const std::exception& e) {
5866	<	SWIG_exception(SWIG_RuntimeError, e.what());
5866	>	PyErr_SetString ( BossError, e.what() );
5867	>	return NULL;
5868		}
5869		}
5870		resultobj = PyInt_FromLong((long)result);
#	Line 5408 \| Line 5892 \| *static PyObject _wrap_BossAdministrator**
5892		std::string arg13 = (std::string) "" ;
5893		bool arg14 = (bool) false ;
5894		bool arg15 = (bool) false ;
5895	+	bool arg16 = (bool) false ;
5896	+	bool arg17 = (bool) false ;
5897		int result;
5898		std::string temp2 ;
5899		std::string temp11 ;
#	Line 5426 \| Line 5912 \| *static PyObject _wrap_BossAdministrator**
5912		PyObject * obj12 = 0 ;
5913		PyObject * obj13 = 0 ;
5914		PyObject * obj14 = 0 ;
5915	+	PyObject * obj15 = 0 ;
5916	+	PyObject * obj16 = 0 ;
5917
5918	<	if(!PyArg_ParseTuple(args,(char *)"OO\|OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) goto fail;
5918	>	if(!PyArg_ParseTuple(args,(char *)"OO\|OOOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) goto fail;
5919		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5920		{
5921		if (PyString_Check(obj1)) {
#	Line 5535 \| Line 6023 \| *static PyObject _wrap_BossAdministrator**
6023		arg15 = PyInt_AsLong(obj14) ? true : false;
6024		if (PyErr_Occurred()) SWIG_fail;
6025		}
6026	+	if (obj15) {
6027	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6028	+	if (PyErr_Occurred()) SWIG_fail;
6029	+	}
6030	+	if (obj16) {
6031	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6032	+	if (PyErr_Occurred()) SWIG_fail;
6033	+	}
6034		{
6035		try {
6036	<	result = (int)(arg1)->registerScheduler((std::string const &)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)arg11,arg12,arg13,arg14,arg15);
6036	>	result = (int)(arg1)->registerScheduler((std::string const &)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)arg11,arg12,arg13,arg14,arg15,arg16,arg17);
6037
6038	+	}catch (const BossSchedFailure & e) {
6039	+	PyErr_SetString ( SchedulerError, e.what() );
6040	+	return NULL;
6041		}catch (const std::exception& e) {
6042	<	SWIG_exception(SWIG_RuntimeError, e.what());
6042	>	PyErr_SetString ( BossError, e.what() );
6043	>	return NULL;
6044		}
6045		}
6046		resultobj = PyInt_FromLong((long)result);
#	Line 5562 \| Line 6062 \| *static PyObject _wrap_BossAdministrator**
6062		try {
6063		result = (arg1)->help();
6064
6065	+	}catch (const BossSchedFailure & e) {
6066	+	PyErr_SetString ( SchedulerError, e.what() );
6067	+	return NULL;
6068		}catch (const std::exception& e) {
6069	<	SWIG_exception(SWIG_RuntimeError, e.what());
6069	>	PyErr_SetString ( BossError, e.what() );
6070	>	return NULL;
6071		}
6072		}
6073		{
#	Line 5601 \| Line 6105 \| *static PyObject _wrap_BossAdministrator**
6105		try {
6106		result = (arg1)->SQL(arg2,arg3);
6107
6108	+	}catch (const BossSchedFailure & e) {
6109	+	PyErr_SetString ( SchedulerError, e.what() );
6110	+	return NULL;
6111		}catch (const std::exception& e) {
6112	<	SWIG_exception(SWIG_RuntimeError, e.what());
6112	>	PyErr_SetString ( BossError, e.what() );
6113	>	return NULL;
6114		}
6115		}
6116		{
#	Line 5673 \| Line 6181 \| *static PyObject _wrap_BossAdministrator**
6181		try {
6182		result = (int)(arg1)->purge((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5);
6183
6184	+	}catch (const BossSchedFailure & e) {
6185	+	PyErr_SetString ( SchedulerError, e.what() );
6186	+	return NULL;
6187		}catch (const std::exception& e) {
6188	<	SWIG_exception(SWIG_RuntimeError, e.what());
6188	>	PyErr_SetString ( BossError, e.what() );
6189	>	return NULL;
6190		}
6191		}
6192		resultobj = PyInt_FromLong((long)result);
#	Line 5704 \| Line 6216 \| *static PyObject _wrap_BossAdministrator**
6216		try {
6217		result = (int)(arg1)->registerPlugins(arg2);
6218
6219	+	}catch (const BossSchedFailure & e) {
6220	+	PyErr_SetString ( SchedulerError, e.what() );
6221	+	return NULL;
6222		}catch (const std::exception& e) {
6223	<	SWIG_exception(SWIG_RuntimeError, e.what());
6223	>	PyErr_SetString ( BossError, e.what() );
6224	>	return NULL;
6225		}
6226		}
6227		resultobj = PyInt_FromLong((long)result);
#	Line 5752 \| Line 6268 \| static PyMethodDef SwigMethods[] = {
6268		{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6269		{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6270		{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5755	–	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5756	–	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5757	–	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5758	–	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5759	–	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5760	–	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5761	–	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6271		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6272		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6273		{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6274		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6275		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6276		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6277	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6278	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6279	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6280	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6281		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6282		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6283		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5777 \| Line 6290 \| static PyMethodDef SwigMethods[] = {
6290		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6291		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6292		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6293	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6294	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6295	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6296	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6297	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6298	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6299	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6300		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6301		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6302		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5784 \| Line 6304 \| static PyMethodDef SwigMethods[] = {
6304		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6305		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6306		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5787	–	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5788	–	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5789	–	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
5790	–	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5791	–	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6307		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6308		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6309		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
#	Line 5807 \| Line 6322 \| static PyMethodDef SwigMethods[] = {
6322		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6323		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6324		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
5810	–	{ (char *)"BossTask_getAllOutput", _wrap_BossTask_getAllOutput, METH_VARARGS },
6325		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6326		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6327		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6328		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6329	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6330	+	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6331	+	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6332	+	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6333	+	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6334		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5816	–	{ (char *)"prompt", _wrap_prompt, METH_VARARGS },
6335		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6336		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
6337		{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
#	Line 5837 \| Line 6355 \| static PyMethodDef SwigMethods[] = {
6355
6356		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6357
6358	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6359		static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t", 0, "std::vector<std::pair<BossProgram,BossProgramExec > > *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t"},{0}};
6360		static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator", 0, "std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator"},{0}};
5842	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6361		static swig_type_info _swigt__p_std__vectorTBossTask_p_t[] = {{"_p_std__vectorTBossTask_p_t", 0, "std::vector<BossTask * > *", 0},{"_p_std__vectorTBossTask_p_t"},{0}};
6362		static swig_type_info _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t[] = {{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t", 0, "std::map<std::string,std::map<std::string,std::string > > *", 0},{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t"},{0}};
6363	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6364		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6365		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5847	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
5848	–	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6366		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6367	+	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6368		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6369		static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6370		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6371		static swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0},{"_p_std__vectorTstd__string_t"},{0}};
6372		static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
6373		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5856	–	static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
6374		static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
6375	+	static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
6376		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6377
6378		static swig_type_info *swig_types_initial[] = {
6379	+	_swigt__p_XMLDoc,
6380		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6381		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
5863	–	_swigt__p_XMLDoc,
6382		_swigt__p_std__vectorTBossTask_p_t,
6383		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6384	+	_swigt__p_std__ostream,
6385		_swigt__p_BossTask,
6386		_swigt__p_BossTaskException,
5868	–	_swigt__p_std__ostream,
5869	–	_swigt__p_BossAttributeContainer,
6387		_swigt__p_printOption,
6388	+	_swigt__p_BossAttributeContainer,
6389		_swigt__p_BossJob,
6390		_swigt__p_BossDatabase,
6391		_swigt__p_BossSession,
6392		_swigt__p_std__vectorTstd__string_t,
6393		_swigt__p_std__mapTstd__string_std__string_t,
6394		_swigt__p_BossAdministratorSession,
5877	–	_swigt__p_BossTask__job_iterator,
6395		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6396	+	_swigt__p_BossTask__job_iterator,
6397		_swigt__p_jobStates,
6398		0
6399		};
#	Line 5919 \| Line 6437 \| SWIGEXPORT(void) SWIG_init(void) {
6437		}
6438		SWIG_InstallConstants(d,swig_const_table);
6439
6440	+
6441	+	// define custom exceptions
6442	+	PyObject *e;
6443	+	e = Py_InitModule("BossSession", NULL);
6444	+	// generic BOSS exception
6445	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6446	+	Py_INCREF(BossError);
6447	+	PyModule_AddObject(e, "BossError", BossError);
6448	+	// scheduler interaction BOSS exception
6449	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6450	+	Py_INCREF(SchedulerError);
6451	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6452	+
6453		}
6454

Diff Legend

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents): Revision 1.13 by gcodispo, Fri Nov 3 15:03:10 2006 UTC vs. Revision 1.19 by gcodispo, Wed Dec 13 18:26:33 2006 UTC

Diff Legend

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.13 by gcodispo, Fri Nov 3 15:03:10 2006 UTC vs.
Revision 1.19 by gcodispo, Wed Dec 13 18:26:33 2006 UTC