ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.18 by gcodispo, Mon Dec 11 09:16:06 2006 UTC vs.
Revision 1.23 by gcodispo, Fri Mar 2 13:06:44 2007 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[0]
658	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[1]
659	<	#define  SWIGTYPE_p_XMLDoc swig_types[2]
657	>	#define  SWIGTYPE_p_XMLDoc swig_types[0]
658	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
659	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660		#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[3]
661		#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662	<	#define  SWIGTYPE_p_BossTask swig_types[5]
663	<	#define  SWIGTYPE_p_BossTaskException swig_types[6]
664	<	#define  SWIGTYPE_p_std__ostream swig_types[7]
665	<	#define  SWIGTYPE_p_BossAttributeContainer swig_types[8]
666	<	#define  SWIGTYPE_p_printOption swig_types[9]
662	>	#define  SWIGTYPE_p_std__ostream swig_types[5]
663	>	#define  SWIGTYPE_p_BossTask swig_types[6]
664	>	#define  SWIGTYPE_p_BossTaskException swig_types[7]
665	>	#define  SWIGTYPE_p_printOption swig_types[8]
666	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[9]
667		#define  SWIGTYPE_p_BossJob swig_types[10]
668		#define  SWIGTYPE_p_BossDatabase swig_types[11]
669		#define  SWIGTYPE_p_BossSession swig_types[12]
670		#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671		#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672		#define  SWIGTYPE_p_BossAdministratorSession swig_types[15]
673	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[16]
674	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[17]
673	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[17]
675		#define  SWIGTYPE_p_jobStates swig_types[18]
676		static swig_type_info *swig_types[20];
677
#	Line 917 | Line 917 | void std_vectorlstd_string_g___delslice_
917		self->erase(self->begin()+i,self->begin()+j);
918		}
919
920	+	static PyObject * BossError;
921	+	static PyObject * SchedulerError;
922		#include "BossSession.h"
923		#include "BossAdministratorSession.h"
924		#include "BossTask.h"
#	Line 928 | Line 930 | void std_vectorlstd_string_g___delslice_
930		#include "BossProgramExec.h"
931		#include "BossDatabase.h"
932		#include "BossScheduler.h"
933	+	#include "BossDeclaration.h"
934
935		PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
936		PyObject *  my_list = PyList_New( my_vec.size());
#	Line 954 | Line 957 | PyObject *BossSession_schedulers(BossSes
957		std::vector<std::string> my_vec = self->showSchedulers();
958		return BossSession_show( self, my_vec );
959		}
960	<	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
960	>	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout,bool keepfile){
961		std::vector<std::string> my_vec = self->listMatch( scheduler,
962		schclassad,
963		keepfile,
964		taskid,
965	<	jobid);
965	>	jobid,
966	>	timeout);
967		return BossSession_show( self, my_vec );
968		}
969	<	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,bool avoidCheck){
969	>	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,unsigned int timeout,bool avoidCheck){
970		if ( !avoidCheck ) {
971		self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
972	<	type, user, after, before);
972	>	type, user, after, before, timeout );
973		}
974		PyObject * job_dict = PyList_New(0);
975		std::vector <std::string>
#	Line 981 | Line 985 | PyObject *BossTask_appendToPyDict(BossTa
985		BossAttributeContainer::const_iterator it_end = obj.end ();
986		for (BossAttributeContainer::const_iterator it = obj.begin ();
987		it != it_end; ++it) {
988	<	tmp = (*it).first.name ();
989	<	char * key = new char[ tmp.size() ];
990	<	key = strdup(tmp.c_str());
987	<	tmp = (*it).second.value ();
988	<	PyObject * val = PyString_FromString( tmp.c_str() );
989	<	PyDict_SetItemString( dict, key, val );
990	<	delete [] key;
988	>	// New code semantically isomorphic to the old one //Fabio
989	>
990	>	PyDict_SetItemString( dict, it->first.name().c_str(), PyString_FromString(it->second.value().c_str()) );
991		}
992		return dict;
993		}
#	Line 1003 | Line 1003 | PyObject *BossTask_jobDict(BossTask cons
1003		std::set<std::string>::const_iterator sch_end =  sch.end();
1004		for (std::set<std::string>::const_iterator it =sch.begin();
1005		it != sch_end; ++ it ) {
1006	<	tmp = (*it);
1007	<	char * key = new char[ tmp.size() ];
1008	<	key = strdup(tmp.c_str());
1006	>	unsigned int size = it->size() +1;
1007	>	char * key = new char[ size ];
1008	>	strncpy( key, tmp.c_str(), size );
1009		tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1010	<	PyObject * val = PyString_FromString( tmp.c_str() );
1011	<	PyDict_SetItemString( job_dict, key, val );
1010	>	PyDict_SetItemString( job_dict, key,
1011	>	PyString_FromString( tmp.c_str() ) );
1012		delete [] key;
1013		}
1014		return job_dict;
#	Line 1086 | Line 1086 | static PyObject *_wrap_new_objectMap__SW
1086		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1087
1088		}catch (const BossSchedFailure & e) {
1089	<	SWIG_exception(SWIG_ValueError, e.what());
1089	>	PyErr_SetString ( SchedulerError, e.what() );
1090	>	return NULL;
1091		}catch (const std::exception& e) {
1092	<	SWIG_exception(SWIG_RuntimeError, e.what());
1092	>	PyErr_SetString ( BossError, e.what() );
1093	>	return NULL;
1094		}
1095		}
1096		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1147 | Line 1149 | static PyObject *_wrap_new_objectMap__SW
1149		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1150
1151		}catch (const BossSchedFailure & e) {
1152	<	SWIG_exception(SWIG_ValueError, e.what());
1152	>	PyErr_SetString ( SchedulerError, e.what() );
1153	>	return NULL;
1154		}catch (const std::exception& e) {
1155	<	SWIG_exception(SWIG_RuntimeError, e.what());
1155	>	PyErr_SetString ( BossError, e.what() );
1156	>	return NULL;
1157		}
1158		}
1159		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1264 | Line 1268 | static PyObject *_wrap_objectMap___len__
1268		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1269
1270		}catch (const BossSchedFailure & e) {
1271	<	SWIG_exception(SWIG_ValueError, e.what());
1271	>	PyErr_SetString ( SchedulerError, e.what() );
1272	>	return NULL;
1273		}catch (const std::exception& e) {
1274	<	SWIG_exception(SWIG_RuntimeError, e.what());
1274	>	PyErr_SetString ( BossError, e.what() );
1275	>	return NULL;
1276		}
1277		}
1278		resultobj = PyInt_FromLong((long)result);
#	Line 1288 | Line 1294 | static PyObject *_wrap_objectMap_clear(P
1294		(arg1)->clear();
1295
1296		}catch (const BossSchedFailure & e) {
1297	<	SWIG_exception(SWIG_ValueError, e.what());
1297	>	PyErr_SetString ( SchedulerError, e.what() );
1298	>	return NULL;
1299		}catch (const std::exception& e) {
1300	<	SWIG_exception(SWIG_RuntimeError, e.what());
1300	>	PyErr_SetString ( BossError, e.what() );
1301	>	return NULL;
1302		}
1303		}
1304		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1313 | Line 1321 | static PyObject *_wrap_objectMap___nonze
1321		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1322
1323		}catch (const BossSchedFailure & e) {
1324	<	SWIG_exception(SWIG_ValueError, e.what());
1324	>	PyErr_SetString ( SchedulerError, e.what() );
1325	>	return NULL;
1326		}catch (const std::exception& e) {
1327	<	SWIG_exception(SWIG_RuntimeError, e.what());
1327	>	PyErr_SetString ( BossError, e.what() );
1328	>	return NULL;
1329		}
1330		}
1331		resultobj = PyInt_FromLong((long)result);
#	Line 1387 | Line 1397 | static PyObject *_wrap_objectMap___setit
1397		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1398
1399		}catch (const BossSchedFailure & e) {
1400	<	SWIG_exception(SWIG_ValueError, e.what());
1400	>	PyErr_SetString ( SchedulerError, e.what() );
1401	>	return NULL;
1402		}catch (const std::exception& e) {
1403	<	SWIG_exception(SWIG_RuntimeError, e.what());
1403	>	PyErr_SetString ( BossError, e.what() );
1404	>	return NULL;
1405		}
1406		}
1407		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1451 | Line 1463 | static PyObject *_wrap_objectMap_has_key
1463		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1464
1465		}catch (const BossSchedFailure & e) {
1466	<	SWIG_exception(SWIG_ValueError, e.what());
1466	>	PyErr_SetString ( SchedulerError, e.what() );
1467	>	return NULL;
1468		}catch (const std::exception& e) {
1469	<	SWIG_exception(SWIG_RuntimeError, e.what());
1469	>	PyErr_SetString ( BossError, e.what() );
1470	>	return NULL;
1471		}
1472		}
1473		resultobj = PyInt_FromLong((long)result);
#	Line 1476 | Line 1490 | static PyObject *_wrap_objectMap_keys(Py
1490		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1491
1492		}catch (const BossSchedFailure & e) {
1493	<	SWIG_exception(SWIG_ValueError, e.what());
1493	>	PyErr_SetString ( SchedulerError, e.what() );
1494	>	return NULL;
1495		}catch (const std::exception& e) {
1496	<	SWIG_exception(SWIG_RuntimeError, e.what());
1496	>	PyErr_SetString ( BossError, e.what() );
1497	>	return NULL;
1498		}
1499		}
1500		resultobj = result;
#	Line 1501 | Line 1517 | static PyObject *_wrap_objectMap_values(
1517		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1518
1519		}catch (const BossSchedFailure & e) {
1520	<	SWIG_exception(SWIG_ValueError, e.what());
1520	>	PyErr_SetString ( SchedulerError, e.what() );
1521	>	return NULL;
1522		}catch (const std::exception& e) {
1523	<	SWIG_exception(SWIG_RuntimeError, e.what());
1523	>	PyErr_SetString ( BossError, e.what() );
1524	>	return NULL;
1525		}
1526		}
1527		resultobj = result;
#	Line 1526 | Line 1544 | static PyObject *_wrap_objectMap_items(P
1544		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1545
1546		}catch (const BossSchedFailure & e) {
1547	<	SWIG_exception(SWIG_ValueError, e.what());
1547	>	PyErr_SetString ( SchedulerError, e.what() );
1548	>	return NULL;
1549		}catch (const std::exception& e) {
1550	<	SWIG_exception(SWIG_RuntimeError, e.what());
1550	>	PyErr_SetString ( BossError, e.what() );
1551	>	return NULL;
1552		}
1553		}
1554		resultobj = result;
#	Line 1559 | Line 1579 | static PyObject *_wrap_objectMap___conta
1579		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1580
1581		}catch (const BossSchedFailure & e) {
1582	<	SWIG_exception(SWIG_ValueError, e.what());
1582	>	PyErr_SetString ( SchedulerError, e.what() );
1583	>	return NULL;
1584		}catch (const std::exception& e) {
1585	<	SWIG_exception(SWIG_RuntimeError, e.what());
1585	>	PyErr_SetString ( BossError, e.what() );
1586	>	return NULL;
1587		}
1588		}
1589		resultobj = PyInt_FromLong((long)result);
#	Line 1607 | Line 1629 | static PyObject *_wrap_delete_objectMap(
1629		delete arg1;
1630
1631		}catch (const BossSchedFailure & e) {
1632	<	SWIG_exception(SWIG_ValueError, e.what());
1632	>	PyErr_SetString ( SchedulerError, e.what() );
1633	>	return NULL;
1634		}catch (const std::exception& e) {
1635	<	SWIG_exception(SWIG_RuntimeError, e.what());
1635	>	PyErr_SetString ( BossError, e.what() );
1636	>	return NULL;
1637		}
1638		}
1639		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1642 | Line 1666 | static PyObject *_wrap_new_vector_string
1666		result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1667
1668		}catch (const BossSchedFailure & e) {
1669	<	SWIG_exception(SWIG_ValueError, e.what());
1669	>	PyErr_SetString ( SchedulerError, e.what() );
1670	>	return NULL;
1671		}catch (const std::exception& e) {
1672	<	SWIG_exception(SWIG_RuntimeError, e.what());
1672	>	PyErr_SetString ( BossError, e.what() );
1673	>	return NULL;
1674		}
1675		}
1676		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1679 | Line 1705 | static PyObject *_wrap_new_vector_string
1705		result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1706
1707		}catch (const BossSchedFailure & e) {
1708	<	SWIG_exception(SWIG_ValueError, e.what());
1708	>	PyErr_SetString ( SchedulerError, e.what() );
1709	>	return NULL;
1710		}catch (const std::exception& e) {
1711	<	SWIG_exception(SWIG_RuntimeError, e.what());
1711	>	PyErr_SetString ( BossError, e.what() );
1712	>	return NULL;
1713		}
1714		}
1715		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1733 | Line 1761 | static PyObject *_wrap_new_vector_string
1761		result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1762
1763		}catch (const BossSchedFailure & e) {
1764	<	SWIG_exception(SWIG_ValueError, e.what());
1764	>	PyErr_SetString ( SchedulerError, e.what() );
1765	>	return NULL;
1766		}catch (const std::exception& e) {
1767	<	SWIG_exception(SWIG_RuntimeError, e.what());
1767	>	PyErr_SetString ( BossError, e.what() );
1768	>	return NULL;
1769		}
1770		}
1771		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1862 | Line 1892 | static PyObject *_wrap_vector_string___l
1892		result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1893
1894		}catch (const BossSchedFailure & e) {
1895	<	SWIG_exception(SWIG_ValueError, e.what());
1895	>	PyErr_SetString ( SchedulerError, e.what() );
1896	>	return NULL;
1897		}catch (const std::exception& e) {
1898	<	SWIG_exception(SWIG_RuntimeError, e.what());
1898	>	PyErr_SetString ( BossError, e.what() );
1899	>	return NULL;
1900		}
1901		}
1902		resultobj = PyInt_FromLong((long)result);
#	Line 1916 | Line 1948 | static PyObject *_wrap_vector_string___n
1948		result = (bool)((std::vector<std::string > const *)arg1)->empty();
1949
1950		}catch (const BossSchedFailure & e) {
1951	<	SWIG_exception(SWIG_ValueError, e.what());
1951	>	PyErr_SetString ( SchedulerError, e.what() );
1952	>	return NULL;
1953		}catch (const std::exception& e) {
1954	<	SWIG_exception(SWIG_RuntimeError, e.what());
1954	>	PyErr_SetString ( BossError, e.what() );
1955	>	return NULL;
1956		}
1957		}
1958		resultobj = PyInt_FromLong((long)result);
#	Line 1940 | Line 1974 | static PyObject *_wrap_vector_string_cle
1974		(arg1)->clear();
1975
1976		}catch (const BossSchedFailure & e) {
1977	<	SWIG_exception(SWIG_ValueError, e.what());
1977	>	PyErr_SetString ( SchedulerError, e.what() );
1978	>	return NULL;
1979		}catch (const std::exception& e) {
1980	<	SWIG_exception(SWIG_RuntimeError, e.what());
1980	>	PyErr_SetString ( BossError, e.what() );
1981	>	return NULL;
1982		}
1983		}
1984		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1972 | Line 2008 | static PyObject *_wrap_vector_string_app
2008		(arg1)->push_back(arg2);
2009
2010		}catch (const BossSchedFailure & e) {
2011	<	SWIG_exception(SWIG_ValueError, e.what());
2011	>	PyErr_SetString ( SchedulerError, e.what() );
2012	>	return NULL;
2013		}catch (const std::exception& e) {
2014	<	SWIG_exception(SWIG_RuntimeError, e.what());
2014	>	PyErr_SetString ( BossError, e.what() );
2015	>	return NULL;
2016		}
2017		}
2018		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2050 | Line 2088 | static PyObject *_wrap_vector_string___g
2088		result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2089
2090		}catch (const BossSchedFailure & e) {
2091	<	SWIG_exception(SWIG_ValueError, e.what());
2091	>	PyErr_SetString ( SchedulerError, e.what() );
2092	>	return NULL;
2093		}catch (const std::exception& e) {
2094	<	SWIG_exception(SWIG_RuntimeError, e.what());
2094	>	PyErr_SetString ( BossError, e.what() );
2095	>	return NULL;
2096		}
2097		}
2098		{
#	Line 2144 | Line 2184 | static PyObject *_wrap_vector_string___s
2184		std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2185
2186		}catch (const BossSchedFailure & e) {
2187	<	SWIG_exception(SWIG_ValueError, e.what());
2187	>	PyErr_SetString ( SchedulerError, e.what() );
2188	>	return NULL;
2189		}catch (const std::exception& e) {
2190	<	SWIG_exception(SWIG_RuntimeError, e.what());
2190	>	PyErr_SetString ( BossError, e.what() );
2191	>	return NULL;
2192		}
2193		}
2194		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2193 | Line 2235 | static PyObject *_wrap_vector_string___d
2235		std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2236
2237		}catch (const BossSchedFailure & e) {
2238	<	SWIG_exception(SWIG_ValueError, e.what());
2238	>	PyErr_SetString ( SchedulerError, e.what() );
2239	>	return NULL;
2240		}catch (const std::exception& e) {
2241	<	SWIG_exception(SWIG_RuntimeError, e.what());
2241	>	PyErr_SetString ( BossError, e.what() );
2242	>	return NULL;
2243		}
2244		}
2245		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2217 | Line 2261 | static PyObject *_wrap_delete_vector_str
2261		delete arg1;
2262
2263		}catch (const BossSchedFailure & e) {
2264	<	SWIG_exception(SWIG_ValueError, e.what());
2264	>	PyErr_SetString ( SchedulerError, e.what() );
2265	>	return NULL;
2266		}catch (const std::exception& e) {
2267	<	SWIG_exception(SWIG_RuntimeError, e.what());
2267	>	PyErr_SetString ( BossError, e.what() );
2268	>	return NULL;
2269		}
2270		}
2271		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2236 | Line 2282 | static PyObject * vector_string_swigregi
2282		Py_INCREF(obj);
2283		return Py_BuildValue((char *)"");
2284		}
2285	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
2285	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2286		PyObject *resultobj;
2287	<	BossSession *arg1 = (BossSession *) 0 ;
2288	<	std::vector<std::string > *arg2 = 0 ;
2289	<	PyObject *result;
2287	>	std::string arg1 = (std::string) "" ;
2288	>	std::string arg2 = (std::string) "2" ;
2289	>	std::string arg3 = (std::string) "" ;
2290	>	std::string arg4 = (std::string) "" ;
2291	>	BossSession *result;
2292		PyObject * obj0 = 0 ;
2293		PyObject * obj1 = 0 ;
2294	+	PyObject * obj2 = 0 ;
2295	+	PyObject * obj3 = 0 ;
2296
2297	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2298	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2299	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2300	<	if (arg2 == NULL) {
2301	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2297	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2298	>	if (obj0) {
2299	>	{
2300	>	if (PyString_Check(obj0))
2301	>	arg1 = std::string(PyString_AsString(obj0));
2302	>	else
2303	>	SWIG_exception(SWIG_TypeError, "string expected");
2304	>	}
2305		}
2306	<	{
2307	<	try {
2308	<	result = (PyObject *)BossSession_show(arg1,*arg2);
2309	<
2310	<	}catch (const BossSchedFailure & e) {
2311	<	SWIG_exception(SWIG_ValueError, e.what());
2312	<	}catch (const std::exception& e) {
2313	<	SWIG_exception(SWIG_RuntimeError, e.what());
2306	>	if (obj1) {
2307	>	{
2308	>	if (PyString_Check(obj1))
2309	>	arg2 = std::string(PyString_AsString(obj1));
2310	>	else
2311	>	SWIG_exception(SWIG_TypeError, "string expected");
2312	>	}
2313	>	}
2314	>	if (obj2) {
2315	>	{
2316	>	if (PyString_Check(obj2))
2317	>	arg3 = std::string(PyString_AsString(obj2));
2318	>	else
2319	>	SWIG_exception(SWIG_TypeError, "string expected");
2320	>	}
2321	>	}
2322	>	if (obj3) {
2323	>	{
2324	>	if (PyString_Check(obj3))
2325	>	arg4 = std::string(PyString_AsString(obj3));
2326	>	else
2327	>	SWIG_exception(SWIG_TypeError, "string expected");
2328		}
2329		}
2263	–	resultobj = result;
2264	–	return resultobj;
2265	–	fail:
2266	–	return NULL;
2267	–	}
2268	–
2269	–
2270	–	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
2271	–	PyObject *resultobj;
2272	–	BossSession *arg1 = (BossSession *) 0 ;
2273	–	PyObject *result;
2274	–	PyObject * obj0 = 0 ;
2275	–
2276	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2277	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2330		{
2331		try {
2332	<	result = (PyObject *)BossSession_CHTools(arg1);
2332	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2333
2334		}catch (const BossSchedFailure & e) {
2335	<	SWIG_exception(SWIG_ValueError, e.what());
2335	>	PyErr_SetString ( SchedulerError, e.what() );
2336	>	return NULL;
2337		}catch (const std::exception& e) {
2338	<	SWIG_exception(SWIG_RuntimeError, e.what());
2338	>	PyErr_SetString ( BossError, e.what() );
2339	>	return NULL;
2340		}
2341		}
2342	<	resultobj = result;
2342	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2343		return resultobj;
2344		fail:
2345		return NULL;
2346		}
2347
2348
2349	<	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
2349	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2350		PyObject *resultobj;
2351		BossSession *arg1 = (BossSession *) 0 ;
2298	–	PyObject *result;
2352		PyObject * obj0 = 0 ;
2353
2354	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2354	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2355		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2356		{
2357		try {
2358	<	result = (PyObject *)BossSession_ProgramTypes(arg1);
2358	>	delete arg1;
2359
2360		}catch (const BossSchedFailure & e) {
2361	<	SWIG_exception(SWIG_ValueError, e.what());
2361	>	PyErr_SetString ( SchedulerError, e.what() );
2362	>	return NULL;
2363		}catch (const std::exception& e) {
2364	<	SWIG_exception(SWIG_RuntimeError, e.what());
2364	>	PyErr_SetString ( BossError, e.what() );
2365	>	return NULL;
2366		}
2367		}
2368	<	resultobj = result;
2368	>	Py_INCREF(Py_None); resultobj = Py_None;
2369		return resultobj;
2370		fail:
2371		return NULL;
2372		}
2373
2374
2375	<	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
2375	>	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2376		PyObject *resultobj;
2377		BossSession *arg1 = (BossSession *) 0 ;
2323	–	PyObject *result;
2378		PyObject * obj0 = 0 ;
2379
2380	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2380	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2381		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2382		{
2383		try {
2384	<	result = (PyObject *)BossSession_RTMons(arg1);
2384	>	(arg1)->resetDB();
2385
2386		}catch (const BossSchedFailure & e) {
2387	<	SWIG_exception(SWIG_ValueError, e.what());
2387	>	PyErr_SetString ( SchedulerError, e.what() );
2388	>	return NULL;
2389		}catch (const std::exception& e) {
2390	<	SWIG_exception(SWIG_RuntimeError, e.what());
2390	>	PyErr_SetString ( BossError, e.what() );
2391	>	return NULL;
2392		}
2393		}
2394	<	resultobj = result;
2394	>	Py_INCREF(Py_None); resultobj = Py_None;
2395		return resultobj;
2396		fail:
2397		return NULL;
2398		}
2399
2400
2401	<	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
2401	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2402		PyObject *resultobj;
2403		BossSession *arg1 = (BossSession *) 0 ;
2348	–	PyObject *result;
2404		PyObject * obj0 = 0 ;
2405
2406	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2406	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2407		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2408		{
2409		try {
2410	<	result = (PyObject *)BossSession_schedulers(arg1);
2410	>	(arg1)->clear();
2411
2412		}catch (const BossSchedFailure & e) {
2413	<	SWIG_exception(SWIG_ValueError, e.what());
2413	>	PyErr_SetString ( SchedulerError, e.what() );
2414	>	return NULL;
2415		}catch (const std::exception& e) {
2416	<	SWIG_exception(SWIG_RuntimeError, e.what());
2416	>	PyErr_SetString ( BossError, e.what() );
2417	>	return NULL;
2418		}
2419		}
2420	<	resultobj = result;
2420	>	Py_INCREF(Py_None); resultobj = Py_None;
2421		return resultobj;
2422		fail:
2423		return NULL;
2424		}
2425
2426
2427	<	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
2427	>	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2428		PyObject *resultobj;
2429		BossSession *arg1 = (BossSession *) 0 ;
2430	<	std::string *arg2 = 0 ;
2431	<	std::string *arg3 = 0 ;
2432	<	std::string const &arg4_defvalue = "" ;
2376	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
2377	<	std::string const &arg5_defvalue = "" ;
2378	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2379	<	bool arg6 = (bool) false ;
2380	<	PyObject *result;
2430	>	std::string const &arg2_defvalue = "" ;
2431	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
2432	>	BossTask *result;
2433		std::string temp2 ;
2382	–	std::string temp3 ;
2383	–	std::string temp4 ;
2384	–	std::string temp5 ;
2434		PyObject * obj0 = 0 ;
2435		PyObject * obj1 = 0 ;
2387	–	PyObject * obj2 = 0 ;
2388	–	PyObject * obj3 = 0 ;
2389	–	PyObject * obj4 = 0 ;
2390	–	PyObject * obj5 = 0 ;
2436
2437	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2437	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2438		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2439	<	{
2395	<	if (PyString_Check(obj1)) {
2396	<	temp2 = std::string(PyString_AsString(obj1));
2397	<	arg2 = &temp2;
2398	<	}else {
2399	<	SWIG_exception(SWIG_TypeError, "string expected");
2400	<	}
2401	<	}
2402	<	{
2403	<	if (PyString_Check(obj2)) {
2404	<	temp3 = std::string(PyString_AsString(obj2));
2405	<	arg3 = &temp3;
2406	<	}else {
2407	<	SWIG_exception(SWIG_TypeError, "string expected");
2408	<	}
2409	<	}
2410	<	if (obj3) {
2411	<	{
2412	<	if (PyString_Check(obj3)) {
2413	<	temp4 = std::string(PyString_AsString(obj3));
2414	<	arg4 = &temp4;
2415	<	}else {
2416	<	SWIG_exception(SWIG_TypeError, "string expected");
2417	<	}
2418	<	}
2419	<	}
2420	<	if (obj4) {
2439	>	if (obj1) {
2440		{
2441	<	if (PyString_Check(obj4)) {
2442	<	temp5 = std::string(PyString_AsString(obj4));
2443	<	arg5 = &temp5;
2441	>	if (PyString_Check(obj1)) {
2442	>	temp2 = std::string(PyString_AsString(obj1));
2443	>	arg2 = &temp2;
2444		}else {
2445		SWIG_exception(SWIG_TypeError, "string expected");
2446		}
2447		}
2448		}
2430	–	if (obj5) {
2431	–	arg6 = PyInt_AsLong(obj5) ? true : false;
2432	–	if (PyErr_Occurred()) SWIG_fail;
2433	–	}
2449		{
2450		try {
2451	<	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
2451	>	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2452
2453		}catch (const BossSchedFailure & e) {
2454	<	SWIG_exception(SWIG_ValueError, e.what());
2454	>	PyErr_SetString ( SchedulerError, e.what() );
2455	>	return NULL;
2456		}catch (const std::exception& e) {
2457	<	SWIG_exception(SWIG_RuntimeError, e.what());
2457	>	PyErr_SetString ( BossError, e.what() );
2458	>	return NULL;
2459		}
2460		}
2461	<	resultobj = result;
2461	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2462		return resultobj;
2463		fail:
2464		return NULL;
2465		}
2466
2467
2468	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2468	>	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2469		PyObject *resultobj;
2470		BossSession *arg1 = (BossSession *) 0 ;
2471	<	int arg2 = (int) SCHEDULED ;
2455	<	std::string const &arg3_defvalue = "all" ;
2456	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
2457	<	std::string const &arg4_defvalue = "all" ;
2458	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
2459	<	std::string const &arg5_defvalue = "" ;
2460	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2461	<	std::string arg6 = (std::string) "" ;
2462	<	std::string arg7 = (std::string) "" ;
2463	<	std::string arg8 = (std::string) "" ;
2464	<	std::string arg9 = (std::string) "" ;
2465	<	bool arg10 = (bool) false ;
2466	<	PyObject *result;
2467	<	std::string temp3 ;
2468	<	std::string temp4 ;
2469	<	std::string temp5 ;
2470	<	PyObject * obj0 = 0 ;
2471	<	PyObject * obj2 = 0 ;
2472	<	PyObject * obj3 = 0 ;
2473	<	PyObject * obj4 = 0 ;
2474	<	PyObject * obj5 = 0 ;
2475	<	PyObject * obj6 = 0 ;
2476	<	PyObject * obj7 = 0 ;
2477	<	PyObject * obj8 = 0 ;
2478	<	PyObject * obj9 = 0 ;
2479	<
2480	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2481	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2482	<	if (obj2) {
2483	<	{
2484	<	if (PyString_Check(obj2)) {
2485	<	temp3 = std::string(PyString_AsString(obj2));
2486	<	arg3 = &temp3;
2487	<	}else {
2488	<	SWIG_exception(SWIG_TypeError, "string expected");
2489	<	}
2490	<	}
2491	<	}
2492	<	if (obj3) {
2493	<	{
2494	<	if (PyString_Check(obj3)) {
2495	<	temp4 = std::string(PyString_AsString(obj3));
2496	<	arg4 = &temp4;
2497	<	}else {
2498	<	SWIG_exception(SWIG_TypeError, "string expected");
2499	<	}
2500	<	}
2501	<	}
2502	<	if (obj4) {
2503	<	{
2504	<	if (PyString_Check(obj4)) {
2505	<	temp5 = std::string(PyString_AsString(obj4));
2506	<	arg5 = &temp5;
2507	<	}else {
2508	<	SWIG_exception(SWIG_TypeError, "string expected");
2509	<	}
2510	<	}
2511	<	}
2512	<	if (obj5) {
2513	<	{
2514	<	if (PyString_Check(obj5))
2515	<	arg6 = std::string(PyString_AsString(obj5));
2516	<	else
2517	<	SWIG_exception(SWIG_TypeError, "string expected");
2518	<	}
2519	<	}
2520	<	if (obj6) {
2521	<	{
2522	<	if (PyString_Check(obj6))
2523	<	arg7 = std::string(PyString_AsString(obj6));
2524	<	else
2525	<	SWIG_exception(SWIG_TypeError, "string expected");
2526	<	}
2527	<	}
2528	<	if (obj7) {
2529	<	{
2530	<	if (PyString_Check(obj7))
2531	<	arg8 = std::string(PyString_AsString(obj7));
2532	<	else
2533	<	SWIG_exception(SWIG_TypeError, "string expected");
2534	<	}
2535	<	}
2536	<	if (obj8) {
2537	<	{
2538	<	if (PyString_Check(obj8))
2539	<	arg9 = std::string(PyString_AsString(obj8));
2540	<	else
2541	<	SWIG_exception(SWIG_TypeError, "string expected");
2542	<	}
2543	<	}
2544	<	if (obj9) {
2545	<	arg10 = PyInt_AsLong(obj9) ? true : false;
2546	<	if (PyErr_Occurred()) SWIG_fail;
2547	<	}
2548	<	{
2549	<	try {
2550	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2551	<
2552	<	}catch (const BossSchedFailure & e) {
2553	<	SWIG_exception(SWIG_ValueError, e.what());
2554	<	}catch (const std::exception& e) {
2555	<	SWIG_exception(SWIG_RuntimeError, e.what());
2556	<	}
2557	<	}
2558	<	resultobj = result;
2559	<	return resultobj;
2560	<	fail:
2561	<	return NULL;
2562	<	}
2563	<
2564	<
2565	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2566	<	PyObject *resultobj;
2567	<	std::string arg1 = (std::string) "" ;
2568	<	std::string arg2 = (std::string) "2" ;
2569	<	std::string arg3 = (std::string) "" ;
2570	<	std::string arg4 = (std::string) "" ;
2571	<	BossSession *result;
2471	>	BossTask *arg2 = (BossTask *) 0 ;
2472		PyObject * obj0 = 0 ;
2473		PyObject * obj1 = 0 ;
2574	–	PyObject * obj2 = 0 ;
2575	–	PyObject * obj3 = 0 ;
2576	–
2577	–	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2578	–	if (obj0) {
2579	–	{
2580	–	if (PyString_Check(obj0))
2581	–	arg1 = std::string(PyString_AsString(obj0));
2582	–	else
2583	–	SWIG_exception(SWIG_TypeError, "string expected");
2584	–	}
2585	–	}
2586	–	if (obj1) {
2587	–	{
2588	–	if (PyString_Check(obj1))
2589	–	arg2 = std::string(PyString_AsString(obj1));
2590	–	else
2591	–	SWIG_exception(SWIG_TypeError, "string expected");
2592	–	}
2593	–	}
2594	–	if (obj2) {
2595	–	{
2596	–	if (PyString_Check(obj2))
2597	–	arg3 = std::string(PyString_AsString(obj2));
2598	–	else
2599	–	SWIG_exception(SWIG_TypeError, "string expected");
2600	–	}
2601	–	}
2602	–	if (obj3) {
2603	–	{
2604	–	if (PyString_Check(obj3))
2605	–	arg4 = std::string(PyString_AsString(obj3));
2606	–	else
2607	–	SWIG_exception(SWIG_TypeError, "string expected");
2608	–	}
2609	–	}
2610	–	{
2611	–	try {
2612	–	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2613	–
2614	–	}catch (const BossSchedFailure & e) {
2615	–	SWIG_exception(SWIG_ValueError, e.what());
2616	–	}catch (const std::exception& e) {
2617	–	SWIG_exception(SWIG_RuntimeError, e.what());
2618	–	}
2619	–	}
2620	–	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2621	–	return resultobj;
2622	–	fail:
2623	–	return NULL;
2624	–	}
2625	–
2626	–
2627	–	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2628	–	PyObject *resultobj;
2629	–	BossSession *arg1 = (BossSession *) 0 ;
2630	–	PyObject * obj0 = 0 ;
2474
2475	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2475	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2476		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2477	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2478		{
2479		try {
2480	<	delete arg1;
2480	>	(arg1)->destroyBossTask(arg2);
2481
2482		}catch (const BossSchedFailure & e) {
2483	<	SWIG_exception(SWIG_ValueError, e.what());
2483	>	PyErr_SetString ( SchedulerError, e.what() );
2484	>	return NULL;
2485		}catch (const std::exception& e) {
2486	<	SWIG_exception(SWIG_RuntimeError, e.what());
2486	>	PyErr_SetString ( BossError, e.what() );
2487	>	return NULL;
2488		}
2489		}
2490		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2648 | Line 2494 | static PyObject *_wrap_delete_BossSessio
2494		}
2495
2496
2497	<	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2497	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2498		PyObject *resultobj;
2499		BossSession *arg1 = (BossSession *) 0 ;
2500	+	std::vector<std::string > result;
2501		PyObject * obj0 = 0 ;
2502
2503	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2503	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2504		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2505		{
2506		try {
2507	<	(arg1)->resetDB();
2507	>	result = (arg1)->showCHTools();
2508
2509		}catch (const BossSchedFailure & e) {
2510	<	SWIG_exception(SWIG_ValueError, e.what());
2510	>	PyErr_SetString ( SchedulerError, e.what() );
2511	>	return NULL;
2512		}catch (const std::exception& e) {
2513	<	SWIG_exception(SWIG_RuntimeError, e.what());
2513	>	PyErr_SetString ( BossError, e.what() );
2514	>	return NULL;
2515		}
2516		}
2517	<	Py_INCREF(Py_None); resultobj = Py_None;
2517	>	{
2518	>	resultobj = PyTuple_New((&result)->size());
2519	>	for (unsigned int i=0; i<(&result)->size(); i++)
2520	>	PyTuple_SetItem(resultobj,i,
2521	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2522	>	}
2523		return resultobj;
2524		fail:
2525		return NULL;
2526		}
2527
2528
2529	<	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2529	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2530		PyObject *resultobj;
2531		BossSession *arg1 = (BossSession *) 0 ;
2532	+	std::vector<std::string > result;
2533		PyObject * obj0 = 0 ;
2534
2535	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2535	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2536		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2537		{
2538		try {
2539	<	(arg1)->clear();
2539	>	result = (arg1)->showProgramTypes();
2540
2541		}catch (const BossSchedFailure & e) {
2542	<	SWIG_exception(SWIG_ValueError, e.what());
2542	>	PyErr_SetString ( SchedulerError, e.what() );
2543	>	return NULL;
2544		}catch (const std::exception& e) {
2545	<	SWIG_exception(SWIG_RuntimeError, e.what());
2545	>	PyErr_SetString ( BossError, e.what() );
2546	>	return NULL;
2547		}
2548		}
2549	<	Py_INCREF(Py_None); resultobj = Py_None;
2549	>	{
2550	>	resultobj = PyTuple_New((&result)->size());
2551	>	for (unsigned int i=0; i<(&result)->size(); i++)
2552	>	PyTuple_SetItem(resultobj,i,
2553	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2554	>	}
2555		return resultobj;
2556		fail:
2557		return NULL;
2558		}
2559
2560
2561	<	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2561	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2562		PyObject *resultobj;
2563		BossSession *arg1 = (BossSession *) 0 ;
2564	<	std::string const &arg2_defvalue = "" ;
2703	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2704	<	BossTask *result;
2705	<	std::string temp2 ;
2564	>	std::vector<std::string > result;
2565		PyObject * obj0 = 0 ;
2707	–	PyObject * obj1 = 0 ;
2566
2567	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2567	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2568		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2711	–	if (obj1) {
2712	–	{
2713	–	if (PyString_Check(obj1)) {
2714	–	temp2 = std::string(PyString_AsString(obj1));
2715	–	arg2 = &temp2;
2716	–	}else {
2717	–	SWIG_exception(SWIG_TypeError, "string expected");
2718	–	}
2719	–	}
2720	–	}
2569		{
2570		try {
2571	<	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2571	>	result = (arg1)->showRTMon();
2572
2573		}catch (const BossSchedFailure & e) {
2574	<	SWIG_exception(SWIG_ValueError, e.what());
2574	>	PyErr_SetString ( SchedulerError, e.what() );
2575	>	return NULL;
2576		}catch (const std::exception& e) {
2577	<	SWIG_exception(SWIG_RuntimeError, e.what());
2577	>	PyErr_SetString ( BossError, e.what() );
2578	>	return NULL;
2579		}
2580		}
2581	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2581	>	{
2582	>	resultobj = PyTuple_New((&result)->size());
2583	>	for (unsigned int i=0; i<(&result)->size(); i++)
2584	>	PyTuple_SetItem(resultobj,i,
2585	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2586	>	}
2587		return resultobj;
2588		fail:
2589		return NULL;
2590		}
2591
2592
2593	<	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2593	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2594		PyObject *resultobj;
2595		BossSession *arg1 = (BossSession *) 0 ;
2596	<	BossTask *arg2 = (BossTask *) 0 ;
2596	>	std::vector<std::string > result;
2597		PyObject * obj0 = 0 ;
2743	–	PyObject * obj1 = 0 ;
2598
2599	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2599	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2600		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2747	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2601		{
2602		try {
2603	<	(arg1)->destroyBossTask(arg2);
2603	>	result = (arg1)->showSchedulers();
2604
2605		}catch (const BossSchedFailure & e) {
2606	<	SWIG_exception(SWIG_ValueError, e.what());
2606	>	PyErr_SetString ( SchedulerError, e.what() );
2607	>	return NULL;
2608		}catch (const std::exception& e) {
2609	<	SWIG_exception(SWIG_RuntimeError, e.what());
2609	>	PyErr_SetString ( BossError, e.what() );
2610	>	return NULL;
2611		}
2612		}
2613	<	Py_INCREF(Py_None); resultobj = Py_None;
2613	>	{
2614	>	resultobj = PyTuple_New((&result)->size());
2615	>	for (unsigned int i=0; i<(&result)->size(); i++)
2616	>	PyTuple_SetItem(resultobj,i,
2617	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2618	>	}
2619		return resultobj;
2620		fail:
2621		return NULL;
#	Line 2775 | Line 2635 | static PyObject *_wrap_BossSession_defau
2635		result = (arg1)->defaultCHTool();
2636
2637		}catch (const BossSchedFailure & e) {
2638	<	SWIG_exception(SWIG_ValueError, e.what());
2638	>	PyErr_SetString ( SchedulerError, e.what() );
2639	>	return NULL;
2640		}catch (const std::exception& e) {
2641	<	SWIG_exception(SWIG_RuntimeError, e.what());
2641	>	PyErr_SetString ( BossError, e.what() );
2642	>	return NULL;
2643		}
2644		}
2645		{
#	Line 2802 | Line 2664 | static PyObject *_wrap_BossSession_defau
2664		result = (arg1)->defaultProgramType();
2665
2666		}catch (const BossSchedFailure & e) {
2667	<	SWIG_exception(SWIG_ValueError, e.what());
2667	>	PyErr_SetString ( SchedulerError, e.what() );
2668	>	return NULL;
2669		}catch (const std::exception& e) {
2670	<	SWIG_exception(SWIG_RuntimeError, e.what());
2670	>	PyErr_SetString ( BossError, e.what() );
2671	>	return NULL;
2672		}
2673		}
2674		{
#	Line 2829 | Line 2693 | static PyObject *_wrap_BossSession_defau
2693		result = (arg1)->defaultRTMon();
2694
2695		}catch (const BossSchedFailure & e) {
2696	<	SWIG_exception(SWIG_ValueError, e.what());
2696	>	PyErr_SetString ( SchedulerError, e.what() );
2697	>	return NULL;
2698		}catch (const std::exception& e) {
2699	<	SWIG_exception(SWIG_RuntimeError, e.what());
2699	>	PyErr_SetString ( BossError, e.what() );
2700	>	return NULL;
2701		}
2702		}
2703		{
#	Line 2856 | Line 2722 | static PyObject *_wrap_BossSession_defau
2722		result = (arg1)->defaultScheduler();
2723
2724		}catch (const BossSchedFailure & e) {
2725	<	SWIG_exception(SWIG_ValueError, e.what());
2725	>	PyErr_SetString ( SchedulerError, e.what() );
2726	>	return NULL;
2727		}catch (const std::exception& e) {
2728	<	SWIG_exception(SWIG_RuntimeError, e.what());
2728	>	PyErr_SetString ( BossError, e.what() );
2729	>	return NULL;
2730		}
2731		}
2732		{
#	Line 2883 | Line 2751 | static PyObject *_wrap_BossSession_versi
2751		result = (arg1)->version();
2752
2753		}catch (const BossSchedFailure & e) {
2754	<	SWIG_exception(SWIG_ValueError, e.what());
2754	>	PyErr_SetString ( SchedulerError, e.what() );
2755	>	return NULL;
2756		}catch (const std::exception& e) {
2757	<	SWIG_exception(SWIG_RuntimeError, e.what());
2757	>	PyErr_SetString ( BossError, e.what() );
2758	>	return NULL;
2759		}
2760		}
2761		{
#	Line 2910 | Line 2780 | static PyObject *_wrap_BossSession_clien
2780		result = (arg1)->clientID();
2781
2782		}catch (const BossSchedFailure & e) {
2783	<	SWIG_exception(SWIG_ValueError, e.what());
2783	>	PyErr_SetString ( SchedulerError, e.what() );
2784	>	return NULL;
2785		}catch (const std::exception& e) {
2786	<	SWIG_exception(SWIG_RuntimeError, e.what());
2786	>	PyErr_SetString ( BossError, e.what() );
2787	>	return NULL;
2788		}
2789		}
2790		{
#	Line 2943 | Line 2815 | static PyObject *_wrap_BossSession_showC
2815		result = (int)(arg1)->showConfigs(arg2);
2816
2817		}catch (const BossSchedFailure & e) {
2818	<	SWIG_exception(SWIG_ValueError, e.what());
2818	>	PyErr_SetString ( SchedulerError, e.what() );
2819	>	return NULL;
2820		}catch (const std::exception& e) {
2821	<	SWIG_exception(SWIG_RuntimeError, e.what());
2821	>	PyErr_SetString ( BossError, e.what() );
2822	>	return NULL;
2823		}
2824		}
2825		resultobj = PyInt_FromLong((long)result);
#	Line 2998 | Line 2872 | static PyObject *_wrap_BossSession_RTupd
2872		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2873
2874		}catch (const BossSchedFailure & e) {
2875	<	SWIG_exception(SWIG_ValueError, e.what());
2875	>	PyErr_SetString ( SchedulerError, e.what() );
2876	>	return NULL;
2877		}catch (const std::exception& e) {
2878	<	SWIG_exception(SWIG_RuntimeError, e.what());
2878	>	PyErr_SetString ( BossError, e.what() );
2879	>	return NULL;
2880		}
2881		}
2882		resultobj = PyInt_FromLong((long)result);
#	Line 3020 | Line 2896 | static PyObject *_wrap_BossSession_listM
2896		std::string *arg5 = (std::string *) &arg5_defvalue ;
2897		std::string const &arg6_defvalue = "" ;
2898		std::string *arg6 = (std::string *) &arg6_defvalue ;
2899	+	unsigned int arg7 = (unsigned int) 0 ;
2900		std::vector<std::string > result;
2901		std::string temp2 ;
2902		std::string temp3 ;
#	Line 3031 | Line 2908 | static PyObject *_wrap_BossSession_listM
2908		PyObject * obj3 = 0 ;
2909		PyObject * obj4 = 0 ;
2910		PyObject * obj5 = 0 ;
2911	+	PyObject * obj6 = 0 ;
2912
2913	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2913	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2914		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2915		{
2916		if (PyString_Check(obj1)) {
#	Line 3074 | Line 2952 | static PyObject *_wrap_BossSession_listM
2952		}
2953		}
2954		}
2955	+	if (obj6) {
2956	+	arg7 = (unsigned int) PyInt_AsLong(obj6);
2957	+	if (PyErr_Occurred()) SWIG_fail;
2958	+	}
2959		{
2960		try {
2961	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2961	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
2962
2963		}catch (const BossSchedFailure & e) {
2964	<	SWIG_exception(SWIG_ValueError, e.what());
2964	>	PyErr_SetString ( SchedulerError, e.what() );
2965	>	return NULL;
2966		}catch (const std::exception& e) {
2967	<	SWIG_exception(SWIG_RuntimeError, e.what());
2967	>	PyErr_SetString ( BossError, e.what() );
2968	>	return NULL;
2969		}
2970		}
2971		{
#	Line 3110 | Line 2994 | static PyObject *_wrap_BossSession_sched
2994		std::string arg7 = (std::string) "" ;
2995		std::string arg8 = (std::string) "" ;
2996		std::string arg9 = (std::string) "" ;
2997	+	unsigned int arg10 = (unsigned int) 0 ;
2998		std::string temp3 ;
2999		std::string temp4 ;
3000		std::string temp5 ;
#	Line 3121 | Line 3006 | static PyObject *_wrap_BossSession_sched
3006		PyObject * obj6 = 0 ;
3007		PyObject * obj7 = 0 ;
3008		PyObject * obj8 = 0 ;
3009	+	PyObject * obj9 = 0 ;
3010
3011	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3011	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3012		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3013		if (obj2) {
3014		{
#	Line 3186 | Line 3072 | static PyObject *_wrap_BossSession_sched
3072		SWIG_exception(SWIG_TypeError, "string expected");
3073		}
3074		}
3075	+	if (obj9) {
3076	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3077	+	if (PyErr_Occurred()) SWIG_fail;
3078	+	}
3079		{
3080		try {
3081	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3081	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3082
3083		}catch (const BossSchedFailure & e) {
3084	<	SWIG_exception(SWIG_ValueError, e.what());
3084	>	PyErr_SetString ( SchedulerError, e.what() );
3085	>	return NULL;
3086		}catch (const std::exception& e) {
3087	<	SWIG_exception(SWIG_RuntimeError, e.what());
3087	>	PyErr_SetString ( BossError, e.what() );
3088	>	return NULL;
3089		}
3090		}
3091		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3272 | Line 3164 | static PyObject *_wrap_BossSession_selec
3164		result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3165
3166		}catch (const BossSchedFailure & e) {
3167	<	SWIG_exception(SWIG_ValueError, e.what());
3167	>	PyErr_SetString ( SchedulerError, e.what() );
3168	>	return NULL;
3169		}catch (const std::exception& e) {
3170	<	SWIG_exception(SWIG_RuntimeError, e.what());
3170	>	PyErr_SetString ( BossError, e.what() );
3171	>	return NULL;
3172		}
3173		}
3174		{
#	Line 3303 | Line 3197 | static PyObject *_wrap_BossSession_query
3197		std::string arg7 = (std::string) "" ;
3198		std::string arg8 = (std::string) "" ;
3199		std::string arg9 = (std::string) "" ;
3200	<	bool arg10 = (bool) false ;
3200	>	unsigned int arg10 = (unsigned int) 0 ;
3201	>	bool arg11 = (bool) false ;
3202		SwigValueWrapper< std::vector<BossTask * > > result;
3203		std::string temp3 ;
3204		std::string temp4 ;
#	Line 3317 | Line 3212 | static PyObject *_wrap_BossSession_query
3212		PyObject * obj7 = 0 ;
3213		PyObject * obj8 = 0 ;
3214		PyObject * obj9 = 0 ;
3215	+	PyObject * obj10 = 0 ;
3216
3217	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3217	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3218		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3219		if (obj2) {
3220		{
#	Line 3383 | Line 3279 | static PyObject *_wrap_BossSession_query
3279		}
3280		}
3281		if (obj9) {
3282	<	arg10 = PyInt_AsLong(obj9) ? true : false;
3282	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3283	>	if (PyErr_Occurred()) SWIG_fail;
3284	>	}
3285	>	if (obj10) {
3286	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3287		if (PyErr_Occurred()) SWIG_fail;
3288		}
3289		{
3290		try {
3291	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3291	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3292
3293		}catch (const BossSchedFailure & e) {
3294	<	SWIG_exception(SWIG_ValueError, e.what());
3294	>	PyErr_SetString ( SchedulerError, e.what() );
3295	>	return NULL;
3296		}catch (const std::exception& e) {
3297	<	SWIG_exception(SWIG_RuntimeError, e.what());
3297	>	PyErr_SetString ( BossError, e.what() );
3298	>	return NULL;
3299		}
3300		}
3301		{
#	Line 3407 | Line 3309 | static PyObject *_wrap_BossSession_query
3309		}
3310
3311
3312	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3411	<	PyObject *obj;
3412	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3413	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3414	<	Py_INCREF(obj);
3415	<	return Py_BuildValue((char *)"");
3416	<	}
3417	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3312	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3313		PyObject *resultobj;
3314	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3315	<	char *arg2 ;
3314	>	BossSession *arg1 = (BossSession *) 0 ;
3315	>	std::vector<std::string > *arg2 = 0 ;
3316	>	PyObject *result;
3317		PyObject * obj0 = 0 ;
3318	+	PyObject * obj1 = 0 ;
3319
3320	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3321	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3320	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3321	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3322	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3323	>	if (arg2 == NULL) {
3324	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3325	>	}
3326		{
3327	<	if (arg2) {
3328	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3329	<	strcpy((char *) arg1->key,arg2);
3330	<	}else {
3331	<	arg1->key = 0;
3327	>	try {
3328	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3329	>
3330	>	}catch (const BossSchedFailure & e) {
3331	>	PyErr_SetString ( SchedulerError, e.what() );
3332	>	return NULL;
3333	>	}catch (const std::exception& e) {
3334	>	PyErr_SetString ( BossError, e.what() );
3335	>	return NULL;
3336		}
3337		}
3338	<	Py_INCREF(Py_None); resultobj = Py_None;
3338	>	resultobj = result;
3339		return resultobj;
3340		fail:
3341		return NULL;
3342		}
3343
3344
3345	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3345	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3346		PyObject *resultobj;
3347	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3348	<	char *result;
3347	>	BossSession *arg1 = (BossSession *) 0 ;
3348	>	PyObject *result;
3349		PyObject * obj0 = 0 ;
3350
3351	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3352	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3353	<	result = (char *) ((arg1)->key);
3354	<
3355	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3351	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3352	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3353	>	{
3354	>	try {
3355	>	result = (PyObject *)BossSession_CHTools(arg1);
3356	>
3357	>	}catch (const BossSchedFailure & e) {
3358	>	PyErr_SetString ( SchedulerError, e.what() );
3359	>	return NULL;
3360	>	}catch (const std::exception& e) {
3361	>	PyErr_SetString ( BossError, e.what() );
3362	>	return NULL;
3363	>	}
3364	>	}
3365	>	resultobj = result;
3366		return resultobj;
3367		fail:
3368		return NULL;
3369		}
3370
3371
3372	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3372	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3373		PyObject *resultobj;
3374	<	char *arg1 ;
3375	<	BossTaskException *result;
3374	>	BossSession *arg1 = (BossSession *) 0 ;
3375	>	PyObject *result;
3376	>	PyObject * obj0 = 0 ;
3377
3378	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3378	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3379	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3380		{
3381		try {
3382	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3382	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3383
3384		}catch (const BossSchedFailure & e) {
3385	<	SWIG_exception(SWIG_ValueError, e.what());
3385	>	PyErr_SetString ( SchedulerError, e.what() );
3386	>	return NULL;
3387		}catch (const std::exception& e) {
3388	<	SWIG_exception(SWIG_RuntimeError, e.what());
3388	>	PyErr_SetString ( BossError, e.what() );
3389	>	return NULL;
3390		}
3391		}
3392	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3392	>	resultobj = result;
3393		return resultobj;
3394		fail:
3395		return NULL;
3396		}
3397
3398
3399	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3399	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3400		PyObject *resultobj;
3401	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3402	<	char *result;
3401	>	BossSession *arg1 = (BossSession *) 0 ;
3402	>	PyObject *result;
3403		PyObject * obj0 = 0 ;
3404
3405	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3406	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3405	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3406	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3407		{
3408		try {
3409	<	result = (char *)((BossTaskException const *)arg1)->what();
3409	>	result = (PyObject *)BossSession_RTMons(arg1);
3410
3411		}catch (const BossSchedFailure & e) {
3412	<	SWIG_exception(SWIG_ValueError, e.what());
3412	>	PyErr_SetString ( SchedulerError, e.what() );
3413	>	return NULL;
3414		}catch (const std::exception& e) {
3415	<	SWIG_exception(SWIG_RuntimeError, e.what());
3415	>	PyErr_SetString ( BossError, e.what() );
3416	>	return NULL;
3417		}
3418		}
3419	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3419	>	resultobj = result;
3420		return resultobj;
3421		fail:
3422		return NULL;
3423		}
3424
3425
3426	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3426	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3427		PyObject *resultobj;
3428	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3428	>	BossSession *arg1 = (BossSession *) 0 ;
3429	>	PyObject *result;
3430		PyObject * obj0 = 0 ;
3431
3432	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3433	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3432	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3433	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3434		{
3435		try {
3436	<	delete arg1;
3436	>	result = (PyObject *)BossSession_schedulers(arg1);
3437
3438		}catch (const BossSchedFailure & e) {
3439	<	SWIG_exception(SWIG_ValueError, e.what());
3439	>	PyErr_SetString ( SchedulerError, e.what() );
3440	>	return NULL;
3441		}catch (const std::exception& e) {
3442	<	SWIG_exception(SWIG_RuntimeError, e.what());
3442	>	PyErr_SetString ( BossError, e.what() );
3443	>	return NULL;
3444		}
3445		}
3446	<	Py_INCREF(Py_None); resultobj = Py_None;
3446	>	resultobj = result;
3447		return resultobj;
3448		fail:
3449		return NULL;
3450		}
3451
3452
3453	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3530	<	PyObject *obj;
3531	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3532	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3533	<	Py_INCREF(obj);
3534	<	return Py_BuildValue((char *)"");
3535	<	}
3536	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3453	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3454		PyObject *resultobj;
3455	<	BossTask *arg1 = (BossTask *) 0 ;
3456	<	PyObject *arg2 = (PyObject *) 0 ;
3457	<	BossAttributeContainer *arg3 = 0 ;
3455	>	BossSession *arg1 = (BossSession *) 0 ;
3456	>	std::string *arg2 = 0 ;
3457	>	std::string *arg3 = 0 ;
3458	>	std::string const &arg4_defvalue = "" ;
3459	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3460	>	std::string const &arg5_defvalue = "" ;
3461	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3462	>	unsigned int arg6 = (unsigned int) 0 ;
3463	>	bool arg7 = (bool) false ;
3464		PyObject *result;
3465	+	std::string temp2 ;
3466	+	std::string temp3 ;
3467	+	std::string temp4 ;
3468	+	std::string temp5 ;
3469		PyObject * obj0 = 0 ;
3470		PyObject * obj1 = 0 ;
3471		PyObject * obj2 = 0 ;
3472	+	PyObject * obj3 = 0 ;
3473	+	PyObject * obj4 = 0 ;
3474	+	PyObject * obj5 = 0 ;
3475	+	PyObject * obj6 = 0 ;
3476
3477	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3478	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3479	<	arg2 = obj1;
3480	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3481	<	if (arg3 == NULL) {
3482	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3477	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3478	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3479	>	{
3480	>	if (PyString_Check(obj1)) {
3481	>	temp2 = std::string(PyString_AsString(obj1));
3482	>	arg2 = &temp2;
3483	>	}else {
3484	>	SWIG_exception(SWIG_TypeError, "string expected");
3485	>	}
3486	>	}
3487	>	{
3488	>	if (PyString_Check(obj2)) {
3489	>	temp3 = std::string(PyString_AsString(obj2));
3490	>	arg3 = &temp3;
3491	>	}else {
3492	>	SWIG_exception(SWIG_TypeError, "string expected");
3493	>	}
3494	>	}
3495	>	if (obj3) {
3496	>	{
3497	>	if (PyString_Check(obj3)) {
3498	>	temp4 = std::string(PyString_AsString(obj3));
3499	>	arg4 = &temp4;
3500	>	}else {
3501	>	SWIG_exception(SWIG_TypeError, "string expected");
3502	>	}
3503	>	}
3504	>	}
3505	>	if (obj4) {
3506	>	{
3507	>	if (PyString_Check(obj4)) {
3508	>	temp5 = std::string(PyString_AsString(obj4));
3509	>	arg5 = &temp5;
3510	>	}else {
3511	>	SWIG_exception(SWIG_TypeError, "string expected");
3512	>	}
3513	>	}
3514	>	}
3515	>	if (obj5) {
3516	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3517	>	if (PyErr_Occurred()) SWIG_fail;
3518	>	}
3519	>	if (obj6) {
3520	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3521	>	if (PyErr_Occurred()) SWIG_fail;
3522		}
3523		{
3524		try {
3525	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3525	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3526
3527		}catch (const BossSchedFailure & e) {
3528	<	SWIG_exception(SWIG_ValueError, e.what());
3528	>	PyErr_SetString ( SchedulerError, e.what() );
3529	>	return NULL;
3530		}catch (const std::exception& e) {
3531	<	SWIG_exception(SWIG_RuntimeError, e.what());
3531	>	PyErr_SetString ( BossError, e.what() );
3532	>	return NULL;
3533		}
3534		}
3535		resultobj = result;
#	Line 3567 | Line 3539 | static PyObject *_wrap_BossTask_appendTo
3539		}
3540
3541
3542	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3542	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3543		PyObject *resultobj;
3544	<	BossTask *arg1 = (BossTask *) 0 ;
3545	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3544	>	BossSession *arg1 = (BossSession *) 0 ;
3545	>	int arg2 = (int) SCHEDULED ;
3546	>	std::string const &arg3_defvalue = "all" ;
3547	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3548	>	std::string const &arg4_defvalue = "all" ;
3549	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3550	>	std::string const &arg5_defvalue = "" ;
3551	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3552	>	std::string arg6 = (std::string) "" ;
3553	>	std::string arg7 = (std::string) "" ;
3554	>	std::string arg8 = (std::string) "" ;
3555	>	std::string arg9 = (std::string) "" ;
3556	>	unsigned int arg10 = (unsigned int) 0 ;
3557	>	bool arg11 = (bool) false ;
3558		PyObject *result;
3559	+	std::string temp3 ;
3560	+	std::string temp4 ;
3561	+	std::string temp5 ;
3562		PyObject * obj0 = 0 ;
3563	<	PyObject * obj1 = 0 ;
3563	>	PyObject * obj2 = 0 ;
3564	>	PyObject * obj3 = 0 ;
3565	>	PyObject * obj4 = 0 ;
3566	>	PyObject * obj5 = 0 ;
3567	>	PyObject * obj6 = 0 ;
3568	>	PyObject * obj7 = 0 ;
3569	>	PyObject * obj8 = 0 ;
3570	>	PyObject * obj9 = 0 ;
3571	>	PyObject * obj10 = 0 ;
3572
3573	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3574	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3575	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3576	<	if (arg2 == NULL) {
3577	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3573	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3574	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3575	>	if (obj2) {
3576	>	{
3577	>	if (PyString_Check(obj2)) {
3578	>	temp3 = std::string(PyString_AsString(obj2));
3579	>	arg3 = &temp3;
3580	>	}else {
3581	>	SWIG_exception(SWIG_TypeError, "string expected");
3582	>	}
3583	>	}
3584	>	}
3585	>	if (obj3) {
3586	>	{
3587	>	if (PyString_Check(obj3)) {
3588	>	temp4 = std::string(PyString_AsString(obj3));
3589	>	arg4 = &temp4;
3590	>	}else {
3591	>	SWIG_exception(SWIG_TypeError, "string expected");
3592	>	}
3593	>	}
3594	>	}
3595	>	if (obj4) {
3596	>	{
3597	>	if (PyString_Check(obj4)) {
3598	>	temp5 = std::string(PyString_AsString(obj4));
3599	>	arg5 = &temp5;
3600	>	}else {
3601	>	SWIG_exception(SWIG_TypeError, "string expected");
3602	>	}
3603	>	}
3604	>	}
3605	>	if (obj5) {
3606	>	{
3607	>	if (PyString_Check(obj5))
3608	>	arg6 = std::string(PyString_AsString(obj5));
3609	>	else
3610	>	SWIG_exception(SWIG_TypeError, "string expected");
3611	>	}
3612	>	}
3613	>	if (obj6) {
3614	>	{
3615	>	if (PyString_Check(obj6))
3616	>	arg7 = std::string(PyString_AsString(obj6));
3617	>	else
3618	>	SWIG_exception(SWIG_TypeError, "string expected");
3619	>	}
3620	>	}
3621	>	if (obj7) {
3622	>	{
3623	>	if (PyString_Check(obj7))
3624	>	arg8 = std::string(PyString_AsString(obj7));
3625	>	else
3626	>	SWIG_exception(SWIG_TypeError, "string expected");
3627	>	}
3628	>	}
3629	>	if (obj8) {
3630	>	{
3631	>	if (PyString_Check(obj8))
3632	>	arg9 = std::string(PyString_AsString(obj8));
3633	>	else
3634	>	SWIG_exception(SWIG_TypeError, "string expected");
3635	>	}
3636	>	}
3637	>	if (obj9) {
3638	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3639	>	if (PyErr_Occurred()) SWIG_fail;
3640	>	}
3641	>	if (obj10) {
3642	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3643	>	if (PyErr_Occurred()) SWIG_fail;
3644		}
3645		{
3646		try {
3647	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3647	>	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3648
3649		}catch (const BossSchedFailure & e) {
3650	<	SWIG_exception(SWIG_ValueError, e.what());
3650	>	PyErr_SetString ( SchedulerError, e.what() );
3651	>	return NULL;
3652		}catch (const std::exception& e) {
3653	<	SWIG_exception(SWIG_RuntimeError, e.what());
3653	>	PyErr_SetString ( BossError, e.what() );
3654	>	return NULL;
3655		}
3656		}
3657		resultobj = result;
#	Line 3598 | Line 3661 | static PyObject *_wrap_BossTask_jobDict(
3661		}
3662
3663
3664	<	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
3664	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3665	>	PyObject *obj;
3666	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3667	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3668	>	Py_INCREF(obj);
3669	>	return Py_BuildValue((char *)"");
3670	>	}
3671	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3672		PyObject *resultobj;
3673	<	BossTask *arg1 = (BossTask *) 0 ;
3674	<	PyObject *result;
3673	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3674	>	char *arg2 ;
3675		PyObject * obj0 = 0 ;
3676
3677	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3678	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3677	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3678	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3679	>	{
3680	>	if (arg2) {
3681	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3682	>	strcpy((char *) arg1->key,arg2);
3683	>	}else {
3684	>	arg1->key = 0;
3685	>	}
3686	>	}
3687	>	Py_INCREF(Py_None); resultobj = Py_None;
3688	>	return resultobj;
3689	>	fail:
3690	>	return NULL;
3691	>	}
3692	>
3693	>
3694	>	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3695	>	PyObject *resultobj;
3696	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3697	>	char *result;
3698	>	PyObject * obj0 = 0 ;
3699	>
3700	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3701	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3702	>	result = (char *) ((arg1)->key);
3703	>
3704	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3705	>	return resultobj;
3706	>	fail:
3707	>	return NULL;
3708	>	}
3709	>
3710	>
3711	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3712	>	PyObject *resultobj;
3713	>	char *arg1 ;
3714	>	BossTaskException *result;
3715	>
3716	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3717		{
3718		try {
3719	<	result = (PyObject *)BossTask_jobsDict(arg1);
3719	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3720
3721		}catch (const BossSchedFailure & e) {
3722	<	SWIG_exception(SWIG_ValueError, e.what());
3722	>	PyErr_SetString ( SchedulerError, e.what() );
3723	>	return NULL;
3724		}catch (const std::exception& e) {
3725	<	SWIG_exception(SWIG_RuntimeError, e.what());
3725	>	PyErr_SetString ( BossError, e.what() );
3726	>	return NULL;
3727		}
3728		}
3729	<	resultobj = result;
3729	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3730		return resultobj;
3731		fail:
3732		return NULL;
3733		}
3734
3735
3736	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3736	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3737		PyObject *resultobj;
3738	<	BossTask *arg1 = (BossTask *) 0 ;
3739	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3630	<	PyObject *result;
3738	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3739	>	char *result;
3740		PyObject * obj0 = 0 ;
3632	–	PyObject * obj1 = 0 ;
3741
3742	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3743	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3636	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3637	<	if (arg2 == NULL) {
3638	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3639	<	}
3742	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3743	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3744		{
3745		try {
3746	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3746	>	result = (char *)((BossTaskException const *)arg1)->what();
3747
3748		}catch (const BossSchedFailure & e) {
3749	<	SWIG_exception(SWIG_ValueError, e.what());
3749	>	PyErr_SetString ( SchedulerError, e.what() );
3750	>	return NULL;
3751		}catch (const std::exception& e) {
3752	<	SWIG_exception(SWIG_RuntimeError, e.what());
3752	>	PyErr_SetString ( BossError, e.what() );
3753	>	return NULL;
3754		}
3755		}
3756	<	resultobj = result;
3756	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3757		return resultobj;
3758		fail:
3759		return NULL;
3760		}
3761
3762
3763	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
3763	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3764		PyObject *resultobj;
3765	<	BossTask *arg1 = (BossTask *) 0 ;
3660	<	std::string *arg2 = 0 ;
3661	<	PyObject *result;
3662	<	std::string temp2 ;
3765	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3766		PyObject * obj0 = 0 ;
3664	–	PyObject * obj1 = 0 ;
3767
3768	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3769	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3668	<	{
3669	<	if (PyString_Check(obj1)) {
3670	<	temp2 = std::string(PyString_AsString(obj1));
3671	<	arg2 = &temp2;
3672	<	}else {
3673	<	SWIG_exception(SWIG_TypeError, "string expected");
3674	<	}
3675	<	}
3768	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3769	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3770		{
3771		try {
3772	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3772	>	delete arg1;
3773
3774		}catch (const BossSchedFailure & e) {
3775	<	SWIG_exception(SWIG_ValueError, e.what());
3775	>	PyErr_SetString ( SchedulerError, e.what() );
3776	>	return NULL;
3777		}catch (const std::exception& e) {
3778	<	SWIG_exception(SWIG_RuntimeError, e.what());
3778	>	PyErr_SetString ( BossError, e.what() );
3779	>	return NULL;
3780		}
3781		}
3782	<	resultobj = result;
3782	>	Py_INCREF(Py_None); resultobj = Py_None;
3783		return resultobj;
3784		fail:
3785		return NULL;
3786		}
3787
3788
3789	+	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3790	+	PyObject *obj;
3791	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3792	+	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3793	+	Py_INCREF(obj);
3794	+	return Py_BuildValue((char *)"");
3795	+	}
3796		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3797		PyObject *resultobj;
3798		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 3703 | Line 3806 | static PyObject *_wrap_new_BossTask__SWI
3806		result = (BossTask *)new BossTask(arg1);
3807
3808		}catch (const BossSchedFailure & e) {
3809	<	SWIG_exception(SWIG_ValueError, e.what());
3809	>	PyErr_SetString ( SchedulerError, e.what() );
3810	>	return NULL;
3811		}catch (const std::exception& e) {
3812	<	SWIG_exception(SWIG_RuntimeError, e.what());
3812	>	PyErr_SetString ( BossError, e.what() );
3813	>	return NULL;
3814		}
3815		}
3816		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3739 | Line 3844 | static PyObject *_wrap_new_BossTask__SWI
3844		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3845
3846		}catch (const BossSchedFailure & e) {
3847	<	SWIG_exception(SWIG_ValueError, e.what());
3847	>	PyErr_SetString ( SchedulerError, e.what() );
3848	>	return NULL;
3849		}catch (const std::exception& e) {
3850	<	SWIG_exception(SWIG_RuntimeError, e.what());
3850	>	PyErr_SetString ( BossError, e.what() );
3851	>	return NULL;
3852		}
3853		}
3854		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3763 | Line 3870 | static PyObject *_wrap_delete_BossTask(P
3870		delete arg1;
3871
3872		}catch (const BossSchedFailure & e) {
3873	<	SWIG_exception(SWIG_ValueError, e.what());
3873	>	PyErr_SetString ( SchedulerError, e.what() );
3874	>	return NULL;
3875		}catch (const std::exception& e) {
3876	<	SWIG_exception(SWIG_RuntimeError, e.what());
3876	>	PyErr_SetString ( BossError, e.what() );
3877	>	return NULL;
3878		}
3879		}
3880		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3791 | Line 3900 | static PyObject *_wrap_new_BossTask__SWI
3900		result = (BossTask *)new BossTask((BossTask const &)*arg1);
3901
3902		}catch (const BossSchedFailure & e) {
3903	<	SWIG_exception(SWIG_ValueError, e.what());
3903	>	PyErr_SetString ( SchedulerError, e.what() );
3904	>	return NULL;
3905		}catch (const std::exception& e) {
3906	<	SWIG_exception(SWIG_RuntimeError, e.what());
3906	>	PyErr_SetString ( BossError, e.what() );
3907	>	return NULL;
3908		}
3909		}
3910		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3884 | Line 3995 | static PyObject *_wrap_BossTask_id(PyObj
3995		}
3996
3997		}catch (const BossSchedFailure & e) {
3998	<	SWIG_exception(SWIG_ValueError, e.what());
3998	>	PyErr_SetString ( SchedulerError, e.what() );
3999	>	return NULL;
4000		}catch (const std::exception& e) {
4001	<	SWIG_exception(SWIG_RuntimeError, e.what());
4001	>	PyErr_SetString ( BossError, e.what() );
4002	>	return NULL;
4003		}
4004		}
4005		{
#	Line 3914 | Line 4027 | static PyObject *_wrap_BossTask_name(PyO
4027		}
4028
4029		}catch (const BossSchedFailure & e) {
4030	<	SWIG_exception(SWIG_ValueError, e.what());
4030	>	PyErr_SetString ( SchedulerError, e.what() );
4031	>	return NULL;
4032		}catch (const std::exception& e) {
4033	<	SWIG_exception(SWIG_RuntimeError, e.what());
4033	>	PyErr_SetString ( BossError, e.what() );
4034	>	return NULL;
4035		}
4036		}
4037		{
#	Line 3941 | Line 4056 | static PyObject *_wrap_BossTask_taskMap(
4056		result = ((BossTask const *)arg1)->taskMap();
4057
4058		}catch (const BossSchedFailure & e) {
4059	<	SWIG_exception(SWIG_ValueError, e.what());
4059	>	PyErr_SetString ( SchedulerError, e.what() );
4060	>	return NULL;
4061		}catch (const std::exception& e) {
4062	<	SWIG_exception(SWIG_RuntimeError, e.what());
4062	>	PyErr_SetString ( BossError, e.what() );
4063	>	return NULL;
4064		}
4065		}
4066		{
#	Line 3973 | Line 4090 | static PyObject *_wrap_BossTask_job_begi
4090		result = ((BossTask const *)arg1)->job_begin();
4091
4092		}catch (const BossSchedFailure & e) {
4093	<	SWIG_exception(SWIG_ValueError, e.what());
4093	>	PyErr_SetString ( SchedulerError, e.what() );
4094	>	return NULL;
4095		}catch (const std::exception& e) {
4096	<	SWIG_exception(SWIG_RuntimeError, e.what());
4096	>	PyErr_SetString ( BossError, e.what() );
4097	>	return NULL;
4098		}
4099		}
4100		{
#	Line 4002 | Line 4121 | static PyObject *_wrap_BossTask_job_end(
4121		result = ((BossTask const *)arg1)->job_end();
4122
4123		}catch (const BossSchedFailure & e) {
4124	<	SWIG_exception(SWIG_ValueError, e.what());
4124	>	PyErr_SetString ( SchedulerError, e.what() );
4125	>	return NULL;
4126		}catch (const std::exception& e) {
4127	<	SWIG_exception(SWIG_RuntimeError, e.what());
4127	>	PyErr_SetString ( BossError, e.what() );
4128	>	return NULL;
4129		}
4130		}
4131		{
#	Line 4031 | Line 4152 | static PyObject *_wrap_BossTask_jobsMap(
4152		result = ((BossTask const *)arg1)->jobsMap();
4153
4154		}catch (const BossSchedFailure & e) {
4155	<	SWIG_exception(SWIG_ValueError, e.what());
4155	>	PyErr_SetString ( SchedulerError, e.what() );
4156	>	return NULL;
4157		}catch (const std::exception& e) {
4158	<	SWIG_exception(SWIG_RuntimeError, e.what());
4158	>	PyErr_SetString ( BossError, e.what() );
4159	>	return NULL;
4160		}
4161		}
4162		{
#	Line 4071 | Line 4194 | static PyObject *_wrap_BossTask_jobMap__
4194		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4195
4196		}catch (const BossSchedFailure & e) {
4197	<	SWIG_exception(SWIG_ValueError, e.what());
4197	>	PyErr_SetString ( SchedulerError, e.what() );
4198	>	return NULL;
4199		}catch (const std::exception& e) {
4200	<	SWIG_exception(SWIG_RuntimeError, e.what());
4200	>	PyErr_SetString ( BossError, e.what() );
4201	>	return NULL;
4202		}
4203		}
4204		{
#	Line 4102 | Line 4227 | static PyObject *_wrap_BossTask_jobMap__
4227		result = ((BossTask const *)arg1)->jobMap(arg2);
4228
4229		}catch (const BossSchedFailure & e) {
4230	<	SWIG_exception(SWIG_ValueError, e.what());
4230	>	PyErr_SetString ( SchedulerError, e.what() );
4231	>	return NULL;
4232		}catch (const std::exception& e) {
4233	<	SWIG_exception(SWIG_RuntimeError, e.what());
4233	>	PyErr_SetString ( BossError, e.what() );
4234	>	return NULL;
4235		}
4236		}
4237		{
#	Line 4209 | Line 4336 | static PyObject *_wrap_BossTask_programs
4336		result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4337
4338		}catch (const BossSchedFailure & e) {
4339	<	SWIG_exception(SWIG_ValueError, e.what());
4339	>	PyErr_SetString ( SchedulerError, e.what() );
4340	>	return NULL;
4341		}catch (const std::exception& e) {
4342	<	SWIG_exception(SWIG_RuntimeError, e.what());
4342	>	PyErr_SetString ( BossError, e.what() );
4343	>	return NULL;
4344		}
4345		}
4346		{
#	Line 4241 | Line 4370 | static PyObject *_wrap_BossTask_queryJob
4370		result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4371
4372		}catch (const BossSchedFailure & e) {
4373	<	SWIG_exception(SWIG_ValueError, e.what());
4373	>	PyErr_SetString ( SchedulerError, e.what() );
4374	>	return NULL;
4375		}catch (const std::exception& e) {
4376	<	SWIG_exception(SWIG_RuntimeError, e.what());
4376	>	PyErr_SetString ( BossError, e.what() );
4377	>	return NULL;
4378		}
4379		}
4380		{
#	Line 4294 | Line 4425 | static PyObject *_wrap_BossTask_declare_
4425		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4426
4427		}catch (const BossSchedFailure & e) {
4428	<	SWIG_exception(SWIG_ValueError, e.what());
4428	>	PyErr_SetString ( SchedulerError, e.what() );
4429	>	return NULL;
4430		}catch (const std::exception& e) {
4431	<	SWIG_exception(SWIG_RuntimeError, e.what());
4431	>	PyErr_SetString ( BossError, e.what() );
4432	>	return NULL;
4433		}
4434		}
4435		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4335 | Line 4468 | static PyObject *_wrap_BossTask_declare_
4468		(arg1)->declare(arg2,(std::string const &)*arg3);
4469
4470		}catch (const BossSchedFailure & e) {
4471	<	SWIG_exception(SWIG_ValueError, e.what());
4471	>	PyErr_SetString ( SchedulerError, e.what() );
4472	>	return NULL;
4473		}catch (const std::exception& e) {
4474	<	SWIG_exception(SWIG_RuntimeError, e.what());
4474	>	PyErr_SetString ( BossError, e.what() );
4475	>	return NULL;
4476		}
4477		}
4478		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4436 | Line 4571 | static PyObject *_wrap_BossTask_remove(P
4571		(arg1)->remove();
4572
4573		}catch (const BossSchedFailure & e) {
4574	<	SWIG_exception(SWIG_ValueError, e.what());
4574	>	PyErr_SetString ( SchedulerError, e.what() );
4575	>	return NULL;
4576		}catch (const std::exception& e) {
4577	<	SWIG_exception(SWIG_RuntimeError, e.what());
4577	>	PyErr_SetString ( BossError, e.what() );
4578	>	return NULL;
4579		}
4580		}
4581		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4474 | Line 4611 | static PyObject *_wrap_BossTask_archive(
4611		(arg1)->archive((std::string const &)*arg2);
4612
4613		}catch (const BossSchedFailure & e) {
4614	<	SWIG_exception(SWIG_ValueError, e.what());
4614	>	PyErr_SetString ( SchedulerError, e.what() );
4615	>	return NULL;
4616		}catch (const std::exception& e) {
4617	<	SWIG_exception(SWIG_RuntimeError, e.what());
4617	>	PyErr_SetString ( BossError, e.what() );
4618	>	return NULL;
4619		}
4620		}
4621		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4499 | Line 4638 | static PyObject *_wrap_BossTask_submit(P
4638		std::string *arg5 = (std::string *) &arg5_defvalue ;
4639		std::string const &arg6_defvalue = "" ;
4640		std::string *arg6 = (std::string *) &arg6_defvalue ;
4641	<	bool arg7 = (bool) false ;
4641	>	unsigned int arg7 = (unsigned int) 0 ;
4642	>	bool arg8 = (bool) false ;
4643		int result;
4644		std::string temp2 ;
4645		std::string temp3 ;
#	Line 4513 | Line 4653 | static PyObject *_wrap_BossTask_submit(P
4653		PyObject * obj4 = 0 ;
4654		PyObject * obj5 = 0 ;
4655		PyObject * obj6 = 0 ;
4656	+	PyObject * obj7 = 0 ;
4657
4658	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4658	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4659		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4660		if (obj1) {
4661		{
#	Line 4567 | Line 4708 | static PyObject *_wrap_BossTask_submit(P
4708		}
4709		}
4710		if (obj6) {
4711	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4711	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4712	>	if (PyErr_Occurred()) SWIG_fail;
4713	>	}
4714	>	if (obj7) {
4715	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4716		if (PyErr_Occurred()) SWIG_fail;
4717		}
4718		{
4719		try {
4720	<	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
4720	>	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7,arg8);
4721
4722		}catch (const BossSchedFailure & e) {
4723	<	SWIG_exception(SWIG_ValueError, e.what());
4723	>	PyErr_SetString ( SchedulerError, e.what() );
4724	>	return NULL;
4725		}catch (const std::exception& e) {
4726	<	SWIG_exception(SWIG_RuntimeError, e.what());
4726	>	PyErr_SetString ( BossError, e.what() );
4727	>	return NULL;
4728		}
4729		}
4730		resultobj = PyInt_FromLong((long)result);
#	Line 4617 | Line 4764 | static PyObject *_wrap_BossTask_reSubmit
4764		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4765
4766		}catch (const BossSchedFailure & e) {
4767	<	SWIG_exception(SWIG_ValueError, e.what());
4767	>	PyErr_SetString ( SchedulerError, e.what() );
4768	>	return NULL;
4769		}catch (const std::exception& e) {
4770	<	SWIG_exception(SWIG_RuntimeError, e.what());
4770	>	PyErr_SetString ( BossError, e.what() );
4771	>	return NULL;
4772		}
4773		}
4774		resultobj = PyInt_FromLong((long)result);
#	Line 4633 | Line 4782 | static PyObject *_wrap_BossTask_kill(PyO
4782		PyObject *resultobj;
4783		BossTask *arg1 = (BossTask *) 0 ;
4784		std::string *arg2 = 0 ;
4785	<	bool arg3 = (bool) false ;
4785	>	unsigned int arg3 = (unsigned int) 0 ;
4786	>	bool arg4 = (bool) false ;
4787		int result;
4788		std::string temp2 ;
4789		PyObject * obj0 = 0 ;
4790		PyObject * obj1 = 0 ;
4791		PyObject * obj2 = 0 ;
4792	+	PyObject * obj3 = 0 ;
4793
4794	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4794	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
4795		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4796		{
4797		if (PyString_Check(obj1)) {
#	Line 4651 | Line 4802 | static PyObject *_wrap_BossTask_kill(PyO
4802		}
4803		}
4804		if (obj2) {
4805	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4805	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
4806	>	if (PyErr_Occurred()) SWIG_fail;
4807	>	}
4808	>	if (obj3) {
4809	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4810		if (PyErr_Occurred()) SWIG_fail;
4811		}
4812		{
4813		try {
4814	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4814	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
4815
4816		}catch (const BossSchedFailure & e) {
4817	<	SWIG_exception(SWIG_ValueError, e.what());
4817	>	PyErr_SetString ( SchedulerError, e.what() );
4818	>	return NULL;
4819		}catch (const std::exception& e) {
4820	<	SWIG_exception(SWIG_RuntimeError, e.what());
4820	>	PyErr_SetString ( BossError, e.what() );
4821	>	return NULL;
4822		}
4823		}
4824		resultobj = PyInt_FromLong((long)result);
#	Line 4678 | Line 4835 | static PyObject *_wrap_BossTask_getOutpu
4835		std::string *arg2 = (std::string *) &arg2_defvalue ;
4836		std::string const &arg3_defvalue = "" ;
4837		std::string *arg3 = (std::string *) &arg3_defvalue ;
4838	<	bool arg4 = (bool) false ;
4838	>	unsigned int arg4 = (unsigned int) 0 ;
4839		bool arg5 = (bool) false ;
4840	+	bool arg6 = (bool) false ;
4841		int result;
4842		std::string temp2 ;
4843		std::string temp3 ;
#	Line 4688 | Line 4846 | static PyObject *_wrap_BossTask_getOutpu
4846		PyObject * obj2 = 0 ;
4847		PyObject * obj3 = 0 ;
4848		PyObject * obj4 = 0 ;
4849	+	PyObject * obj5 = 0 ;
4850
4851	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4851	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
4852		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4853		if (obj1) {
4854		{
#	Line 4712 | Line 4871 | static PyObject *_wrap_BossTask_getOutpu
4871		}
4872		}
4873		if (obj3) {
4874	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4874	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
4875		if (PyErr_Occurred()) SWIG_fail;
4876		}
4877		if (obj4) {
4878		arg5 = PyInt_AsLong(obj4) ? true : false;
4879		if (PyErr_Occurred()) SWIG_fail;
4880		}
4881	+	if (obj5) {
4882	+	arg6 = PyInt_AsLong(obj5) ? true : false;
4883	+	if (PyErr_Occurred()) SWIG_fail;
4884	+	}
4885		{
4886		try {
4887	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4887	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
4888
4889		}catch (const BossSchedFailure & e) {
4890	<	SWIG_exception(SWIG_ValueError, e.what());
4890	>	PyErr_SetString ( SchedulerError, e.what() );
4891	>	return NULL;
4892		}catch (const std::exception& e) {
4893	<	SWIG_exception(SWIG_RuntimeError, e.what());
4893	>	PyErr_SetString ( BossError, e.what() );
4894	>	return NULL;
4895		}
4896		}
4897		resultobj = PyInt_FromLong((long)result);
#	Line 4818 | Line 4983 | static PyObject *_wrap_BossTask_load(PyO
4983		result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4984
4985		}catch (const BossSchedFailure & e) {
4986	<	SWIG_exception(SWIG_ValueError, e.what());
4986	>	PyErr_SetString ( SchedulerError, e.what() );
4987	>	return NULL;
4988		}catch (const std::exception& e) {
4989	<	SWIG_exception(SWIG_RuntimeError, e.what());
4989	>	PyErr_SetString ( BossError, e.what() );
4990	>	return NULL;
4991		}
4992		}
4993		resultobj = PyInt_FromLong((long)result);
#	Line 4842 | Line 5009 | static PyObject *_wrap_BossTask_query(Py
5009		std::string arg6 = (std::string) "" ;
5010		std::string arg7 = (std::string) "" ;
5011		std::string arg8 = (std::string) "" ;
5012	<	bool arg9 = (bool) false ;
5012	>	unsigned int arg9 = (unsigned int) 0 ;
5013	>	bool arg10 = (bool) false ;
5014		int result;
5015		std::string temp3 ;
5016		std::string temp4 ;
#	Line 4854 | Line 5022 | static PyObject *_wrap_BossTask_query(Py
5022		PyObject * obj6 = 0 ;
5023		PyObject * obj7 = 0 ;
5024		PyObject * obj8 = 0 ;
5025	+	PyObject * obj9 = 0 ;
5026
5027	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5027	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5028		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5029		if (obj2) {
5030		{
#	Line 4910 | Line 5079 | static PyObject *_wrap_BossTask_query(Py
5079		}
5080		}
5081		if (obj8) {
5082	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5082	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5083	>	if (PyErr_Occurred()) SWIG_fail;
5084	>	}
5085	>	if (obj9) {
5086	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5087		if (PyErr_Occurred()) SWIG_fail;
5088		}
5089		{
5090		try {
5091	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5091	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5092
5093		}catch (const BossSchedFailure & e) {
5094	<	SWIG_exception(SWIG_ValueError, e.what());
5094	>	PyErr_SetString ( SchedulerError, e.what() );
5095	>	return NULL;
5096		}catch (const std::exception& e) {
5097	<	SWIG_exception(SWIG_RuntimeError, e.what());
5097	>	PyErr_SetString ( BossError, e.what() );
5098	>	return NULL;
5099		}
5100		}
5101		resultobj = PyInt_FromLong((long)result);
#	Line 4979 | Line 5154 | static PyObject *_wrap_BossTask_query_ou
5154		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5155
5156		}catch (const BossSchedFailure & e) {
5157	<	SWIG_exception(SWIG_ValueError, e.what());
5157	>	PyErr_SetString ( SchedulerError, e.what() );
5158	>	return NULL;
5159		}catch (const std::exception& e) {
5160	<	SWIG_exception(SWIG_RuntimeError, e.what());
5160	>	PyErr_SetString ( BossError, e.what() );
5161	>	return NULL;
5162		}
5163		}
5164		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5003 | Line 5180 | static PyObject *_wrap_BossTask_clear(Py
5180		(arg1)->clear();
5181
5182		}catch (const BossSchedFailure & e) {
5183	<	SWIG_exception(SWIG_ValueError, e.what());
5183	>	PyErr_SetString ( SchedulerError, e.what() );
5184	>	return NULL;
5185		}catch (const std::exception& e) {
5186	<	SWIG_exception(SWIG_RuntimeError, e.what());
5186	>	PyErr_SetString ( BossError, e.what() );
5187	>	return NULL;
5188		}
5189		}
5190		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5015 | Line 5194 | static PyObject *_wrap_BossTask_clear(Py
5194		}
5195
5196
5197	+	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5198	+	PyObject *resultobj;
5199	+	BossTask *arg1 = (BossTask *) 0 ;
5200	+	PyObject *arg2 = (PyObject *) 0 ;
5201	+	BossAttributeContainer *arg3 = 0 ;
5202	+	PyObject *result;
5203	+	PyObject * obj0 = 0 ;
5204	+	PyObject * obj1 = 0 ;
5205	+	PyObject * obj2 = 0 ;
5206	+
5207	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5208	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5209	+	arg2 = obj1;
5210	+	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5211	+	if (arg3 == NULL) {
5212	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5213	+	}
5214	+	{
5215	+	try {
5216	+	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5217	+
5218	+	}catch (const BossSchedFailure & e) {
5219	+	PyErr_SetString ( SchedulerError, e.what() );
5220	+	return NULL;
5221	+	}catch (const std::exception& e) {
5222	+	PyErr_SetString ( BossError, e.what() );
5223	+	return NULL;
5224	+	}
5225	+	}
5226	+	resultobj = result;
5227	+	return resultobj;
5228	+	fail:
5229	+	return NULL;
5230	+	}
5231	+
5232	+
5233	+	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5234	+	PyObject *resultobj;
5235	+	BossTask *arg1 = (BossTask *) 0 ;
5236	+	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5237	+	PyObject *result;
5238	+	PyObject * obj0 = 0 ;
5239	+	PyObject * obj1 = 0 ;
5240	+
5241	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5242	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5243	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5244	+	if (arg2 == NULL) {
5245	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5246	+	}
5247	+	{
5248	+	try {
5249	+	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5250	+
5251	+	}catch (const BossSchedFailure & e) {
5252	+	PyErr_SetString ( SchedulerError, e.what() );
5253	+	return NULL;
5254	+	}catch (const std::exception& e) {
5255	+	PyErr_SetString ( BossError, e.what() );
5256	+	return NULL;
5257	+	}
5258	+	}
5259	+	resultobj = result;
5260	+	return resultobj;
5261	+	fail:
5262	+	return NULL;
5263	+	}
5264	+
5265	+
5266	+	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5267	+	PyObject *resultobj;
5268	+	BossTask *arg1 = (BossTask *) 0 ;
5269	+	PyObject *result;
5270	+	PyObject * obj0 = 0 ;
5271	+
5272	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5273	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5274	+	{
5275	+	try {
5276	+	result = (PyObject *)BossTask_jobsDict(arg1);
5277	+
5278	+	}catch (const BossSchedFailure & e) {
5279	+	PyErr_SetString ( SchedulerError, e.what() );
5280	+	return NULL;
5281	+	}catch (const std::exception& e) {
5282	+	PyErr_SetString ( BossError, e.what() );
5283	+	return NULL;
5284	+	}
5285	+	}
5286	+	resultobj = result;
5287	+	return resultobj;
5288	+	fail:
5289	+	return NULL;
5290	+	}
5291	+
5292	+
5293	+	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5294	+	PyObject *resultobj;
5295	+	BossTask *arg1 = (BossTask *) 0 ;
5296	+	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5297	+	PyObject *result;
5298	+	PyObject * obj0 = 0 ;
5299	+	PyObject * obj1 = 0 ;
5300	+
5301	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5302	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5303	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5304	+	if (arg2 == NULL) {
5305	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5306	+	}
5307	+	{
5308	+	try {
5309	+	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5310	+
5311	+	}catch (const BossSchedFailure & e) {
5312	+	PyErr_SetString ( SchedulerError, e.what() );
5313	+	return NULL;
5314	+	}catch (const std::exception& e) {
5315	+	PyErr_SetString ( BossError, e.what() );
5316	+	return NULL;
5317	+	}
5318	+	}
5319	+	resultobj = result;
5320	+	return resultobj;
5321	+	fail:
5322	+	return NULL;
5323	+	}
5324	+
5325	+
5326	+	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5327	+	PyObject *resultobj;
5328	+	BossTask *arg1 = (BossTask *) 0 ;
5329	+	std::string *arg2 = 0 ;
5330	+	PyObject *result;
5331	+	std::string temp2 ;
5332	+	PyObject * obj0 = 0 ;
5333	+	PyObject * obj1 = 0 ;
5334	+
5335	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5336	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5337	+	{
5338	+	if (PyString_Check(obj1)) {
5339	+	temp2 = std::string(PyString_AsString(obj1));
5340	+	arg2 = &temp2;
5341	+	}else {
5342	+	SWIG_exception(SWIG_TypeError, "string expected");
5343	+	}
5344	+	}
5345	+	{
5346	+	try {
5347	+	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5348	+
5349	+	}catch (const BossSchedFailure & e) {
5350	+	PyErr_SetString ( SchedulerError, e.what() );
5351	+	return NULL;
5352	+	}catch (const std::exception& e) {
5353	+	PyErr_SetString ( BossError, e.what() );
5354	+	return NULL;
5355	+	}
5356	+	}
5357	+	resultobj = result;
5358	+	return resultobj;
5359	+	fail:
5360	+	return NULL;
5361	+	}
5362	+
5363	+
5364		static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5365		PyObject *obj;
5366		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 5078 | Line 5424 | static PyObject *_wrap_new_BossAdministr
5424		result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5425
5426		}catch (const BossSchedFailure & e) {
5427	<	SWIG_exception(SWIG_ValueError, e.what());
5427	>	PyErr_SetString ( SchedulerError, e.what() );
5428	>	return NULL;
5429		}catch (const std::exception& e) {
5430	<	SWIG_exception(SWIG_RuntimeError, e.what());
5430	>	PyErr_SetString ( BossError, e.what() );
5431	>	return NULL;
5432		}
5433		}
5434		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 5102 | Line 5450 | static PyObject *_wrap_delete_BossAdmini
5450		delete arg1;
5451
5452		}catch (const BossSchedFailure & e) {
5453	<	SWIG_exception(SWIG_ValueError, e.what());
5453	>	PyErr_SetString ( SchedulerError, e.what() );
5454	>	return NULL;
5455		}catch (const std::exception& e) {
5456	<	SWIG_exception(SWIG_RuntimeError, e.what());
5456	>	PyErr_SetString ( BossError, e.what() );
5457	>	return NULL;
5458		}
5459		}
5460		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5127 | Line 5477 | static PyObject *_wrap_BossAdministrator
5477		result = (int)(arg1)->configureDB();
5478
5479		}catch (const BossSchedFailure & e) {
5480	<	SWIG_exception(SWIG_ValueError, e.what());
5480	>	PyErr_SetString ( SchedulerError, e.what() );
5481	>	return NULL;
5482		}catch (const std::exception& e) {
5483	<	SWIG_exception(SWIG_RuntimeError, e.what());
5483	>	PyErr_SetString ( BossError, e.what() );
5484	>	return NULL;
5485		}
5486		}
5487		resultobj = PyInt_FromLong((long)result);
#	Line 5163 | Line 5515 | static PyObject *_wrap_BossAdministrator
5515		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5516
5517		}catch (const BossSchedFailure & e) {
5518	<	SWIG_exception(SWIG_ValueError, e.what());
5518	>	PyErr_SetString ( SchedulerError, e.what() );
5519	>	return NULL;
5520		}catch (const std::exception& e) {
5521	<	SWIG_exception(SWIG_RuntimeError, e.what());
5521	>	PyErr_SetString ( BossError, e.what() );
5522	>	return NULL;
5523		}
5524		}
5525		resultobj = PyInt_FromLong((long)result);
#	Line 5199 | Line 5553 | static PyObject *_wrap_BossAdministrator
5553		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5554
5555		}catch (const BossSchedFailure & e) {
5556	<	SWIG_exception(SWIG_ValueError, e.what());
5556	>	PyErr_SetString ( SchedulerError, e.what() );
5557	>	return NULL;
5558		}catch (const std::exception& e) {
5559	<	SWIG_exception(SWIG_RuntimeError, e.what());
5559	>	PyErr_SetString ( BossError, e.what() );
5560	>	return NULL;
5561		}
5562		}
5563		resultobj = PyInt_FromLong((long)result);
#	Line 5235 | Line 5591 | static PyObject *_wrap_BossAdministrator
5591		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5592
5593		}catch (const BossSchedFailure & e) {
5594	<	SWIG_exception(SWIG_ValueError, e.what());
5594	>	PyErr_SetString ( SchedulerError, e.what() );
5595	>	return NULL;
5596		}catch (const std::exception& e) {
5597	<	SWIG_exception(SWIG_RuntimeError, e.what());
5597	>	PyErr_SetString ( BossError, e.what() );
5598	>	return NULL;
5599		}
5600		}
5601		resultobj = PyInt_FromLong((long)result);
#	Line 5271 | Line 5629 | static PyObject *_wrap_BossAdministrator
5629		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5630
5631		}catch (const BossSchedFailure & e) {
5632	<	SWIG_exception(SWIG_ValueError, e.what());
5632	>	PyErr_SetString ( SchedulerError, e.what() );
5633	>	return NULL;
5634		}catch (const std::exception& e) {
5635	<	SWIG_exception(SWIG_RuntimeError, e.what());
5635	>	PyErr_SetString ( BossError, e.what() );
5636	>	return NULL;
5637		}
5638		}
5639		resultobj = PyInt_FromLong((long)result);
#	Line 5307 | Line 5667 | static PyObject *_wrap_BossAdministrator
5667		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5668
5669		}catch (const BossSchedFailure & e) {
5670	<	SWIG_exception(SWIG_ValueError, e.what());
5670	>	PyErr_SetString ( SchedulerError, e.what() );
5671	>	return NULL;
5672		}catch (const std::exception& e) {
5673	<	SWIG_exception(SWIG_RuntimeError, e.what());
5673	>	PyErr_SetString ( BossError, e.what() );
5674	>	return NULL;
5675		}
5676		}
5677		resultobj = PyInt_FromLong((long)result);
#	Line 5375 | Line 5737 | static PyObject *_wrap_BossAdministrator
5737		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5738
5739		}catch (const BossSchedFailure & e) {
5740	<	SWIG_exception(SWIG_ValueError, e.what());
5740	>	PyErr_SetString ( SchedulerError, e.what() );
5741	>	return NULL;
5742		}catch (const std::exception& e) {
5743	<	SWIG_exception(SWIG_RuntimeError, e.what());
5743	>	PyErr_SetString ( BossError, e.what() );
5744	>	return NULL;
5745		}
5746		}
5747		resultobj = PyInt_FromLong((long)result);
#	Line 5467 | Line 5831 | static PyObject *_wrap_BossAdministrator
5831		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5832
5833		}catch (const BossSchedFailure & e) {
5834	<	SWIG_exception(SWIG_ValueError, e.what());
5834	>	PyErr_SetString ( SchedulerError, e.what() );
5835	>	return NULL;
5836		}catch (const std::exception& e) {
5837	<	SWIG_exception(SWIG_RuntimeError, e.what());
5837	>	PyErr_SetString ( BossError, e.what() );
5838	>	return NULL;
5839		}
5840		}
5841		resultobj = PyInt_FromLong((long)result);
#	Line 5545 | Line 5911 | static PyObject *_wrap_BossAdministrator
5911		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5912
5913		}catch (const BossSchedFailure & e) {
5914	<	SWIG_exception(SWIG_ValueError, e.what());
5914	>	PyErr_SetString ( SchedulerError, e.what() );
5915	>	return NULL;
5916		}catch (const std::exception& e) {
5917	<	SWIG_exception(SWIG_RuntimeError, e.what());
5917	>	PyErr_SetString ( BossError, e.what() );
5918	>	return NULL;
5919		}
5920		}
5921		resultobj = PyInt_FromLong((long)result);
#	Line 5719 | Line 6087 | static PyObject *_wrap_BossAdministrator
6087		result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15,arg16,arg17);
6088
6089		}catch (const BossSchedFailure & e) {
6090	<	SWIG_exception(SWIG_ValueError, e.what());
6090	>	PyErr_SetString ( SchedulerError, e.what() );
6091	>	return NULL;
6092		}catch (const std::exception& e) {
6093	<	SWIG_exception(SWIG_RuntimeError, e.what());
6093	>	PyErr_SetString ( BossError, e.what() );
6094	>	return NULL;
6095		}
6096		}
6097		resultobj = PyInt_FromLong((long)result);
#	Line 5744 | Line 6114 | static PyObject *_wrap_BossAdministrator
6114		result = (arg1)->help();
6115
6116		}catch (const BossSchedFailure & e) {
6117	<	SWIG_exception(SWIG_ValueError, e.what());
6117	>	PyErr_SetString ( SchedulerError, e.what() );
6118	>	return NULL;
6119		}catch (const std::exception& e) {
6120	<	SWIG_exception(SWIG_RuntimeError, e.what());
6120	>	PyErr_SetString ( BossError, e.what() );
6121	>	return NULL;
6122		}
6123		}
6124		{
#	Line 5785 | Line 6157 | static PyObject *_wrap_BossAdministrator
6157		result = (arg1)->SQL(arg2,arg3);
6158
6159		}catch (const BossSchedFailure & e) {
6160	<	SWIG_exception(SWIG_ValueError, e.what());
6160	>	PyErr_SetString ( SchedulerError, e.what() );
6161	>	return NULL;
6162		}catch (const std::exception& e) {
6163	<	SWIG_exception(SWIG_RuntimeError, e.what());
6163	>	PyErr_SetString ( BossError, e.what() );
6164	>	return NULL;
6165		}
6166		}
6167		{
#	Line 5859 | Line 6233 | static PyObject *_wrap_BossAdministrator
6233		result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6234
6235		}catch (const BossSchedFailure & e) {
6236	<	SWIG_exception(SWIG_ValueError, e.what());
6236	>	PyErr_SetString ( SchedulerError, e.what() );
6237	>	return NULL;
6238		}catch (const std::exception& e) {
6239	<	SWIG_exception(SWIG_RuntimeError, e.what());
6239	>	PyErr_SetString ( BossError, e.what() );
6240	>	return NULL;
6241		}
6242		}
6243		resultobj = PyInt_FromLong((long)result);
#	Line 5892 | Line 6268 | static PyObject *_wrap_BossAdministrator
6268		result = (int)(arg1)->registerPlugins(arg2);
6269
6270		}catch (const BossSchedFailure & e) {
6271	<	SWIG_exception(SWIG_ValueError, e.what());
6271	>	PyErr_SetString ( SchedulerError, e.what() );
6272	>	return NULL;
6273		}catch (const std::exception& e) {
6274	<	SWIG_exception(SWIG_RuntimeError, e.what());
6274	>	PyErr_SetString ( BossError, e.what() );
6275	>	return NULL;
6276		}
6277		}
6278		resultobj = PyInt_FromLong((long)result);
#	Line 5941 | Line 6319 | static PyMethodDef SwigMethods[] = {
6319		{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6320		{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6321		{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5944	–	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5945	–	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5946	–	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5947	–	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5948	–	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5949	–	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5950	–	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6322		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6323		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6324		{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6325		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6326		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6327		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6328	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6329	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6330	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6331	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6332		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6333		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6334		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5966 | Line 6341 | static PyMethodDef SwigMethods[] = {
6341		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6342		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6343		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6344	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6345	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6346	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6347	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6348	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6349	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6350	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6351		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6352		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6353		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5973 | Line 6355 | static PyMethodDef SwigMethods[] = {
6355		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6356		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6357		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5976	–	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5977	–	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5978	–	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
5979	–	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5980	–	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6358		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6359		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6360		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
#	Line 6000 | Line 6377 | static PyMethodDef SwigMethods[] = {
6377		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6378		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6379		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6380	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6381	+	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6382	+	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6383	+	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6384	+	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6385		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6386		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6387		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 6024 | Line 6406 | static PyMethodDef SwigMethods[] = {
6406
6407		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6408
6409	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6410		static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t", 0, "std::vector<std::pair<BossProgram,BossProgramExec > > *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t"},{0}};
6411		static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator", 0, "std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator"},{0}};
6029	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6412		static swig_type_info _swigt__p_std__vectorTBossTask_p_t[] = {{"_p_std__vectorTBossTask_p_t", 0, "std::vector<BossTask * > *", 0},{"_p_std__vectorTBossTask_p_t"},{0}};
6413		static swig_type_info _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t[] = {{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t", 0, "std::map<std::string,std::map<std::string,std::string > > *", 0},{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t"},{0}};
6414	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6415		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6416		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
6034	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6035	–	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6417		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6418	+	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6419		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6420		static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6421		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6422		static swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0},{"_p_std__vectorTstd__string_t"},{0}};
6423		static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
6424		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
6043	–	static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
6425		static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
6426	+	static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
6427		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6428
6429		static swig_type_info *swig_types_initial[] = {
6430	+	_swigt__p_XMLDoc,
6431		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6432		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6050	–	_swigt__p_XMLDoc,
6433		_swigt__p_std__vectorTBossTask_p_t,
6434		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6435	+	_swigt__p_std__ostream,
6436		_swigt__p_BossTask,
6437		_swigt__p_BossTaskException,
6055	–	_swigt__p_std__ostream,
6056	–	_swigt__p_BossAttributeContainer,
6438		_swigt__p_printOption,
6439	+	_swigt__p_BossAttributeContainer,
6440		_swigt__p_BossJob,
6441		_swigt__p_BossDatabase,
6442		_swigt__p_BossSession,
6443		_swigt__p_std__vectorTstd__string_t,
6444		_swigt__p_std__mapTstd__string_std__string_t,
6445		_swigt__p_BossAdministratorSession,
6064	–	_swigt__p_BossTask__job_iterator,
6446		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6447	+	_swigt__p_BossTask__job_iterator,
6448		_swigt__p_jobStates,
6449		0
6450		};
#	Line 6106 | Line 6488 | SWIGEXPORT(void) SWIG_init(void) {
6488		}
6489		SWIG_InstallConstants(d,swig_const_table);
6490
6491	+
6492	+	// define custom exceptions
6493	+	PyObject *e;
6494	+	PyMethodDef tp_methods = {
6495	+	NULL, NULL, 0, NULL
6496	+	};
6497	+	e = Py_InitModule("BossSession", &tp_methods);
6498	+	// generic BOSS exception
6499	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6500	+	Py_INCREF(BossError);
6501	+	PyModule_AddObject(e, "BossError", BossError);
6502	+	// scheduler interaction BOSS exception
6503	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6504	+	Py_INCREF(SchedulerError);
6505	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6506	+
6507		}
6508

Diff Legend

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