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

Diff Legend

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