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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.11 by gcodispo, Mon Oct 30 14:00:27 2006 UTC vs.
Revision 1.27 by gcodispo, Thu Mar 8 17:52:39 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 927 \| Line 929 \| void std_vectorlstd_string_g___delslice_
929		#include "BossProgram.h"
930		#include "BossProgramExec.h"
931		#include "BossDatabase.h"
932	+	#include "BossScheduler.h"
933	+	#include "BossDeclaration.h"
934
935		PyObject BossSession_show(BossSession self,std::vector<std::string > &my_vec){
936		PyObject * my_list = PyList_New( my_vec.size());
#	Line 953 \| 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){
970	<	if ( !avoidCheck ) {
971	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
972	<	type, user, after, before);
973	<	}
974	<	PyObject * job_dict = PyList_New(0);
975	<	std::vector <std::string>
971	<	taskList = self->selectTasks( taskRange, before, after, user);
972	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
973	<	it!= taskList.end(); ++it ) {
974	<	PyList_Append( job_dict, PyString_FromString(it->c_str() ) );
969	>	PyObject BossSession_queryTasks(BossSession self,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
970	>	PyObject * task_list = PyList_New(0);
971	>	std::vector <std::string> taskList;
972	>	if ( taskName.empty() ) {
973	>	taskList = self->selectTasks( taskRange, before, after, user);
974	>	} else {
975	>	taskList = self->selectTasksByName( taskName );
976		}
977	<
978	<	// int size = taskList.size();
979	<	// PyObject * job_dict = PyList_New(0);
979	<	// for ( unsigned int i = 0; i < size; ++i ) {
980	<	// PyList_SetItem(job_dict,i, );
981	<	// self->makeBossTask( *it );
982	<	// }
983	<	return job_dict;
984	<	}
985	<	PyObject BossTask_appendToPyDict(BossTask const self,PyObject *dict,BossAttributeContainer const &obj){
986	<	std::string tmp;
987	<	BossAttributeContainer::const_iterator it_end = obj.end ();
988	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
989	<	it != it_end; ++it) {
990	<	tmp = (*it).first.name ();
991	<	char * key = new char[ tmp.size() ];
992	<	key = strdup(tmp.c_str());
993	<	tmp = (*it).second.value ();
994	<	PyObject * val = PyString_FromString( tmp.c_str() );
995	<	PyDict_SetItemString( dict, key, val );
996	<	delete [] key;
977	>	for ( std::vector <std::string>::const_iterator it= taskList.begin();
978	>	it!= taskList.end(); ++it ) {
979	>	PyList_Append( task_list, PyString_FromString(it->c_str() ) );
980		}
981	<	return dict;
981	>	return task_list;
982		}
983	<	PyObject BossTask_jobDict(BossTask const self,std::vector<BossJob * >::const_iterator &jit){
983	>	void BossTask_appendToPyDict(BossTask const self,PyObject dict,BossAttributeContainer const &obj){
984	>	std::string tmp;
985	>	BossAttributeContainer::const_iterator it_end = obj.end ();
986	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
987	>	it != it_end; ++it) {
988	>
989	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
990	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
991	>	PyDict_SetItem( dict, key, val);
992	>	Py_DECREF(key);
993	>	Py_DECREF(val);
994	>	}
995	>	return;
996	>	}
997	>	void BossTask_jobDict(BossTask const self,std::vector<BossJob >::const_iterator &jit,PyObject *job_dict){
998
999	<	PyObject * job_dict = PyDict_New();
999	>	// PyObject * job_dict = PyDict_New();
1000		std::string tmp;
1001
1002		BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1003	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1003	>	BossTask_appendToPyDict ( self, job_dict, obj );
1004
1005		std::set<std::string> sch = (*jit)->getSchedulerElements();
1006		std::set<std::string>::const_iterator sch_end = sch.end();
1007		for (std::set<std::string>::const_iterator it =sch.begin();
1008		it != sch_end; ++ it ) {
1009	<	tmp = (*it);
1013	<	char * key = new char[ tmp.size() ];
1014	<	key = strdup(tmp.c_str());
1009	>
1010		tmp = (*jit)["JOB_SCHED_INFO."+(it)];
1011	+	PyObject * key = PyString_FromString( it->c_str() );
1012		PyObject * val = PyString_FromString( tmp.c_str() );
1013	<	PyDict_SetItemString( job_dict, key, val );
1014	<	delete [] key;
1013	>	PyDict_SetItem( job_dict, key, val);
1014	>	Py_DECREF(key);
1015	>	Py_DECREF(val);
1016		}
1017	<	return job_dict;
1017	>	return;
1018		}
1019	<	PyObject BossTask_jobsDict(BossTask const self){
1019	>	PyObject BossTask_jobsDict(BossTask self){
1020
1021		PyObject * job_dict = PyDict_New();
1022	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1023		for (BossTask::job_iterator jit = self->job_begin ();
1024		jit != self->job_end (); ++jit) {
1025	<	std::string id = (*jit)->chainId();
1026	<	PyObject * tmp = BossTask_jobDict( self, jit );
1027	<	PyObject * myid = PyString_FromString(id.c_str() );
1028	<	PyDict_SetItem( job_dict, myid,tmp );
1025	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1026	>	PyObject * tmp_dict = PyDict_New();
1027	>	BossTask_jobDict( self, jit, tmp_dict );
1028	>	PyDict_SetItem( job_dict, id, tmp_dict );
1029	>	Py_DECREF(id);
1030	>	Py_DECREF(tmp_dict);
1031		}
1032		return job_dict;
1033		}
#	Line 1072 \| Line 1072 \| *PyObject BossTask_jobPrograms(BossTask**
1072		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1073		++programs_it ) {
1074		std::string id = (programs_it->first)["PROGRAM.ID"];
1075	<	PyObject * tmp = BossTask_progDict( self, programs_it );
1075	>	PyObject * tmp_dict = BossTask_progDict( self, programs_it );
1076		PyObject * myid = PyString_FromString(id.c_str() );
1077	<	PyDict_SetItem( job_dict, myid,tmp );
1077	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1078	>	Py_DECREF(myid);
1079	>	Py_DECREF(tmp_dict);
1080		}
1081		return job_dict;
1082		}
#	Line 1090 \| Line 1092 \| *static PyObject _wrap_new_objectMap__SW**
1092		try {
1093		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1094
1095	+	}catch (const BossSchedFailure & e) {
1096	+	PyErr_SetString ( SchedulerError, e.what() );
1097	+	return NULL;
1098		}catch (const std::exception& e) {
1099	<	SWIG_exception(SWIG_RuntimeError, e.what());
1099	>	PyErr_SetString ( BossError, e.what() );
1100	>	return NULL;
1101		}
1102		}
1103		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1149 \| Line 1155 \| *static PyObject _wrap_new_objectMap__SW**
1155		try {
1156		result = (std::map<std::string,std::string > )new std::map<std::string,std::string >((std::map<std::string,std::string > const &)arg1);
1157
1158	+	}catch (const BossSchedFailure & e) {
1159	+	PyErr_SetString ( SchedulerError, e.what() );
1160	+	return NULL;
1161		}catch (const std::exception& e) {
1162	<	SWIG_exception(SWIG_RuntimeError, e.what());
1162	>	PyErr_SetString ( BossError, e.what() );
1163	>	return NULL;
1164		}
1165		}
1166		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1264 \| Line 1274 \| *static PyObject _wrap_objectMap___len__**
1274		try {
1275		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1276
1277	+	}catch (const BossSchedFailure & e) {
1278	+	PyErr_SetString ( SchedulerError, e.what() );
1279	+	return NULL;
1280		}catch (const std::exception& e) {
1281	<	SWIG_exception(SWIG_RuntimeError, e.what());
1281	>	PyErr_SetString ( BossError, e.what() );
1282	>	return NULL;
1283		}
1284		}
1285		resultobj = PyInt_FromLong((long)result);
#	Line 1286 \| Line 1300 \| *static PyObject _wrap_objectMap_clear(P**
1300		try {
1301		(arg1)->clear();
1302
1303	+	}catch (const BossSchedFailure & e) {
1304	+	PyErr_SetString ( SchedulerError, e.what() );
1305	+	return NULL;
1306		}catch (const std::exception& e) {
1307	<	SWIG_exception(SWIG_RuntimeError, e.what());
1307	>	PyErr_SetString ( BossError, e.what() );
1308	>	return NULL;
1309		}
1310		}
1311		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1309 \| Line 1327 \| *static PyObject _wrap_objectMap___nonze**
1327		try {
1328		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1329
1330	+	}catch (const BossSchedFailure & e) {
1331	+	PyErr_SetString ( SchedulerError, e.what() );
1332	+	return NULL;
1333		}catch (const std::exception& e) {
1334	<	SWIG_exception(SWIG_RuntimeError, e.what());
1334	>	PyErr_SetString ( BossError, e.what() );
1335	>	return NULL;
1336		}
1337		}
1338		resultobj = PyInt_FromLong((long)result);
#	Line 1381 \| Line 1403 \| *static PyObject _wrap_objectMap___setit**
1403		try {
1404		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1405
1406	+	}catch (const BossSchedFailure & e) {
1407	+	PyErr_SetString ( SchedulerError, e.what() );
1408	+	return NULL;
1409		}catch (const std::exception& e) {
1410	<	SWIG_exception(SWIG_RuntimeError, e.what());
1410	>	PyErr_SetString ( BossError, e.what() );
1411	>	return NULL;
1412		}
1413		}
1414		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1443 \| Line 1469 \| *static PyObject _wrap_objectMap_has_key**
1469		try {
1470		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1471
1472	+	}catch (const BossSchedFailure & e) {
1473	+	PyErr_SetString ( SchedulerError, e.what() );
1474	+	return NULL;
1475		}catch (const std::exception& e) {
1476	<	SWIG_exception(SWIG_RuntimeError, e.what());
1476	>	PyErr_SetString ( BossError, e.what() );
1477	>	return NULL;
1478		}
1479		}
1480		resultobj = PyInt_FromLong((long)result);
#	Line 1466 \| Line 1496 \| *static PyObject _wrap_objectMap_keys(Py**
1496		try {
1497		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1498
1499	+	}catch (const BossSchedFailure & e) {
1500	+	PyErr_SetString ( SchedulerError, e.what() );
1501	+	return NULL;
1502		}catch (const std::exception& e) {
1503	<	SWIG_exception(SWIG_RuntimeError, e.what());
1503	>	PyErr_SetString ( BossError, e.what() );
1504	>	return NULL;
1505		}
1506		}
1507		resultobj = result;
#	Line 1489 \| Line 1523 \| *static PyObject _wrap_objectMap_values(**
1523		try {
1524		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1525
1526	+	}catch (const BossSchedFailure & e) {
1527	+	PyErr_SetString ( SchedulerError, e.what() );
1528	+	return NULL;
1529		}catch (const std::exception& e) {
1530	<	SWIG_exception(SWIG_RuntimeError, e.what());
1530	>	PyErr_SetString ( BossError, e.what() );
1531	>	return NULL;
1532		}
1533		}
1534		resultobj = result;
#	Line 1512 \| Line 1550 \| *static PyObject _wrap_objectMap_items(P**
1550		try {
1551		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1552
1553	+	}catch (const BossSchedFailure & e) {
1554	+	PyErr_SetString ( SchedulerError, e.what() );
1555	+	return NULL;
1556		}catch (const std::exception& e) {
1557	<	SWIG_exception(SWIG_RuntimeError, e.what());
1557	>	PyErr_SetString ( BossError, e.what() );
1558	>	return NULL;
1559		}
1560		}
1561		resultobj = result;
#	Line 1543 \| Line 1585 \| *static PyObject _wrap_objectMap___conta**
1585		try {
1586		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1587
1588	+	}catch (const BossSchedFailure & e) {
1589	+	PyErr_SetString ( SchedulerError, e.what() );
1590	+	return NULL;
1591		}catch (const std::exception& e) {
1592	<	SWIG_exception(SWIG_RuntimeError, e.what());
1592	>	PyErr_SetString ( BossError, e.what() );
1593	>	return NULL;
1594		}
1595		}
1596		resultobj = PyInt_FromLong((long)result);
#	Line 1589 \| Line 1635 \| *static PyObject _wrap_delete_objectMap(**
1635		try {
1636		delete arg1;
1637
1638	+	}catch (const BossSchedFailure & e) {
1639	+	PyErr_SetString ( SchedulerError, e.what() );
1640	+	return NULL;
1641		}catch (const std::exception& e) {
1642	<	SWIG_exception(SWIG_RuntimeError, e.what());
1642	>	PyErr_SetString ( BossError, e.what() );
1643	>	return NULL;
1644		}
1645		}
1646		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1622 \| Line 1672 \| *static PyObject _wrap_new_vector_string**
1672		try {
1673		result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1674
1675	+	}catch (const BossSchedFailure & e) {
1676	+	PyErr_SetString ( SchedulerError, e.what() );
1677	+	return NULL;
1678		}catch (const std::exception& e) {
1679	<	SWIG_exception(SWIG_RuntimeError, e.what());
1679	>	PyErr_SetString ( BossError, e.what() );
1680	>	return NULL;
1681		}
1682		}
1683		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1657 \| Line 1711 \| *static PyObject _wrap_new_vector_string**
1711		try {
1712		result = (std::vector<std::string > )new std::vector<std::string >(arg1,(std::string const &)arg2);
1713
1714	+	}catch (const BossSchedFailure & e) {
1715	+	PyErr_SetString ( SchedulerError, e.what() );
1716	+	return NULL;
1717		}catch (const std::exception& e) {
1718	<	SWIG_exception(SWIG_RuntimeError, e.what());
1718	>	PyErr_SetString ( BossError, e.what() );
1719	>	return NULL;
1720		}
1721		}
1722		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1709 \| Line 1767 \| *static PyObject _wrap_new_vector_string**
1767		try {
1768		result = (std::vector<std::string > )new std::vector<std::string >((std::vector<std::string > const &)arg1);
1769
1770	+	}catch (const BossSchedFailure & e) {
1771	+	PyErr_SetString ( SchedulerError, e.what() );
1772	+	return NULL;
1773		}catch (const std::exception& e) {
1774	<	SWIG_exception(SWIG_RuntimeError, e.what());
1774	>	PyErr_SetString ( BossError, e.what() );
1775	>	return NULL;
1776		}
1777		}
1778		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1836 \| Line 1898 \| *static PyObject _wrap_vector_string___l**
1898		try {
1899		result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1900
1901	+	}catch (const BossSchedFailure & e) {
1902	+	PyErr_SetString ( SchedulerError, e.what() );
1903	+	return NULL;
1904		}catch (const std::exception& e) {
1905	<	SWIG_exception(SWIG_RuntimeError, e.what());
1905	>	PyErr_SetString ( BossError, e.what() );
1906	>	return NULL;
1907		}
1908		}
1909		resultobj = PyInt_FromLong((long)result);
#	Line 1888 \| Line 1954 \| *static PyObject _wrap_vector_string___n**
1954		try {
1955		result = (bool)((std::vector<std::string > const *)arg1)->empty();
1956
1957	+	}catch (const BossSchedFailure & e) {
1958	+	PyErr_SetString ( SchedulerError, e.what() );
1959	+	return NULL;
1960		}catch (const std::exception& e) {
1961	<	SWIG_exception(SWIG_RuntimeError, e.what());
1961	>	PyErr_SetString ( BossError, e.what() );
1962	>	return NULL;
1963		}
1964		}
1965		resultobj = PyInt_FromLong((long)result);
#	Line 1910 \| Line 1980 \| *static PyObject _wrap_vector_string_cle**
1980		try {
1981		(arg1)->clear();
1982
1983	+	}catch (const BossSchedFailure & e) {
1984	+	PyErr_SetString ( SchedulerError, e.what() );
1985	+	return NULL;
1986		}catch (const std::exception& e) {
1987	<	SWIG_exception(SWIG_RuntimeError, e.what());
1987	>	PyErr_SetString ( BossError, e.what() );
1988	>	return NULL;
1989		}
1990		}
1991		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1940 \| Line 2014 \| *static PyObject _wrap_vector_string_app**
2014		try {
2015		(arg1)->push_back(arg2);
2016
2017	+	}catch (const BossSchedFailure & e) {
2018	+	PyErr_SetString ( SchedulerError, e.what() );
2019	+	return NULL;
2020		}catch (const std::exception& e) {
2021	<	SWIG_exception(SWIG_RuntimeError, e.what());
2021	>	PyErr_SetString ( BossError, e.what() );
2022	>	return NULL;
2023		}
2024		}
2025		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2016 \| Line 2094 \| *static PyObject _wrap_vector_string___g**
2094		try {
2095		result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2096
2097	+	}catch (const BossSchedFailure & e) {
2098	+	PyErr_SetString ( SchedulerError, e.what() );
2099	+	return NULL;
2100		}catch (const std::exception& e) {
2101	<	SWIG_exception(SWIG_RuntimeError, e.what());
2101	>	PyErr_SetString ( BossError, e.what() );
2102	>	return NULL;
2103		}
2104		}
2105		{
#	Line 2108 \| Line 2190 \| *static PyObject _wrap_vector_string___s**
2190		try {
2191		std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2192
2193	+	}catch (const BossSchedFailure & e) {
2194	+	PyErr_SetString ( SchedulerError, e.what() );
2195	+	return NULL;
2196		}catch (const std::exception& e) {
2197	<	SWIG_exception(SWIG_RuntimeError, e.what());
2197	>	PyErr_SetString ( BossError, e.what() );
2198	>	return NULL;
2199		}
2200		}
2201		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2155 \| Line 2241 \| *static PyObject _wrap_vector_string___d**
2241		try {
2242		std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2243
2244	+	}catch (const BossSchedFailure & e) {
2245	+	PyErr_SetString ( SchedulerError, e.what() );
2246	+	return NULL;
2247		}catch (const std::exception& e) {
2248	<	SWIG_exception(SWIG_RuntimeError, e.what());
2248	>	PyErr_SetString ( BossError, e.what() );
2249	>	return NULL;
2250		}
2251		}
2252		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2177 \| Line 2267 \| *static PyObject _wrap_delete_vector_str**
2267		try {
2268		delete arg1;
2269
2270	+	}catch (const BossSchedFailure & e) {
2271	+	PyErr_SetString ( SchedulerError, e.what() );
2272	+	return NULL;
2273		}catch (const std::exception& e) {
2274	<	SWIG_exception(SWIG_RuntimeError, e.what());
2274	>	PyErr_SetString ( BossError, e.what() );
2275	>	return NULL;
2276		}
2277		}
2278		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2195 \| Line 2289 \| *static PyObject vector_string_swigregi**
2289		Py_INCREF(obj);
2290		return Py_BuildValue((char *)"");
2291		}
2292	<	static PyObject _wrap_BossSession_show(PyObject self, PyObject *args) {
2292	>	static PyObject _wrap_new_BossSession(PyObject self, PyObject *args) {
2293		PyObject *resultobj;
2294	<	BossSession arg1 = (BossSession ) 0 ;
2295	<	std::vector<std::string > *arg2 = 0 ;
2296	<	PyObject *result;
2294	>	std::string arg1 = (std::string) "" ;
2295	>	std::string arg2 = (std::string) "2" ;
2296	>	std::string arg3 = (std::string) "" ;
2297	>	std::string arg4 = (std::string) "" ;
2298	>	BossSession *result;
2299		PyObject * obj0 = 0 ;
2300		PyObject * obj1 = 0 ;
2301	+	PyObject * obj2 = 0 ;
2302	+	PyObject * obj3 = 0 ;
2303
2304	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2305	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2306	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2307	<	if (arg2 == NULL) {
2308	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2304	>	if(!PyArg_ParseTuple(args,(char *)"\|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2305	>	if (obj0) {
2306	>	{
2307	>	if (PyString_Check(obj0))
2308	>	arg1 = std::string(PyString_AsString(obj0));
2309	>	else
2310	>	SWIG_exception(SWIG_TypeError, "string expected");
2311	>	}
2312		}
2313	<	{
2314	<	try {
2315	<	result = (PyObject )BossSession_show(arg1,arg2);
2316	<
2317	<	}catch (const std::exception& e) {
2318	<	SWIG_exception(SWIG_RuntimeError, e.what());
2313	>	if (obj1) {
2314	>	{
2315	>	if (PyString_Check(obj1))
2316	>	arg2 = std::string(PyString_AsString(obj1));
2317	>	else
2318	>	SWIG_exception(SWIG_TypeError, "string expected");
2319	>	}
2320	>	}
2321	>	if (obj2) {
2322	>	{
2323	>	if (PyString_Check(obj2))
2324	>	arg3 = std::string(PyString_AsString(obj2));
2325	>	else
2326	>	SWIG_exception(SWIG_TypeError, "string expected");
2327	>	}
2328	>	}
2329	>	if (obj3) {
2330	>	{
2331	>	if (PyString_Check(obj3))
2332	>	arg4 = std::string(PyString_AsString(obj3));
2333	>	else
2334	>	SWIG_exception(SWIG_TypeError, "string expected");
2335		}
2336		}
2220	–	resultobj = result;
2221	–	return resultobj;
2222	–	fail:
2223	–	return NULL;
2224	–	}
2225	–
2226	–
2227	–	static PyObject _wrap_BossSession_CHTools(PyObject self, PyObject *args) {
2228	–	PyObject *resultobj;
2229	–	BossSession arg1 = (BossSession ) 0 ;
2230	–	PyObject *result;
2231	–	PyObject * obj0 = 0 ;
2232	–
2233	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2234	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2337		{
2338		try {
2339	<	result = (PyObject *)BossSession_CHTools(arg1);
2339	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2340
2341	+	}catch (const BossSchedFailure & e) {
2342	+	PyErr_SetString ( SchedulerError, e.what() );
2343	+	return NULL;
2344		}catch (const std::exception& e) {
2345	<	SWIG_exception(SWIG_RuntimeError, e.what());
2345	>	PyErr_SetString ( BossError, e.what() );
2346	>	return NULL;
2347		}
2348		}
2349	<	resultobj = result;
2349	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2350		return resultobj;
2351		fail:
2352		return NULL;
2353		}
2354
2355
2356	<	static PyObject _wrap_BossSession_ProgramTypes(PyObject self, PyObject *args) {
2356	>	static PyObject _wrap_delete_BossSession(PyObject self, PyObject *args) {
2357		PyObject *resultobj;
2358		BossSession arg1 = (BossSession ) 0 ;
2253	–	PyObject *result;
2359		PyObject * obj0 = 0 ;
2360
2361	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2361	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2362		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2363		{
2364		try {
2365	<	result = (PyObject *)BossSession_ProgramTypes(arg1);
2365	>	delete arg1;
2366
2367	+	}catch (const BossSchedFailure & e) {
2368	+	PyErr_SetString ( SchedulerError, e.what() );
2369	+	return NULL;
2370		}catch (const std::exception& e) {
2371	<	SWIG_exception(SWIG_RuntimeError, e.what());
2371	>	PyErr_SetString ( BossError, e.what() );
2372	>	return NULL;
2373		}
2374		}
2375	<	resultobj = result;
2375	>	Py_INCREF(Py_None); resultobj = Py_None;
2376		return resultobj;
2377		fail:
2378		return NULL;
2379		}
2380
2381
2382	<	static PyObject _wrap_BossSession_RTMons(PyObject self, PyObject *args) {
2382	>	static PyObject _wrap_BossSession_resetDB(PyObject self, PyObject *args) {
2383		PyObject *resultobj;
2384		BossSession arg1 = (BossSession ) 0 ;
2276	–	PyObject *result;
2385		PyObject * obj0 = 0 ;
2386
2387	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2387	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2388		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2389		{
2390		try {
2391	<	result = (PyObject *)BossSession_RTMons(arg1);
2391	>	(arg1)->resetDB();
2392
2393	+	}catch (const BossSchedFailure & e) {
2394	+	PyErr_SetString ( SchedulerError, e.what() );
2395	+	return NULL;
2396		}catch (const std::exception& e) {
2397	<	SWIG_exception(SWIG_RuntimeError, e.what());
2397	>	PyErr_SetString ( BossError, e.what() );
2398	>	return NULL;
2399		}
2400		}
2401	<	resultobj = result;
2401	>	Py_INCREF(Py_None); resultobj = Py_None;
2402		return resultobj;
2403		fail:
2404		return NULL;
2405		}
2406
2407
2408	<	static PyObject _wrap_BossSession_schedulers(PyObject self, PyObject *args) {
2408	>	static PyObject _wrap_BossSession_clear(PyObject self, PyObject *args) {
2409		PyObject *resultobj;
2410		BossSession arg1 = (BossSession ) 0 ;
2299	–	PyObject *result;
2411		PyObject * obj0 = 0 ;
2412
2413	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2413	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2414		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2415		{
2416		try {
2417	<	result = (PyObject *)BossSession_schedulers(arg1);
2417	>	(arg1)->clear();
2418
2419	+	}catch (const BossSchedFailure & e) {
2420	+	PyErr_SetString ( SchedulerError, e.what() );
2421	+	return NULL;
2422		}catch (const std::exception& e) {
2423	<	SWIG_exception(SWIG_RuntimeError, e.what());
2423	>	PyErr_SetString ( BossError, e.what() );
2424	>	return NULL;
2425		}
2426		}
2427	<	resultobj = result;
2427	>	Py_INCREF(Py_None); resultobj = Py_None;
2428		return resultobj;
2429		fail:
2430		return NULL;
2431		}
2432
2433
2434	<	static PyObject _wrap_BossSession_schedListMatch(PyObject self, PyObject *args) {
2434	>	static PyObject _wrap_BossSession_makeBossTask(PyObject self, PyObject *args) {
2435		PyObject *resultobj;
2436		BossSession arg1 = (BossSession ) 0 ;
2437	<	std::string *arg2 = 0 ;
2438	<	std::string *arg3 = 0 ;
2439	<	std::string const &arg4_defvalue = "" ;
2325	<	std::string arg4 = (std::string ) &arg4_defvalue ;
2326	<	std::string const &arg5_defvalue = "" ;
2327	<	std::string arg5 = (std::string ) &arg5_defvalue ;
2328	<	bool arg6 = (bool) false ;
2329	<	PyObject *result;
2437	>	std::string const &arg2_defvalue = "" ;
2438	>	std::string arg2 = (std::string ) &arg2_defvalue ;
2439	>	BossTask *result;
2440		std::string temp2 ;
2331	–	std::string temp3 ;
2332	–	std::string temp4 ;
2333	–	std::string temp5 ;
2441		PyObject * obj0 = 0 ;
2442		PyObject * obj1 = 0 ;
2336	–	PyObject * obj2 = 0 ;
2337	–	PyObject * obj3 = 0 ;
2338	–	PyObject * obj4 = 0 ;
2339	–	PyObject * obj5 = 0 ;
2443
2444	<	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2444	>	if(!PyArg_ParseTuple(args,(char *)"O\|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2445		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2446	<	{
2344	<	if (PyString_Check(obj1)) {
2345	<	temp2 = std::string(PyString_AsString(obj1));
2346	<	arg2 = &temp2;
2347	<	}else {
2348	<	SWIG_exception(SWIG_TypeError, "string expected");
2349	<	}
2350	<	}
2351	<	{
2352	<	if (PyString_Check(obj2)) {
2353	<	temp3 = std::string(PyString_AsString(obj2));
2354	<	arg3 = &temp3;
2355	<	}else {
2356	<	SWIG_exception(SWIG_TypeError, "string expected");
2357	<	}
2358	<	}
2359	<	if (obj3) {
2360	<	{
2361	<	if (PyString_Check(obj3)) {
2362	<	temp4 = std::string(PyString_AsString(obj3));
2363	<	arg4 = &temp4;
2364	<	}else {
2365	<	SWIG_exception(SWIG_TypeError, "string expected");
2366	<	}
2367	<	}
2368	<	}
2369	<	if (obj4) {
2446	>	if (obj1) {
2447		{
2448	<	if (PyString_Check(obj4)) {
2449	<	temp5 = std::string(PyString_AsString(obj4));
2450	<	arg5 = &temp5;
2448	>	if (PyString_Check(obj1)) {
2449	>	temp2 = std::string(PyString_AsString(obj1));
2450	>	arg2 = &temp2;
2451		}else {
2452		SWIG_exception(SWIG_TypeError, "string expected");
2453		}
2454		}
2455		}
2379	–	if (obj5) {
2380	–	arg6 = PyInt_AsLong(obj5) ? true : false;
2381	–	if (PyErr_Occurred()) SWIG_fail;
2382	–	}
2456		{
2457		try {
2458	<	result = (PyObject )BossSession_schedListMatch(arg1,(std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6);
2458	>	result = (BossTask )(arg1)->makeBossTask((std::string const &)arg2);
2459
2460	+	}catch (const BossSchedFailure & e) {
2461	+	PyErr_SetString ( SchedulerError, e.what() );
2462	+	return NULL;
2463		}catch (const std::exception& e) {
2464	<	SWIG_exception(SWIG_RuntimeError, e.what());
2464	>	PyErr_SetString ( BossError, e.what() );
2465	>	return NULL;
2466		}
2467		}
2468	<	resultobj = result;
2468	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2469		return resultobj;
2470		fail:
2471		return NULL;
2472		}
2473
2474
2475	<	static PyObject _wrap_BossSession_queryTasks(PyObject self, PyObject *args) {
2475	>	static PyObject _wrap_BossSession_destroyBossTask(PyObject self, PyObject *args) {
2476		PyObject *resultobj;
2477		BossSession arg1 = (BossSession ) 0 ;
2478	<	int arg2 = (int) SCHEDULED ;
2402	<	std::string const &arg3_defvalue = "all" ;
2403	<	std::string arg3 = (std::string ) &arg3_defvalue ;
2404	<	std::string const &arg4_defvalue = "all" ;
2405	<	std::string arg4 = (std::string ) &arg4_defvalue ;
2406	<	std::string const &arg5_defvalue = "" ;
2407	<	std::string arg5 = (std::string ) &arg5_defvalue ;
2408	<	std::string arg6 = (std::string) "" ;
2409	<	std::string arg7 = (std::string) "" ;
2410	<	std::string arg8 = (std::string) "" ;
2411	<	std::string arg9 = (std::string) "" ;
2412	<	bool arg10 = (bool) false ;
2413	<	PyObject *result;
2414	<	std::string temp3 ;
2415	<	std::string temp4 ;
2416	<	std::string temp5 ;
2478	>	BossTask arg2 = (BossTask ) 0 ;
2479		PyObject * obj0 = 0 ;
2480	<	PyObject * obj2 = 0 ;
2419	<	PyObject * obj3 = 0 ;
2420	<	PyObject * obj4 = 0 ;
2421	<	PyObject * obj5 = 0 ;
2422	<	PyObject * obj6 = 0 ;
2423	<	PyObject * obj7 = 0 ;
2424	<	PyObject * obj8 = 0 ;
2425	<	PyObject * obj9 = 0 ;
2480	>	PyObject * obj1 = 0 ;
2481
2482	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2482	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2483		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2484	<	if (obj2) {
2430	<	{
2431	<	if (PyString_Check(obj2)) {
2432	<	temp3 = std::string(PyString_AsString(obj2));
2433	<	arg3 = &temp3;
2434	<	}else {
2435	<	SWIG_exception(SWIG_TypeError, "string expected");
2436	<	}
2437	<	}
2438	<	}
2439	<	if (obj3) {
2440	<	{
2441	<	if (PyString_Check(obj3)) {
2442	<	temp4 = std::string(PyString_AsString(obj3));
2443	<	arg4 = &temp4;
2444	<	}else {
2445	<	SWIG_exception(SWIG_TypeError, "string expected");
2446	<	}
2447	<	}
2448	<	}
2449	<	if (obj4) {
2450	<	{
2451	<	if (PyString_Check(obj4)) {
2452	<	temp5 = std::string(PyString_AsString(obj4));
2453	<	arg5 = &temp5;
2454	<	}else {
2455	<	SWIG_exception(SWIG_TypeError, "string expected");
2456	<	}
2457	<	}
2458	<	}
2459	<	if (obj5) {
2460	<	{
2461	<	if (PyString_Check(obj5))
2462	<	arg6 = std::string(PyString_AsString(obj5));
2463	<	else
2464	<	SWIG_exception(SWIG_TypeError, "string expected");
2465	<	}
2466	<	}
2467	<	if (obj6) {
2468	<	{
2469	<	if (PyString_Check(obj6))
2470	<	arg7 = std::string(PyString_AsString(obj6));
2471	<	else
2472	<	SWIG_exception(SWIG_TypeError, "string expected");
2473	<	}
2474	<	}
2475	<	if (obj7) {
2476	<	{
2477	<	if (PyString_Check(obj7))
2478	<	arg8 = std::string(PyString_AsString(obj7));
2479	<	else
2480	<	SWIG_exception(SWIG_TypeError, "string expected");
2481	<	}
2482	<	}
2483	<	if (obj8) {
2484	<	{
2485	<	if (PyString_Check(obj8))
2486	<	arg9 = std::string(PyString_AsString(obj8));
2487	<	else
2488	<	SWIG_exception(SWIG_TypeError, "string expected");
2489	<	}
2490	<	}
2491	<	if (obj9) {
2492	<	arg10 = PyInt_AsLong(obj9) ? true : false;
2493	<	if (PyErr_Occurred()) SWIG_fail;
2494	<	}
2495	<	{
2496	<	try {
2497	<	result = (PyObject )BossSession_queryTasks(arg1,arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5,arg6,arg7,arg8,arg9,arg10);
2498	<
2499	<	}catch (const std::exception& e) {
2500	<	SWIG_exception(SWIG_RuntimeError, e.what());
2501	<	}
2502	<	}
2503	<	resultobj = result;
2504	<	return resultobj;
2505	<	fail:
2506	<	return NULL;
2507	<	}
2508	<
2509	<
2510	<	static PyObject _wrap_new_BossSession(PyObject self, PyObject *args) {
2511	<	PyObject *resultobj;
2512	<	std::string arg1 = (std::string) "" ;
2513	<	BossSession *result;
2514	<	PyObject * obj0 = 0 ;
2515	<
2516	<	if(!PyArg_ParseTuple(args,(char *)"\|O:new_BossSession",&obj0)) goto fail;
2517	<	if (obj0) {
2518	<	{
2519	<	if (PyString_Check(obj0))
2520	<	arg1 = std::string(PyString_AsString(obj0));
2521	<	else
2522	<	SWIG_exception(SWIG_TypeError, "string expected");
2523	<	}
2524	<	}
2484	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2485		{
2486		try {
2487	<	result = (BossSession *)new BossSession(arg1);
2487	>	(arg1)->destroyBossTask(arg2);
2488
2489	+	}catch (const BossSchedFailure & e) {
2490	+	PyErr_SetString ( SchedulerError, e.what() );
2491	+	return NULL;
2492		}catch (const std::exception& e) {
2493	<	SWIG_exception(SWIG_RuntimeError, e.what());
2493	>	PyErr_SetString ( BossError, e.what() );
2494	>	return NULL;
2495		}
2496		}
2497	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2497	>	Py_INCREF(Py_None); resultobj = Py_None;
2498		return resultobj;
2499		fail:
2500		return NULL;
2501		}
2502
2503
2504	<	static PyObject _wrap_delete_BossSession(PyObject self, PyObject *args) {
2504	>	static PyObject _wrap_BossSession_showCHTools(PyObject self, PyObject *args) {
2505		PyObject *resultobj;
2506		BossSession arg1 = (BossSession ) 0 ;
2507	+	std::vector<std::string > result;
2508		PyObject * obj0 = 0 ;
2509
2510	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2510	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2511		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2512		{
2513		try {
2514	<	delete arg1;
2514	>	result = (arg1)->showCHTools();
2515
2516	+	}catch (const BossSchedFailure & e) {
2517	+	PyErr_SetString ( SchedulerError, e.what() );
2518	+	return NULL;
2519		}catch (const std::exception& e) {
2520	<	SWIG_exception(SWIG_RuntimeError, e.what());
2520	>	PyErr_SetString ( BossError, e.what() );
2521	>	return NULL;
2522		}
2523		}
2524	<	Py_INCREF(Py_None); resultobj = Py_None;
2524	>	{
2525	>	resultobj = PyTuple_New((&result)->size());
2526	>	for (unsigned int i=0; i<(&result)->size(); i++)
2527	>	PyTuple_SetItem(resultobj,i,
2528	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2529	>	}
2530		return resultobj;
2531		fail:
2532		return NULL;
2533		}
2534
2535
2536	<	static PyObject _wrap_BossSession_clear(PyObject self, PyObject *args) {
2536	>	static PyObject _wrap_BossSession_showProgramTypes(PyObject self, PyObject *args) {
2537		PyObject *resultobj;
2538		BossSession arg1 = (BossSession ) 0 ;
2539	+	std::vector<std::string > result;
2540		PyObject * obj0 = 0 ;
2541
2542	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2542	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2543		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2544		{
2545		try {
2546	<	(arg1)->clear();
2546	>	result = (arg1)->showProgramTypes();
2547
2548	+	}catch (const BossSchedFailure & e) {
2549	+	PyErr_SetString ( SchedulerError, e.what() );
2550	+	return NULL;
2551		}catch (const std::exception& e) {
2552	<	SWIG_exception(SWIG_RuntimeError, e.what());
2552	>	PyErr_SetString ( BossError, e.what() );
2553	>	return NULL;
2554		}
2555		}
2556	<	Py_INCREF(Py_None); resultobj = Py_None;
2556	>	{
2557	>	resultobj = PyTuple_New((&result)->size());
2558	>	for (unsigned int i=0; i<(&result)->size(); i++)
2559	>	PyTuple_SetItem(resultobj,i,
2560	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2561	>	}
2562		return resultobj;
2563		fail:
2564		return NULL;
2565		}
2566
2567
2568	<	static PyObject _wrap_BossSession_makeBossTask(PyObject self, PyObject *args) {
2568	>	static PyObject _wrap_BossSession_showRTMon(PyObject self, PyObject *args) {
2569		PyObject *resultobj;
2570		BossSession arg1 = (BossSession ) 0 ;
2571	<	std::string const &arg2_defvalue = "" ;
2588	<	std::string arg2 = (std::string ) &arg2_defvalue ;
2589	<	BossTask *result;
2590	<	std::string temp2 ;
2571	>	std::vector<std::string > result;
2572		PyObject * obj0 = 0 ;
2592	–	PyObject * obj1 = 0 ;
2573
2574	<	if(!PyArg_ParseTuple(args,(char *)"O\|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2574	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2575		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2596	–	if (obj1) {
2597	–	{
2598	–	if (PyString_Check(obj1)) {
2599	–	temp2 = std::string(PyString_AsString(obj1));
2600	–	arg2 = &temp2;
2601	–	}else {
2602	–	SWIG_exception(SWIG_TypeError, "string expected");
2603	–	}
2604	–	}
2605	–	}
2576		{
2577		try {
2578	<	result = (BossTask )(arg1)->makeBossTask((std::string const &)arg2);
2578	>	result = (arg1)->showRTMon();
2579
2580	+	}catch (const BossSchedFailure & e) {
2581	+	PyErr_SetString ( SchedulerError, e.what() );
2582	+	return NULL;
2583		}catch (const std::exception& e) {
2584	<	SWIG_exception(SWIG_RuntimeError, e.what());
2584	>	PyErr_SetString ( BossError, e.what() );
2585	>	return NULL;
2586		}
2587		}
2588	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2588	>	{
2589	>	resultobj = PyTuple_New((&result)->size());
2590	>	for (unsigned int i=0; i<(&result)->size(); i++)
2591	>	PyTuple_SetItem(resultobj,i,
2592	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2593	>	}
2594		return resultobj;
2595		fail:
2596		return NULL;
2597		}
2598
2599
2600	<	static PyObject _wrap_BossSession_destroyBossTask(PyObject self, PyObject *args) {
2600	>	static PyObject _wrap_BossSession_showSchedulers(PyObject self, PyObject *args) {
2601		PyObject *resultobj;
2602		BossSession arg1 = (BossSession ) 0 ;
2603	<	BossTask arg2 = (BossTask ) 0 ;
2603	>	std::vector<std::string > result;
2604		PyObject * obj0 = 0 ;
2626	–	PyObject * obj1 = 0 ;
2605
2606	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2606	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2607		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2630	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2608		{
2609		try {
2610	<	(arg1)->destroyBossTask(arg2);
2610	>	result = (arg1)->showSchedulers();
2611
2612	+	}catch (const BossSchedFailure & e) {
2613	+	PyErr_SetString ( SchedulerError, e.what() );
2614	+	return NULL;
2615		}catch (const std::exception& e) {
2616	<	SWIG_exception(SWIG_RuntimeError, e.what());
2616	>	PyErr_SetString ( BossError, e.what() );
2617	>	return NULL;
2618		}
2619		}
2620	<	Py_INCREF(Py_None); resultobj = Py_None;
2620	>	{
2621	>	resultobj = PyTuple_New((&result)->size());
2622	>	for (unsigned int i=0; i<(&result)->size(); i++)
2623	>	PyTuple_SetItem(resultobj,i,
2624	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2625	>	}
2626		return resultobj;
2627		fail:
2628		return NULL;
#	Line 2655 \| Line 2641 \| *static PyObject _wrap_BossSession_defau**
2641		try {
2642		result = (arg1)->defaultCHTool();
2643
2644	+	}catch (const BossSchedFailure & e) {
2645	+	PyErr_SetString ( SchedulerError, e.what() );
2646	+	return NULL;
2647		}catch (const std::exception& e) {
2648	<	SWIG_exception(SWIG_RuntimeError, e.what());
2648	>	PyErr_SetString ( BossError, e.what() );
2649	>	return NULL;
2650		}
2651		}
2652		{
#	Line 2680 \| Line 2670 \| *static PyObject _wrap_BossSession_defau**
2670		try {
2671		result = (arg1)->defaultProgramType();
2672
2673	+	}catch (const BossSchedFailure & e) {
2674	+	PyErr_SetString ( SchedulerError, e.what() );
2675	+	return NULL;
2676		}catch (const std::exception& e) {
2677	<	SWIG_exception(SWIG_RuntimeError, e.what());
2677	>	PyErr_SetString ( BossError, e.what() );
2678	>	return NULL;
2679		}
2680		}
2681		{
#	Line 2705 \| Line 2699 \| *static PyObject _wrap_BossSession_defau**
2699		try {
2700		result = (arg1)->defaultRTMon();
2701
2702	+	}catch (const BossSchedFailure & e) {
2703	+	PyErr_SetString ( SchedulerError, e.what() );
2704	+	return NULL;
2705		}catch (const std::exception& e) {
2706	<	SWIG_exception(SWIG_RuntimeError, e.what());
2706	>	PyErr_SetString ( BossError, e.what() );
2707	>	return NULL;
2708		}
2709		}
2710		{
#	Line 2730 \| Line 2728 \| *static PyObject _wrap_BossSession_defau**
2728		try {
2729		result = (arg1)->defaultScheduler();
2730
2731	+	}catch (const BossSchedFailure & e) {
2732	+	PyErr_SetString ( SchedulerError, e.what() );
2733	+	return NULL;
2734		}catch (const std::exception& e) {
2735	<	SWIG_exception(SWIG_RuntimeError, e.what());
2735	>	PyErr_SetString ( BossError, e.what() );
2736	>	return NULL;
2737		}
2738		}
2739		{
#	Line 2755 \| Line 2757 \| *static PyObject _wrap_BossSession_versi**
2757		try {
2758		result = (arg1)->version();
2759
2760	+	}catch (const BossSchedFailure & e) {
2761	+	PyErr_SetString ( SchedulerError, e.what() );
2762	+	return NULL;
2763		}catch (const std::exception& e) {
2764	<	SWIG_exception(SWIG_RuntimeError, e.what());
2764	>	PyErr_SetString ( BossError, e.what() );
2765	>	return NULL;
2766		}
2767		}
2768		{
#	Line 2780 \| Line 2786 \| *static PyObject _wrap_BossSession_clien**
2786		try {
2787		result = (arg1)->clientID();
2788
2789	+	}catch (const BossSchedFailure & e) {
2790	+	PyErr_SetString ( SchedulerError, e.what() );
2791	+	return NULL;
2792		}catch (const std::exception& e) {
2793	<	SWIG_exception(SWIG_RuntimeError, e.what());
2793	>	PyErr_SetString ( BossError, e.what() );
2794	>	return NULL;
2795		}
2796		}
2797		{
#	Line 2811 \| Line 2821 \| *static PyObject _wrap_BossSession_showC**
2821		try {
2822		result = (int)(arg1)->showConfigs(arg2);
2823
2824	+	}catch (const BossSchedFailure & e) {
2825	+	PyErr_SetString ( SchedulerError, e.what() );
2826	+	return NULL;
2827		}catch (const std::exception& e) {
2828	<	SWIG_exception(SWIG_RuntimeError, e.what());
2828	>	PyErr_SetString ( BossError, e.what() );
2829	>	return NULL;
2830		}
2831		}
2832		resultobj = PyInt_FromLong((long)result);
#	Line 2864 \| Line 2878 \| *static PyObject _wrap_BossSession_RTupd**
2878		try {
2879		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2880
2881	+	}catch (const BossSchedFailure & e) {
2882	+	PyErr_SetString ( SchedulerError, e.what() );
2883	+	return NULL;
2884		}catch (const std::exception& e) {
2885	<	SWIG_exception(SWIG_RuntimeError, e.what());
2885	>	PyErr_SetString ( BossError, e.what() );
2886	>	return NULL;
2887		}
2888		}
2889		resultobj = PyInt_FromLong((long)result);
#	Line 2885 \| Line 2903 \| *static PyObject _wrap_BossSession_listM**
2903		std::string arg5 = (std::string ) &arg5_defvalue ;
2904		std::string const &arg6_defvalue = "" ;
2905		std::string arg6 = (std::string ) &arg6_defvalue ;
2906	+	unsigned int arg7 = (unsigned int) 0 ;
2907		std::vector<std::string > result;
2908		std::string temp2 ;
2909		std::string temp3 ;
#	Line 2896 \| Line 2915 \| *static PyObject _wrap_BossSession_listM**
2915		PyObject * obj3 = 0 ;
2916		PyObject * obj4 = 0 ;
2917		PyObject * obj5 = 0 ;
2918	+	PyObject * obj6 = 0 ;
2919
2920	<	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2920	>	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2921		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2922		{
2923		if (PyString_Check(obj1)) {
#	Line 2939 \| Line 2959 \| *static PyObject _wrap_BossSession_listM**
2959		}
2960		}
2961		}
2962	+	if (obj6) {
2963	+	arg7 = (unsigned int) PyInt_AsLong(obj6);
2964	+	if (PyErr_Occurred()) SWIG_fail;
2965	+	}
2966		{
2967		try {
2968	<	result = (arg1)->listMatch((std::string const &)arg2,(std::string const &)arg3,arg4,(std::string const &)arg5,(std::string const &)arg6);
2968	>	result = (arg1)->listMatch((std::string const &)arg2,(std::string const &)arg3,arg4,(std::string const &)arg5,(std::string const &)arg6,arg7);
2969
2970	+	}catch (const BossSchedFailure & e) {
2971	+	PyErr_SetString ( SchedulerError, e.what() );
2972	+	return NULL;
2973		}catch (const std::exception& e) {
2974	<	SWIG_exception(SWIG_RuntimeError, e.what());
2974	>	PyErr_SetString ( BossError, e.what() );
2975	>	return NULL;
2976		}
2977		}
2978		{
#	Line 2973 \| Line 3001 \| *static PyObject _wrap_BossSession_sched**
3001		std::string arg7 = (std::string) "" ;
3002		std::string arg8 = (std::string) "" ;
3003		std::string arg9 = (std::string) "" ;
3004	+	unsigned int arg10 = (unsigned int) 0 ;
3005		std::string temp3 ;
3006		std::string temp4 ;
3007		std::string temp5 ;
#	Line 2984 \| Line 3013 \| *static PyObject _wrap_BossSession_sched**
3013		PyObject * obj6 = 0 ;
3014		PyObject * obj7 = 0 ;
3015		PyObject * obj8 = 0 ;
3016	+	PyObject * obj9 = 0 ;
3017
3018	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3018	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3019		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3020		if (obj2) {
3021		{
#	Line 3049 \| Line 3079 \| *static PyObject _wrap_BossSession_sched**
3079		SWIG_exception(SWIG_TypeError, "string expected");
3080		}
3081		}
3082	+	if (obj9) {
3083	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3084	+	if (PyErr_Occurred()) SWIG_fail;
3085	+	}
3086		{
3087		try {
3088	<	(arg1)->schedulerQuery(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3088	>	(arg1)->schedulerQuery(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3089
3090	+	}catch (const BossSchedFailure & e) {
3091	+	PyErr_SetString ( SchedulerError, e.what() );
3092	+	return NULL;
3093		}catch (const std::exception& e) {
3094	<	SWIG_exception(SWIG_RuntimeError, e.what());
3094	>	PyErr_SetString ( BossError, e.what() );
3095	>	return NULL;
3096		}
3097		}
3098		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3132 \| Line 3170 \| *static PyObject _wrap_BossSession_selec**
3170		try {
3171		result = (arg1)->selectTasks((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5);
3172
3173	+	}catch (const BossSchedFailure & e) {
3174	+	PyErr_SetString ( SchedulerError, e.what() );
3175	+	return NULL;
3176	+	}catch (const std::exception& e) {
3177	+	PyErr_SetString ( BossError, e.what() );
3178	+	return NULL;
3179	+	}
3180	+	}
3181	+	{
3182	+	resultobj = PyTuple_New((&result)->size());
3183	+	for (unsigned int i=0; i<(&result)->size(); i++)
3184	+	PyTuple_SetItem(resultobj,i,
3185	+	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3186	+	}
3187	+	return resultobj;
3188	+	fail:
3189	+	return NULL;
3190	+	}
3191	+
3192	+
3193	+	static PyObject _wrap_BossSession_selectTasksByName(PyObject self, PyObject *args) {
3194	+	PyObject *resultobj;
3195	+	BossSession arg1 = (BossSession ) 0 ;
3196	+	std::string *arg2 = 0 ;
3197	+	std::vector<std::string > result;
3198	+	std::string temp2 ;
3199	+	PyObject * obj0 = 0 ;
3200	+	PyObject * obj1 = 0 ;
3201	+
3202	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3203	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3204	+	{
3205	+	if (PyString_Check(obj1)) {
3206	+	temp2 = std::string(PyString_AsString(obj1));
3207	+	arg2 = &temp2;
3208	+	}else {
3209	+	SWIG_exception(SWIG_TypeError, "string expected");
3210	+	}
3211	+	}
3212	+	{
3213	+	try {
3214	+	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3215	+
3216	+	}catch (const BossSchedFailure & e) {
3217	+	PyErr_SetString ( SchedulerError, e.what() );
3218	+	return NULL;
3219		}catch (const std::exception& e) {
3220	<	SWIG_exception(SWIG_RuntimeError, e.what());
3220	>	PyErr_SetString ( BossError, e.what() );
3221	>	return NULL;
3222		}
3223		}
3224		{
#	Line 3162 \| Line 3247 \| *static PyObject _wrap_BossSession_query**
3247		std::string arg7 = (std::string) "" ;
3248		std::string arg8 = (std::string) "" ;
3249		std::string arg9 = (std::string) "" ;
3250	<	bool arg10 = (bool) false ;
3250	>	unsigned int arg10 = (unsigned int) 0 ;
3251	>	bool arg11 = (bool) false ;
3252		SwigValueWrapper< std::vector<BossTask * > > result;
3253		std::string temp3 ;
3254		std::string temp4 ;
#	Line 3176 \| Line 3262 \| *static PyObject _wrap_BossSession_query**
3262		PyObject * obj7 = 0 ;
3263		PyObject * obj8 = 0 ;
3264		PyObject * obj9 = 0 ;
3265	+	PyObject * obj10 = 0 ;
3266
3267	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3267	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3268		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3269		if (obj2) {
3270		{
#	Line 3242 \| Line 3329 \| *static PyObject _wrap_BossSession_query**
3329		}
3330		}
3331		if (obj9) {
3332	<	arg10 = PyInt_AsLong(obj9) ? true : false;
3332	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3333	>	if (PyErr_Occurred()) SWIG_fail;
3334	>	}
3335	>	if (obj10) {
3336	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3337		if (PyErr_Occurred()) SWIG_fail;
3338		}
3339		{
3340		try {
3341	<	result = (arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3341	>	result = (arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3342
3343	+	}catch (const BossSchedFailure & e) {
3344	+	PyErr_SetString ( SchedulerError, e.what() );
3345	+	return NULL;
3346		}catch (const std::exception& e) {
3347	<	SWIG_exception(SWIG_RuntimeError, e.what());
3347	>	PyErr_SetString ( BossError, e.what() );
3348	>	return NULL;
3349		}
3350		}
3351		{
#	Line 3264 \| Line 3359 \| *static PyObject _wrap_BossSession_query**
3359		}
3360
3361
3362	<	static PyObject * BossSession_swigregister(PyObject self, PyObject args) {
3268	<	PyObject *obj;
3269	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3270	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3271	<	Py_INCREF(obj);
3272	<	return Py_BuildValue((char *)"");
3273	<	}
3274	<	static PyObject _wrap_BossTaskException_key_set(PyObject self, PyObject *args) {
3362	>	static PyObject _wrap_BossSession_getTasksByName(PyObject self, PyObject *args) {
3363		PyObject *resultobj;
3364	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3365	<	char *arg2 ;
3364	>	BossSession arg1 = (BossSession ) 0 ;
3365	>	std::string *arg2 = 0 ;
3366	>	SwigValueWrapper< std::vector<BossTask * > > result;
3367	>	std::string temp2 ;
3368		PyObject * obj0 = 0 ;
3369	+	PyObject * obj1 = 0 ;
3370
3371	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3372	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3371	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3372	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3373		{
3374	<	if (arg2) {
3375	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3376	<	strcpy((char *) arg1->key,arg2);
3374	>	if (PyString_Check(obj1)) {
3375	>	temp2 = std::string(PyString_AsString(obj1));
3376	>	arg2 = &temp2;
3377		}else {
3378	<	arg1->key = 0;
3378	>	SWIG_exception(SWIG_TypeError, "string expected");
3379		}
3380		}
3381	<	Py_INCREF(Py_None); resultobj = Py_None;
3381	>	{
3382	>	try {
3383	>	result = (arg1)->getTasksByName((std::string const &)*arg2);
3384	>
3385	>	}catch (const BossSchedFailure & e) {
3386	>	PyErr_SetString ( SchedulerError, e.what() );
3387	>	return NULL;
3388	>	}catch (const std::exception& e) {
3389	>	PyErr_SetString ( BossError, e.what() );
3390	>	return NULL;
3391	>	}
3392	>	}
3393	>	{
3394	>	std::vector<BossTask * > * resultptr;
3395	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3396	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3397	>	}
3398		return resultobj;
3399		fail:
3400		return NULL;
3401		}
3402
3403
3404	<	static PyObject _wrap_BossTaskException_key_get(PyObject self, PyObject *args) {
3404	>	static PyObject _wrap_BossSession_show(PyObject self, PyObject *args) {
3405		PyObject *resultobj;
3406	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3407	<	char *result;
3406	>	BossSession arg1 = (BossSession ) 0 ;
3407	>	std::vector<std::string > *arg2 = 0 ;
3408	>	PyObject *result;
3409		PyObject * obj0 = 0 ;
3410	+	PyObject * obj1 = 0 ;
3411
3412	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3413	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3414	<	result = (char *) ((arg1)->key);
3415	<
3416	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3412	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3413	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3414	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3415	>	if (arg2 == NULL) {
3416	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3417	>	}
3418	>	{
3419	>	try {
3420	>	result = (PyObject )BossSession_show(arg1,arg2);
3421	>
3422	>	}catch (const BossSchedFailure & e) {
3423	>	PyErr_SetString ( SchedulerError, e.what() );
3424	>	return NULL;
3425	>	}catch (const std::exception& e) {
3426	>	PyErr_SetString ( BossError, e.what() );
3427	>	return NULL;
3428	>	}
3429	>	}
3430	>	resultobj = result;
3431		return resultobj;
3432		fail:
3433		return NULL;
3434		}
3435
3436
3437	<	static PyObject _wrap_new_BossTaskException(PyObject self, PyObject *args) {
3437	>	static PyObject _wrap_BossSession_CHTools(PyObject self, PyObject *args) {
3438		PyObject *resultobj;
3439	<	char *arg1 ;
3440	<	BossTaskException *result;
3439	>	BossSession arg1 = (BossSession ) 0 ;
3440	>	PyObject *result;
3441	>	PyObject * obj0 = 0 ;
3442
3443	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3443	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3444	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3445		{
3446		try {
3447	<	result = (BossTaskException )new BossTaskException((char const )arg1);
3447	>	result = (PyObject *)BossSession_CHTools(arg1);
3448
3449	+	}catch (const BossSchedFailure & e) {
3450	+	PyErr_SetString ( SchedulerError, e.what() );
3451	+	return NULL;
3452		}catch (const std::exception& e) {
3453	<	SWIG_exception(SWIG_RuntimeError, e.what());
3453	>	PyErr_SetString ( BossError, e.what() );
3454	>	return NULL;
3455		}
3456		}
3457	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3457	>	resultobj = result;
3458		return resultobj;
3459		fail:
3460		return NULL;
3461		}
3462
3463
3464	<	static PyObject _wrap_BossTaskException_what(PyObject self, PyObject *args) {
3464	>	static PyObject _wrap_BossSession_ProgramTypes(PyObject self, PyObject *args) {
3465		PyObject *resultobj;
3466	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3467	<	char *result;
3466	>	BossSession arg1 = (BossSession ) 0 ;
3467	>	PyObject *result;
3468		PyObject * obj0 = 0 ;
3469
3470	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3471	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3470	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3471	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3472		{
3473		try {
3474	<	result = (char )((BossTaskException const )arg1)->what();
3474	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3475
3476	+	}catch (const BossSchedFailure & e) {
3477	+	PyErr_SetString ( SchedulerError, e.what() );
3478	+	return NULL;
3479		}catch (const std::exception& e) {
3480	<	SWIG_exception(SWIG_RuntimeError, e.what());
3480	>	PyErr_SetString ( BossError, e.what() );
3481	>	return NULL;
3482		}
3483		}
3484	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3484	>	resultobj = result;
3485		return resultobj;
3486		fail:
3487		return NULL;
3488		}
3489
3490
3491	<	static PyObject _wrap_delete_BossTaskException(PyObject self, PyObject *args) {
3491	>	static PyObject _wrap_BossSession_RTMons(PyObject self, PyObject *args) {
3492		PyObject *resultobj;
3493	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3493	>	BossSession arg1 = (BossSession ) 0 ;
3494	>	PyObject *result;
3495		PyObject * obj0 = 0 ;
3496
3497	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3498	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3497	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3498	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3499		{
3500		try {
3501	<	delete arg1;
3501	>	result = (PyObject *)BossSession_RTMons(arg1);
3502
3503	+	}catch (const BossSchedFailure & e) {
3504	+	PyErr_SetString ( SchedulerError, e.what() );
3505	+	return NULL;
3506		}catch (const std::exception& e) {
3507	<	SWIG_exception(SWIG_RuntimeError, e.what());
3507	>	PyErr_SetString ( BossError, e.what() );
3508	>	return NULL;
3509		}
3510		}
3511	<	Py_INCREF(Py_None); resultobj = Py_None;
3511	>	resultobj = result;
3512		return resultobj;
3513		fail:
3514		return NULL;
3515		}
3516
3517
3518	<	static PyObject * BossTaskException_swigregister(PyObject self, PyObject args) {
3381	<	PyObject *obj;
3382	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3383	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3384	<	Py_INCREF(obj);
3385	<	return Py_BuildValue((char *)"");
3386	<	}
3387	<	static PyObject _wrap_BossTask_appendToPyDict(PyObject self, PyObject *args) {
3518	>	static PyObject _wrap_BossSession_schedulers(PyObject self, PyObject *args) {
3519		PyObject *resultobj;
3520	<	BossTask arg1 = (BossTask ) 0 ;
3390	<	PyObject arg2 = (PyObject ) 0 ;
3391	<	BossAttributeContainer *arg3 = 0 ;
3520	>	BossSession arg1 = (BossSession ) 0 ;
3521		PyObject *result;
3522		PyObject * obj0 = 0 ;
3394	–	PyObject * obj1 = 0 ;
3395	–	PyObject * obj2 = 0 ;
3523
3524	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3525	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3399	<	arg2 = obj1;
3400	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3401	<	if (arg3 == NULL) {
3402	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3403	<	}
3524	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3525	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3526		{
3527		try {
3528	<	result = (PyObject )BossTask_appendToPyDict((BossTask const )arg1,arg2,(BossAttributeContainer const &)*arg3);
3528	>	result = (PyObject *)BossSession_schedulers(arg1);
3529
3530	+	}catch (const BossSchedFailure & e) {
3531	+	PyErr_SetString ( SchedulerError, e.what() );
3532	+	return NULL;
3533		}catch (const std::exception& e) {
3534	<	SWIG_exception(SWIG_RuntimeError, e.what());
3534	>	PyErr_SetString ( BossError, e.what() );
3535	>	return NULL;
3536		}
3537		}
3538		resultobj = result;
#	Line 3416 \| Line 3542 \| *static PyObject _wrap_BossTask_appendTo**
3542		}
3543
3544
3545	<	static PyObject _wrap_BossTask_jobDict(PyObject self, PyObject *args) {
3545	>	static PyObject _wrap_BossSession_schedListMatch(PyObject self, PyObject *args) {
3546		PyObject *resultobj;
3547	<	BossTask arg1 = (BossTask ) 0 ;
3548	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3547	>	BossSession arg1 = (BossSession ) 0 ;
3548	>	std::string *arg2 = 0 ;
3549	>	std::string *arg3 = 0 ;
3550	>	std::string const &arg4_defvalue = "" ;
3551	>	std::string arg4 = (std::string ) &arg4_defvalue ;
3552	>	std::string const &arg5_defvalue = "" ;
3553	>	std::string arg5 = (std::string ) &arg5_defvalue ;
3554	>	unsigned int arg6 = (unsigned int) 0 ;
3555	>	bool arg7 = (bool) false ;
3556		PyObject *result;
3557	+	std::string temp2 ;
3558	+	std::string temp3 ;
3559	+	std::string temp4 ;
3560	+	std::string temp5 ;
3561		PyObject * obj0 = 0 ;
3562		PyObject * obj1 = 0 ;
3563	+	PyObject * obj2 = 0 ;
3564	+	PyObject * obj3 = 0 ;
3565	+	PyObject * obj4 = 0 ;
3566	+	PyObject * obj5 = 0 ;
3567	+	PyObject * obj6 = 0 ;
3568
3569	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3570	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3571	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3572	<	if (arg2 == NULL) {
3573	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3569	>	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3570	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3571	>	{
3572	>	if (PyString_Check(obj1)) {
3573	>	temp2 = std::string(PyString_AsString(obj1));
3574	>	arg2 = &temp2;
3575	>	}else {
3576	>	SWIG_exception(SWIG_TypeError, "string expected");
3577	>	}
3578	>	}
3579	>	{
3580	>	if (PyString_Check(obj2)) {
3581	>	temp3 = std::string(PyString_AsString(obj2));
3582	>	arg3 = &temp3;
3583	>	}else {
3584	>	SWIG_exception(SWIG_TypeError, "string expected");
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	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3609	>	if (PyErr_Occurred()) SWIG_fail;
3610	>	}
3611	>	if (obj6) {
3612	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3613	>	if (PyErr_Occurred()) SWIG_fail;
3614		}
3615		{
3616		try {
3617	<	result = (PyObject )BossTask_jobDict((BossTask const )arg1,*arg2);
3617	>	result = (PyObject )BossSession_schedListMatch(arg1,(std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7);
3618
3619	+	}catch (const BossSchedFailure & e) {
3620	+	PyErr_SetString ( SchedulerError, e.what() );
3621	+	return NULL;
3622		}catch (const std::exception& e) {
3623	<	SWIG_exception(SWIG_RuntimeError, e.what());
3623	>	PyErr_SetString ( BossError, e.what() );
3624	>	return NULL;
3625		}
3626		}
3627		resultobj = result;
#	Line 3445 \| Line 3631 \| *static PyObject _wrap_BossTask_jobDict(**
3631		}
3632
3633
3634	<	static PyObject _wrap_BossTask_jobsDict(PyObject self, PyObject *args) {
3634	>	static PyObject _wrap_BossSession_queryTasks(PyObject self, PyObject *args) {
3635		PyObject *resultobj;
3636	<	BossTask arg1 = (BossTask ) 0 ;
3636	>	BossSession arg1 = (BossSession ) 0 ;
3637	>	std::string const &arg2_defvalue = "" ;
3638	>	std::string arg2 = (std::string ) &arg2_defvalue ;
3639	>	std::string const &arg3_defvalue = "all" ;
3640	>	std::string arg3 = (std::string ) &arg3_defvalue ;
3641	>	std::string arg4 = (std::string) "" ;
3642	>	std::string arg5 = (std::string) "" ;
3643	>	std::string arg6 = (std::string) "" ;
3644		PyObject *result;
3645	+	std::string temp2 ;
3646	+	std::string temp3 ;
3647		PyObject * obj0 = 0 ;
3648	+	PyObject * obj1 = 0 ;
3649	+	PyObject * obj2 = 0 ;
3650	+	PyObject * obj3 = 0 ;
3651	+	PyObject * obj4 = 0 ;
3652	+	PyObject * obj5 = 0 ;
3653
3654	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3655	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3654	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3655	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3656	>	if (obj1) {
3657	>	{
3658	>	if (PyString_Check(obj1)) {
3659	>	temp2 = std::string(PyString_AsString(obj1));
3660	>	arg2 = &temp2;
3661	>	}else {
3662	>	SWIG_exception(SWIG_TypeError, "string expected");
3663	>	}
3664	>	}
3665	>	}
3666	>	if (obj2) {
3667	>	{
3668	>	if (PyString_Check(obj2)) {
3669	>	temp3 = std::string(PyString_AsString(obj2));
3670	>	arg3 = &temp3;
3671	>	}else {
3672	>	SWIG_exception(SWIG_TypeError, "string expected");
3673	>	}
3674	>	}
3675	>	}
3676	>	if (obj3) {
3677	>	{
3678	>	if (PyString_Check(obj3))
3679	>	arg4 = std::string(PyString_AsString(obj3));
3680	>	else
3681	>	SWIG_exception(SWIG_TypeError, "string expected");
3682	>	}
3683	>	}
3684	>	if (obj4) {
3685	>	{
3686	>	if (PyString_Check(obj4))
3687	>	arg5 = std::string(PyString_AsString(obj4));
3688	>	else
3689	>	SWIG_exception(SWIG_TypeError, "string expected");
3690	>	}
3691	>	}
3692	>	if (obj5) {
3693	>	{
3694	>	if (PyString_Check(obj5))
3695	>	arg6 = std::string(PyString_AsString(obj5));
3696	>	else
3697	>	SWIG_exception(SWIG_TypeError, "string expected");
3698	>	}
3699	>	}
3700		{
3701		try {
3702	<	result = (PyObject )BossTask_jobsDict((BossTask const )arg1);
3702	>	result = (PyObject )BossSession_queryTasks(arg1,(std::string const &)arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3703
3704	+	}catch (const BossSchedFailure & e) {
3705	+	PyErr_SetString ( SchedulerError, e.what() );
3706	+	return NULL;
3707		}catch (const std::exception& e) {
3708	<	SWIG_exception(SWIG_RuntimeError, e.what());
3708	>	PyErr_SetString ( BossError, e.what() );
3709	>	return NULL;
3710		}
3711		}
3712		resultobj = result;
#	Line 3468 \| Line 3716 \| *static PyObject _wrap_BossTask_jobsDict**
3716		}
3717
3718
3719	<	static PyObject _wrap_BossTask_progDict(PyObject self, PyObject *args) {
3719	>	static PyObject * BossSession_swigregister(PyObject self, PyObject args) {
3720	>	PyObject *obj;
3721	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3722	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3723	>	Py_INCREF(obj);
3724	>	return Py_BuildValue((char *)"");
3725	>	}
3726	>	static PyObject _wrap_BossTaskException_key_set(PyObject self, PyObject *args) {
3727		PyObject *resultobj;
3728	<	BossTask arg1 = (BossTask ) 0 ;
3729	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3475	<	PyObject *result;
3728	>	BossTaskException arg1 = (BossTaskException ) 0 ;
3729	>	char *arg2 ;
3730		PyObject * obj0 = 0 ;
3477	–	PyObject * obj1 = 0 ;
3731
3732	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3733	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3734	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3735	<	if (arg2 == NULL) {
3736	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3732	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3733	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3734	>	{
3735	>	if (arg2) {
3736	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3737	>	strcpy((char *) arg1->key,arg2);
3738	>	}else {
3739	>	arg1->key = 0;
3740	>	}
3741		}
3742	+	Py_INCREF(Py_None); resultobj = Py_None;
3743	+	return resultobj;
3744	+	fail:
3745	+	return NULL;
3746	+	}
3747	+
3748	+
3749	+	static PyObject _wrap_BossTaskException_key_get(PyObject self, PyObject *args) {
3750	+	PyObject *resultobj;
3751	+	BossTaskException arg1 = (BossTaskException ) 0 ;
3752	+	char *result;
3753	+	PyObject * obj0 = 0 ;
3754	+
3755	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3756	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3757	+	result = (char *) ((arg1)->key);
3758	+
3759	+	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3760	+	return resultobj;
3761	+	fail:
3762	+	return NULL;
3763	+	}
3764	+
3765	+
3766	+	static PyObject _wrap_new_BossTaskException(PyObject self, PyObject *args) {
3767	+	PyObject *resultobj;
3768	+	char *arg1 ;
3769	+	BossTaskException *result;
3770	+
3771	+	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3772		{
3773		try {
3774	<	result = (PyObject )BossTask_progDict((BossTask const )arg1,*arg2);
3774	>	result = (BossTaskException )new BossTaskException((char const )arg1);
3775
3776	+	}catch (const BossSchedFailure & e) {
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	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3785		return resultobj;
3786		fail:
3787		return NULL;
3788		}
3789
3790
3791	<	static PyObject _wrap_BossTask_jobPrograms(PyObject self, PyObject *args) {
3791	>	static PyObject _wrap_BossTaskException_what(PyObject self, PyObject *args) {
3792		PyObject *resultobj;
3793	<	BossTask arg1 = (BossTask ) 0 ;
3794	<	std::string *arg2 = 0 ;
3504	<	PyObject *result;
3505	<	std::string temp2 ;
3793	>	BossTaskException arg1 = (BossTaskException ) 0 ;
3794	>	char *result;
3795		PyObject * obj0 = 0 ;
3507	–	PyObject * obj1 = 0 ;
3796
3797	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3798	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3797	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3798	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3799		{
3800	<	if (PyString_Check(obj1)) {
3801	<	temp2 = std::string(PyString_AsString(obj1));
3802	<	arg2 = &temp2;
3803	<	}else {
3804	<	SWIG_exception(SWIG_TypeError, "string expected");
3800	>	try {
3801	>	result = (char )((BossTaskException const )arg1)->what();
3802	>
3803	>	}catch (const BossSchedFailure & e) {
3804	>	PyErr_SetString ( SchedulerError, e.what() );
3805	>	return NULL;
3806	>	}catch (const std::exception& e) {
3807	>	PyErr_SetString ( BossError, e.what() );
3808	>	return NULL;
3809		}
3810		}
3811	+	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3812	+	return resultobj;
3813	+	fail:
3814	+	return NULL;
3815	+	}
3816	+
3817	+
3818	+	static PyObject _wrap_delete_BossTaskException(PyObject self, PyObject *args) {
3819	+	PyObject *resultobj;
3820	+	BossTaskException arg1 = (BossTaskException ) 0 ;
3821	+	PyObject * obj0 = 0 ;
3822	+
3823	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3824	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3825		{
3826		try {
3827	<	result = (PyObject )BossTask_jobPrograms((BossTask const )arg1,(std::string const &)*arg2);
3827	>	delete arg1;
3828
3829	+	}catch (const BossSchedFailure & e) {
3830	+	PyErr_SetString ( SchedulerError, e.what() );
3831	+	return NULL;
3832		}catch (const std::exception& e) {
3833	<	SWIG_exception(SWIG_RuntimeError, e.what());
3833	>	PyErr_SetString ( BossError, e.what() );
3834	>	return NULL;
3835		}
3836		}
3837	<	resultobj = result;
3837	>	Py_INCREF(Py_None); resultobj = Py_None;
3838		return resultobj;
3839		fail:
3840		return NULL;
3841		}
3842
3843
3844	+	static PyObject * BossTaskException_swigregister(PyObject self, PyObject args) {
3845	+	PyObject *obj;
3846	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3847	+	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3848	+	Py_INCREF(obj);
3849	+	return Py_BuildValue((char *)"");
3850	+	}
3851		static PyObject _wrap_new_BossTask__SWIG_0(PyObject self, PyObject *args) {
3852		PyObject *resultobj;
3853		BossDatabase arg1 = (BossDatabase ) 0 ;
#	Line 3543 \| Line 3860 \| *static PyObject _wrap_new_BossTask__SWI**
3860		try {
3861		result = (BossTask *)new BossTask(arg1);
3862
3863	+	}catch (const BossSchedFailure & e) {
3864	+	PyErr_SetString ( SchedulerError, e.what() );
3865	+	return NULL;
3866		}catch (const std::exception& e) {
3867	<	SWIG_exception(SWIG_RuntimeError, e.what());
3867	>	PyErr_SetString ( BossError, e.what() );
3868	>	return NULL;
3869		}
3870		}
3871		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3577 \| Line 3898 \| *static PyObject _wrap_new_BossTask__SWI**
3898		try {
3899		result = (BossTask )new BossTask(arg1,(std::string const &)arg2);
3900
3901	+	}catch (const BossSchedFailure & e) {
3902	+	PyErr_SetString ( SchedulerError, e.what() );
3903	+	return NULL;
3904		}catch (const std::exception& e) {
3905	<	SWIG_exception(SWIG_RuntimeError, e.what());
3905	>	PyErr_SetString ( BossError, e.what() );
3906	>	return NULL;
3907		}
3908		}
3909		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3599 \| Line 3924 \| *static PyObject _wrap_delete_BossTask(P**
3924		try {
3925		delete arg1;
3926
3927	+	}catch (const BossSchedFailure & e) {
3928	+	PyErr_SetString ( SchedulerError, e.what() );
3929	+	return NULL;
3930		}catch (const std::exception& e) {
3931	<	SWIG_exception(SWIG_RuntimeError, e.what());
3931	>	PyErr_SetString ( BossError, e.what() );
3932	>	return NULL;
3933		}
3934		}
3935		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3625 \| Line 3954 \| *static PyObject _wrap_new_BossTask__SWI**
3954		try {
3955		result = (BossTask )new BossTask((BossTask const &)arg1);
3956
3957	+	}catch (const BossSchedFailure & e) {
3958	+	PyErr_SetString ( SchedulerError, e.what() );
3959	+	return NULL;
3960		}catch (const std::exception& e) {
3961	<	SWIG_exception(SWIG_RuntimeError, e.what());
3961	>	PyErr_SetString ( BossError, e.what() );
3962	>	return NULL;
3963		}
3964		}
3965		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3716 \| Line 4049 \| *static PyObject _wrap_BossTask_id(PyObj**
4049		result = (std::string *) &_result_ref;
4050		}
4051
4052	+	}catch (const BossSchedFailure & e) {
4053	+	PyErr_SetString ( SchedulerError, e.what() );
4054	+	return NULL;
4055		}catch (const std::exception& e) {
4056	<	SWIG_exception(SWIG_RuntimeError, e.what());
4056	>	PyErr_SetString ( BossError, e.what() );
4057	>	return NULL;
4058		}
4059		}
4060		{
#	Line 3744 \| Line 4081 \| *static PyObject _wrap_BossTask_name(PyO**
4081		result = (std::string *) &_result_ref;
4082		}
4083
4084	+	}catch (const BossSchedFailure & e) {
4085	+	PyErr_SetString ( SchedulerError, e.what() );
4086	+	return NULL;
4087		}catch (const std::exception& e) {
4088	<	SWIG_exception(SWIG_RuntimeError, e.what());
4088	>	PyErr_SetString ( BossError, e.what() );
4089	>	return NULL;
4090		}
4091		}
4092		{
#	Line 3769 \| Line 4110 \| *static PyObject _wrap_BossTask_taskMap(**
4110		try {
4111		result = ((BossTask const *)arg1)->taskMap();
4112
4113	+	}catch (const BossSchedFailure & e) {
4114	+	PyErr_SetString ( SchedulerError, e.what() );
4115	+	return NULL;
4116		}catch (const std::exception& e) {
4117	<	SWIG_exception(SWIG_RuntimeError, e.what());
4117	>	PyErr_SetString ( BossError, e.what() );
4118	>	return NULL;
4119		}
4120		}
4121		{
#	Line 3799 \| Line 4144 \| *static PyObject _wrap_BossTask_job_begi**
4144		try {
4145		result = ((BossTask const *)arg1)->job_begin();
4146
4147	+	}catch (const BossSchedFailure & e) {
4148	+	PyErr_SetString ( SchedulerError, e.what() );
4149	+	return NULL;
4150		}catch (const std::exception& e) {
4151	<	SWIG_exception(SWIG_RuntimeError, e.what());
4151	>	PyErr_SetString ( BossError, e.what() );
4152	>	return NULL;
4153		}
4154		}
4155		{
#	Line 3826 \| Line 4175 \| *static PyObject _wrap_BossTask_job_end(**
4175		try {
4176		result = ((BossTask const *)arg1)->job_end();
4177
4178	+	}catch (const BossSchedFailure & e) {
4179	+	PyErr_SetString ( SchedulerError, e.what() );
4180	+	return NULL;
4181		}catch (const std::exception& e) {
4182	<	SWIG_exception(SWIG_RuntimeError, e.what());
4182	>	PyErr_SetString ( BossError, e.what() );
4183	>	return NULL;
4184		}
4185		}
4186		{
#	Line 3853 \| Line 4206 \| *static PyObject _wrap_BossTask_jobsMap(**
4206		try {
4207		result = ((BossTask const *)arg1)->jobsMap();
4208
4209	+	}catch (const BossSchedFailure & e) {
4210	+	PyErr_SetString ( SchedulerError, e.what() );
4211	+	return NULL;
4212		}catch (const std::exception& e) {
4213	<	SWIG_exception(SWIG_RuntimeError, e.what());
4213	>	PyErr_SetString ( BossError, e.what() );
4214	>	return NULL;
4215		}
4216		}
4217		{
#	Line 3891 \| Line 4248 \| *static PyObject _wrap_BossTask_jobMap__**
4248		try {
4249		result = ((BossTask const )arg1)->jobMap(arg2,arg3);
4250
4251	+	}catch (const BossSchedFailure & e) {
4252	+	PyErr_SetString ( SchedulerError, e.what() );
4253	+	return NULL;
4254		}catch (const std::exception& e) {
4255	<	SWIG_exception(SWIG_RuntimeError, e.what());
4255	>	PyErr_SetString ( BossError, e.what() );
4256	>	return NULL;
4257		}
4258		}
4259		{
#	Line 3920 \| Line 4281 \| *static PyObject _wrap_BossTask_jobMap__**
4281		try {
4282		result = ((BossTask const *)arg1)->jobMap(arg2);
4283
4284	+	}catch (const BossSchedFailure & e) {
4285	+	PyErr_SetString ( SchedulerError, e.what() );
4286	+	return NULL;
4287		}catch (const std::exception& e) {
4288	<	SWIG_exception(SWIG_RuntimeError, e.what());
4288	>	PyErr_SetString ( BossError, e.what() );
4289	>	return NULL;
4290		}
4291		}
4292		{
#	Line 4025 \| Line 4390 \| *static PyObject _wrap_BossTask_programs**
4390		try {
4391		result = ((BossTask const )arg1)->programsMap((BossJob const )arg2);
4392
4393	+	}catch (const BossSchedFailure & e) {
4394	+	PyErr_SetString ( SchedulerError, e.what() );
4395	+	return NULL;
4396		}catch (const std::exception& e) {
4397	<	SWIG_exception(SWIG_RuntimeError, e.what());
4397	>	PyErr_SetString ( BossError, e.what() );
4398	>	return NULL;
4399		}
4400		}
4401		{
#	Line 4055 \| Line 4424 \| *static PyObject _wrap_BossTask_queryJob**
4424		try {
4425		result = ((BossTask const )arg1)->queryJobPrograms((BossJob const )arg2);
4426
4427	+	}catch (const BossSchedFailure & e) {
4428	+	PyErr_SetString ( SchedulerError, e.what() );
4429	+	return NULL;
4430		}catch (const std::exception& e) {
4431	<	SWIG_exception(SWIG_RuntimeError, e.what());
4431	>	PyErr_SetString ( BossError, e.what() );
4432	>	return NULL;
4433		}
4434		}
4435		{
#	Line 4106 \| Line 4479 \| *static PyObject _wrap_BossTask_declare_**
4479		try {
4480		(arg1)->declare((std::string const &)arg2,(std::string const &)arg3);
4481
4482	+	}catch (const BossSchedFailure & e) {
4483	+	PyErr_SetString ( SchedulerError, e.what() );
4484	+	return NULL;
4485		}catch (const std::exception& e) {
4486	<	SWIG_exception(SWIG_RuntimeError, e.what());
4486	>	PyErr_SetString ( BossError, e.what() );
4487	>	return NULL;
4488		}
4489		}
4490		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4145 \| Line 4522 \| *static PyObject _wrap_BossTask_declare_**
4522		try {
4523		(arg1)->declare(arg2,(std::string const &)*arg3);
4524
4525	+	}catch (const BossSchedFailure & e) {
4526	+	PyErr_SetString ( SchedulerError, e.what() );
4527	+	return NULL;
4528		}catch (const std::exception& e) {
4529	<	SWIG_exception(SWIG_RuntimeError, e.what());
4529	>	PyErr_SetString ( BossError, e.what() );
4530	>	return NULL;
4531		}
4532		}
4533		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4244 \| Line 4625 \| *static PyObject _wrap_BossTask_remove(P**
4625		try {
4626		(arg1)->remove();
4627
4628	+	}catch (const BossSchedFailure & e) {
4629	+	PyErr_SetString ( SchedulerError, e.what() );
4630	+	return NULL;
4631		}catch (const std::exception& e) {
4632	<	SWIG_exception(SWIG_RuntimeError, e.what());
4632	>	PyErr_SetString ( BossError, e.what() );
4633	>	return NULL;
4634		}
4635		}
4636		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4280 \| Line 4665 \| *static PyObject _wrap_BossTask_archive(**
4665		try {
4666		(arg1)->archive((std::string const &)*arg2);
4667
4668	+	}catch (const BossSchedFailure & e) {
4669	+	PyErr_SetString ( SchedulerError, e.what() );
4670	+	return NULL;
4671		}catch (const std::exception& e) {
4672	<	SWIG_exception(SWIG_RuntimeError, e.what());
4672	>	PyErr_SetString ( BossError, e.what() );
4673	>	return NULL;
4674		}
4675		}
4676		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4304 \| Line 4693 \| *static PyObject _wrap_BossTask_submit(P**
4693		std::string arg5 = (std::string ) &arg5_defvalue ;
4694		std::string const &arg6_defvalue = "" ;
4695		std::string arg6 = (std::string ) &arg6_defvalue ;
4696	<	bool arg7 = (bool) false ;
4696	>	unsigned int arg7 = (unsigned int) 0 ;
4697	>	bool arg8 = (bool) false ;
4698		int result;
4699		std::string temp2 ;
4700		std::string temp3 ;
#	Line 4318 \| Line 4708 \| *static PyObject _wrap_BossTask_submit(P**
4708		PyObject * obj4 = 0 ;
4709		PyObject * obj5 = 0 ;
4710		PyObject * obj6 = 0 ;
4711	+	PyObject * obj7 = 0 ;
4712
4713	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4713	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4714		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4715		if (obj1) {
4716		{
#	Line 4372 \| Line 4763 \| *static PyObject _wrap_BossTask_submit(P**
4763		}
4764		}
4765		if (obj6) {
4766	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4766	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4767	>	if (PyErr_Occurred()) SWIG_fail;
4768	>	}
4769	>	if (obj7) {
4770	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4771		if (PyErr_Occurred()) SWIG_fail;
4772		}
4773		{
4774		try {
4775	<	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);
4775	>	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);
4776
4777	+	}catch (const BossSchedFailure & e) {
4778	+	PyErr_SetString ( SchedulerError, e.what() );
4779	+	return NULL;
4780		}catch (const std::exception& e) {
4781	<	SWIG_exception(SWIG_RuntimeError, e.what());
4781	>	PyErr_SetString ( BossError, e.what() );
4782	>	return NULL;
4783		}
4784		}
4785		resultobj = PyInt_FromLong((long)result);
#	Line 4419 \| Line 4818 \| *static PyObject _wrap_BossTask_reSubmit**
4818		try {
4819		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4820
4821	+	}catch (const BossSchedFailure & e) {
4822	+	PyErr_SetString ( SchedulerError, e.what() );
4823	+	return NULL;
4824		}catch (const std::exception& e) {
4825	<	SWIG_exception(SWIG_RuntimeError, e.what());
4825	>	PyErr_SetString ( BossError, e.what() );
4826	>	return NULL;
4827		}
4828		}
4829		resultobj = PyInt_FromLong((long)result);
#	Line 4434 \| Line 4837 \| *static PyObject _wrap_BossTask_kill(PyO**
4837		PyObject *resultobj;
4838		BossTask arg1 = (BossTask ) 0 ;
4839		std::string *arg2 = 0 ;
4840	<	bool arg3 = (bool) false ;
4840	>	unsigned int arg3 = (unsigned int) 0 ;
4841	>	bool arg4 = (bool) false ;
4842		int result;
4843		std::string temp2 ;
4844		PyObject * obj0 = 0 ;
4845		PyObject * obj1 = 0 ;
4846		PyObject * obj2 = 0 ;
4847	+	PyObject * obj3 = 0 ;
4848
4849	<	if(!PyArg_ParseTuple(args,(char *)"OO\|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4849	>	if(!PyArg_ParseTuple(args,(char *)"OO\|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
4850		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4851		{
4852		if (PyString_Check(obj1)) {
#	Line 4452 \| Line 4857 \| *static PyObject _wrap_BossTask_kill(PyO**
4857		}
4858		}
4859		if (obj2) {
4860	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4860	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
4861	>	if (PyErr_Occurred()) SWIG_fail;
4862	>	}
4863	>	if (obj3) {
4864	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4865		if (PyErr_Occurred()) SWIG_fail;
4866		}
4867		{
4868		try {
4869	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4869	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
4870
4871	+	}catch (const BossSchedFailure & e) {
4872	+	PyErr_SetString ( SchedulerError, e.what() );
4873	+	return NULL;
4874		}catch (const std::exception& e) {
4875	<	SWIG_exception(SWIG_RuntimeError, e.what());
4875	>	PyErr_SetString ( BossError, e.what() );
4876	>	return NULL;
4877		}
4878		}
4879		resultobj = PyInt_FromLong((long)result);
#	Line 4477 \| Line 4890 \| *static PyObject _wrap_BossTask_getOutpu**
4890		std::string arg2 = (std::string ) &arg2_defvalue ;
4891		std::string const &arg3_defvalue = "" ;
4892		std::string arg3 = (std::string ) &arg3_defvalue ;
4893	<	bool arg4 = (bool) false ;
4893	>	unsigned int arg4 = (unsigned int) 0 ;
4894		bool arg5 = (bool) false ;
4895	+	bool arg6 = (bool) false ;
4896		int result;
4897		std::string temp2 ;
4898		std::string temp3 ;
#	Line 4487 \| Line 4901 \| *static PyObject _wrap_BossTask_getOutpu**
4901		PyObject * obj2 = 0 ;
4902		PyObject * obj3 = 0 ;
4903		PyObject * obj4 = 0 ;
4904	+	PyObject * obj5 = 0 ;
4905
4906	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4906	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
4907		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4908		if (obj1) {
4909		{
#	Line 4511 \| Line 4926 \| *static PyObject _wrap_BossTask_getOutpu**
4926		}
4927		}
4928		if (obj3) {
4929	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4929	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
4930		if (PyErr_Occurred()) SWIG_fail;
4931		}
4932		if (obj4) {
4933		arg5 = PyInt_AsLong(obj4) ? true : false;
4934		if (PyErr_Occurred()) SWIG_fail;
4935		}
4936	+	if (obj5) {
4937	+	arg6 = PyInt_AsLong(obj5) ? true : false;
4938	+	if (PyErr_Occurred()) SWIG_fail;
4939	+	}
4940		{
4941		try {
4942	<	result = (int)(arg1)->getOutput((std::string const &)arg2,(std::string const &)arg3,arg4,arg5);
4942	>	result = (int)(arg1)->getOutput((std::string const &)arg2,(std::string const &)arg3,arg4,arg5,arg6);
4943
4944	+	}catch (const BossSchedFailure & e) {
4945	+	PyErr_SetString ( SchedulerError, e.what() );
4946	+	return NULL;
4947		}catch (const std::exception& e) {
4948	<	SWIG_exception(SWIG_RuntimeError, e.what());
4948	>	PyErr_SetString ( BossError, e.what() );
4949	>	return NULL;
4950		}
4951		}
4952		resultobj = PyInt_FromLong((long)result);
#	Line 4533 \| Line 4956 \| *static PyObject _wrap_BossTask_getOutpu**
4956		}
4957
4958
4959	<	static PyObject _wrap_BossTask_getAllOutput(PyObject self, PyObject *args) {
4959	>	static PyObject _wrap_BossTask_loadByName(PyObject self, PyObject *args) {
4960		PyObject *resultobj;
4961		BossTask arg1 = (BossTask ) 0 ;
4962	<	std::string const &arg2_defvalue = "" ;
4540	<	std::string arg2 = (std::string ) &arg2_defvalue ;
4541	<	bool arg3 = (bool) false ;
4542	<	bool arg4 = (bool) false ;
4962	>	std::string *arg2 = 0 ;
4963		int result;
4964		std::string temp2 ;
4965		PyObject * obj0 = 0 ;
4966		PyObject * obj1 = 0 ;
4967	+
4968	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
4969	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4970	+	{
4971	+	if (PyString_Check(obj1)) {
4972	+	temp2 = std::string(PyString_AsString(obj1));
4973	+	arg2 = &temp2;
4974	+	}else {
4975	+	SWIG_exception(SWIG_TypeError, "string expected");
4976	+	}
4977	+	}
4978	+	{
4979	+	try {
4980	+	result = (int)(arg1)->loadByName((std::string const &)*arg2);
4981	+
4982	+	}catch (const BossSchedFailure & e) {
4983	+	PyErr_SetString ( SchedulerError, e.what() );
4984	+	return NULL;
4985	+	}catch (const std::exception& e) {
4986	+	PyErr_SetString ( BossError, e.what() );
4987	+	return NULL;
4988	+	}
4989	+	}
4990	+	resultobj = PyInt_FromLong((long)result);
4991	+	return resultobj;
4992	+	fail:
4993	+	return NULL;
4994	+	}
4995	+
4996	+
4997	+	static PyObject _wrap_BossTask_load(PyObject self, PyObject *args) {
4998	+	PyObject *resultobj;
4999	+	BossTask arg1 = (BossTask ) 0 ;
5000	+	int arg2 = (int) SCHEDULED ;
5001	+	std::string const &arg3_defvalue = "all" ;
5002	+	std::string arg3 = (std::string ) &arg3_defvalue ;
5003	+	std::string const &arg4_defvalue = "" ;
5004	+	std::string arg4 = (std::string ) &arg4_defvalue ;
5005	+	std::string arg5 = (std::string) "" ;
5006	+	std::string arg6 = (std::string) "" ;
5007	+	std::string arg7 = (std::string) "" ;
5008	+	std::string arg8 = (std::string) "" ;
5009	+	int result;
5010	+	std::string temp3 ;
5011	+	std::string temp4 ;
5012	+	PyObject * obj0 = 0 ;
5013		PyObject * obj2 = 0 ;
5014		PyObject * obj3 = 0 ;
5015	+	PyObject * obj4 = 0 ;
5016	+	PyObject * obj5 = 0 ;
5017	+	PyObject * obj6 = 0 ;
5018	+	PyObject * obj7 = 0 ;
5019
5020	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
5020	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5021		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5022	<	if (obj1) {
5022	>	if (obj2) {
5023		{
5024	<	if (PyString_Check(obj1)) {
5025	<	temp2 = std::string(PyString_AsString(obj1));
5026	<	arg2 = &temp2;
5024	>	if (PyString_Check(obj2)) {
5025	>	temp3 = std::string(PyString_AsString(obj2));
5026	>	arg3 = &temp3;
5027		}else {
5028		SWIG_exception(SWIG_TypeError, "string expected");
5029		}
5030		}
5031		}
4562	–	if (obj2) {
4563	–	arg3 = PyInt_AsLong(obj2) ? true : false;
4564	–	if (PyErr_Occurred()) SWIG_fail;
4565	–	}
5032		if (obj3) {
5033	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5034	<	if (PyErr_Occurred()) SWIG_fail;
5033	>	{
5034	>	if (PyString_Check(obj3)) {
5035	>	temp4 = std::string(PyString_AsString(obj3));
5036	>	arg4 = &temp4;
5037	>	}else {
5038	>	SWIG_exception(SWIG_TypeError, "string expected");
5039	>	}
5040	>	}
5041	>	}
5042	>	if (obj4) {
5043	>	{
5044	>	if (PyString_Check(obj4))
5045	>	arg5 = std::string(PyString_AsString(obj4));
5046	>	else
5047	>	SWIG_exception(SWIG_TypeError, "string expected");
5048	>	}
5049	>	}
5050	>	if (obj5) {
5051	>	{
5052	>	if (PyString_Check(obj5))
5053	>	arg6 = std::string(PyString_AsString(obj5));
5054	>	else
5055	>	SWIG_exception(SWIG_TypeError, "string expected");
5056	>	}
5057	>	}
5058	>	if (obj6) {
5059	>	{
5060	>	if (PyString_Check(obj6))
5061	>	arg7 = std::string(PyString_AsString(obj6));
5062	>	else
5063	>	SWIG_exception(SWIG_TypeError, "string expected");
5064	>	}
5065	>	}
5066	>	if (obj7) {
5067	>	{
5068	>	if (PyString_Check(obj7))
5069	>	arg8 = std::string(PyString_AsString(obj7));
5070	>	else
5071	>	SWIG_exception(SWIG_TypeError, "string expected");
5072	>	}
5073		}
5074		{
5075		try {
5076	<	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3,arg4);
5076	>	result = (int)(arg1)->load(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8);
5077
5078	+	}catch (const BossSchedFailure & e) {
5079	+	PyErr_SetString ( SchedulerError, e.what() );
5080	+	return NULL;
5081		}catch (const std::exception& e) {
5082	<	SWIG_exception(SWIG_RuntimeError, e.what());
5082	>	PyErr_SetString ( BossError, e.what() );
5083	>	return NULL;
5084		}
5085		}
5086		resultobj = PyInt_FromLong((long)result);
#	Line 4594 \| Line 5102 \| *static PyObject _wrap_BossTask_query(Py**
5102		std::string arg6 = (std::string) "" ;
5103		std::string arg7 = (std::string) "" ;
5104		std::string arg8 = (std::string) "" ;
5105	<	bool arg9 = (bool) false ;
5105	>	unsigned int arg9 = (unsigned int) 0 ;
5106	>	bool arg10 = (bool) false ;
5107		int result;
5108		std::string temp3 ;
5109		std::string temp4 ;
#	Line 4606 \| Line 5115 \| *static PyObject _wrap_BossTask_query(Py**
5115		PyObject * obj6 = 0 ;
5116		PyObject * obj7 = 0 ;
5117		PyObject * obj8 = 0 ;
5118	+	PyObject * obj9 = 0 ;
5119
5120	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5120	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5121		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5122		if (obj2) {
5123		{
#	Line 4662 \| Line 5172 \| *static PyObject _wrap_BossTask_query(Py**
5172		}
5173		}
5174		if (obj8) {
5175	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5175	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5176	>	if (PyErr_Occurred()) SWIG_fail;
5177	>	}
5178	>	if (obj9) {
5179	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5180		if (PyErr_Occurred()) SWIG_fail;
5181		}
5182		{
5183		try {
5184	<	result = (int)(arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9);
5184	>	result = (int)(arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5185
5186	+	}catch (const BossSchedFailure & e) {
5187	+	PyErr_SetString ( SchedulerError, e.what() );
5188	+	return NULL;
5189		}catch (const std::exception& e) {
5190	<	SWIG_exception(SWIG_RuntimeError, e.what());
5190	>	PyErr_SetString ( BossError, e.what() );
5191	>	return NULL;
5192		}
5193		}
5194		resultobj = PyInt_FromLong((long)result);
#	Line 4728 \| Line 5246 \| *static PyObject _wrap_BossTask_query_ou**
5246		try {
5247		((BossTask const )arg1)->query_out(arg2,(jobStates const &)arg3,(printOption const &)arg4,arg5);
5248
5249	+	}catch (const BossSchedFailure & e) {
5250	+	PyErr_SetString ( SchedulerError, e.what() );
5251	+	return NULL;
5252		}catch (const std::exception& e) {
5253	<	SWIG_exception(SWIG_RuntimeError, e.what());
5253	>	PyErr_SetString ( BossError, e.what() );
5254	>	return NULL;
5255		}
5256		}
5257		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4750 \| Line 5272 \| *static PyObject _wrap_BossTask_clear(Py**
5272		try {
5273		(arg1)->clear();
5274
5275	+	}catch (const BossSchedFailure & e) {
5276	+	PyErr_SetString ( SchedulerError, e.what() );
5277	+	return NULL;
5278		}catch (const std::exception& e) {
5279	<	SWIG_exception(SWIG_RuntimeError, e.what());
5279	>	PyErr_SetString ( BossError, e.what() );
5280	>	return NULL;
5281		}
5282		}
5283		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4761 \| Line 5287 \| *static PyObject _wrap_BossTask_clear(Py**
5287		}
5288
5289
5290	<	static PyObject * BossTask_swigregister(PyObject self, PyObject args) {
5291	<	PyObject *obj;
5292	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5293	<	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5294	<	Py_INCREF(obj);
5295	<	return Py_BuildValue((char *)"");
5290	>	static PyObject _wrap_BossTask_appendToPyDict(PyObject self, PyObject *args) {
5291	>	PyObject *resultobj;
5292	>	BossTask arg1 = (BossTask ) 0 ;
5293	>	PyObject arg2 = (PyObject ) 0 ;
5294	>	BossAttributeContainer *arg3 = 0 ;
5295	>	PyObject * obj0 = 0 ;
5296	>	PyObject * obj1 = 0 ;
5297	>	PyObject * obj2 = 0 ;
5298	>
5299	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5300	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5301	>	arg2 = obj1;
5302	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5303	>	if (arg3 == NULL) {
5304	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5305	>	}
5306	>	{
5307	>	try {
5308	>	BossTask_appendToPyDict((BossTask const )arg1,arg2,(BossAttributeContainer const &)arg3);
5309	>
5310	>	}catch (const BossSchedFailure & e) {
5311	>	PyErr_SetString ( SchedulerError, e.what() );
5312	>	return NULL;
5313	>	}catch (const std::exception& e) {
5314	>	PyErr_SetString ( BossError, e.what() );
5315	>	return NULL;
5316	>	}
5317	>	}
5318	>	Py_INCREF(Py_None); resultobj = Py_None;
5319	>	return resultobj;
5320	>	fail:
5321	>	return NULL;
5322		}
5323	<	static PyObject _wrap_prompt(PyObject self, PyObject *args) {
5323	>
5324	>
5325	>	static PyObject _wrap_BossTask_jobDict(PyObject self, PyObject *args) {
5326		PyObject *resultobj;
5327	<	std::string *arg1 = 0 ;
5328	<	bool result;
5329	<	std::string temp1 ;
5327	>	BossTask arg1 = (BossTask ) 0 ;
5328	>	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5329	>	PyObject arg3 = (PyObject ) 0 ;
5330		PyObject * obj0 = 0 ;
5331	+	PyObject * obj1 = 0 ;
5332	+	PyObject * obj2 = 0 ;
5333
5334	<	if(!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) goto fail;
5334	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5335	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5336	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5337	>	if (arg2 == NULL) {
5338	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5339	>	}
5340	>	arg3 = obj2;
5341		{
5342	<	if (PyString_Check(obj0)) {
5343	<	temp1 = std::string(PyString_AsString(obj0));
5344	<	arg1 = &temp1;
5342	>	try {
5343	>	BossTask_jobDict((BossTask const )arg1,arg2,arg3);
5344	>
5345	>	}catch (const BossSchedFailure & e) {
5346	>	PyErr_SetString ( SchedulerError, e.what() );
5347	>	return NULL;
5348	>	}catch (const std::exception& e) {
5349	>	PyErr_SetString ( BossError, e.what() );
5350	>	return NULL;
5351	>	}
5352	>	}
5353	>	Py_INCREF(Py_None); resultobj = Py_None;
5354	>	return resultobj;
5355	>	fail:
5356	>	return NULL;
5357	>	}
5358	>
5359	>
5360	>	static PyObject _wrap_BossTask_jobsDict(PyObject self, PyObject *args) {
5361	>	PyObject *resultobj;
5362	>	BossTask arg1 = (BossTask ) 0 ;
5363	>	PyObject *result;
5364	>	PyObject * obj0 = 0 ;
5365	>
5366	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5367	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5368	>	{
5369	>	try {
5370	>	result = (PyObject *)BossTask_jobsDict(arg1);
5371	>
5372	>	}catch (const BossSchedFailure & e) {
5373	>	PyErr_SetString ( SchedulerError, e.what() );
5374	>	return NULL;
5375	>	}catch (const std::exception& e) {
5376	>	PyErr_SetString ( BossError, e.what() );
5377	>	return NULL;
5378	>	}
5379	>	}
5380	>	resultobj = result;
5381	>	return resultobj;
5382	>	fail:
5383	>	return NULL;
5384	>	}
5385	>
5386	>
5387	>	static PyObject _wrap_BossTask_progDict(PyObject self, PyObject *args) {
5388	>	PyObject *resultobj;
5389	>	BossTask arg1 = (BossTask ) 0 ;
5390	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5391	>	PyObject *result;
5392	>	PyObject * obj0 = 0 ;
5393	>	PyObject * obj1 = 0 ;
5394	>
5395	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5396	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5397	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5398	>	if (arg2 == NULL) {
5399	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5400	>	}
5401	>	{
5402	>	try {
5403	>	result = (PyObject )BossTask_progDict((BossTask const )arg1,*arg2);
5404	>
5405	>	}catch (const BossSchedFailure & e) {
5406	>	PyErr_SetString ( SchedulerError, e.what() );
5407	>	return NULL;
5408	>	}catch (const std::exception& e) {
5409	>	PyErr_SetString ( BossError, e.what() );
5410	>	return NULL;
5411	>	}
5412	>	}
5413	>	resultobj = result;
5414	>	return resultobj;
5415	>	fail:
5416	>	return NULL;
5417	>	}
5418	>
5419	>
5420	>	static PyObject _wrap_BossTask_jobPrograms(PyObject self, PyObject *args) {
5421	>	PyObject *resultobj;
5422	>	BossTask arg1 = (BossTask ) 0 ;
5423	>	std::string *arg2 = 0 ;
5424	>	PyObject *result;
5425	>	std::string temp2 ;
5426	>	PyObject * obj0 = 0 ;
5427	>	PyObject * obj1 = 0 ;
5428	>
5429	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5430	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5431	>	{
5432	>	if (PyString_Check(obj1)) {
5433	>	temp2 = std::string(PyString_AsString(obj1));
5434	>	arg2 = &temp2;
5435		}else {
5436		SWIG_exception(SWIG_TypeError, "string expected");
5437		}
5438		}
5439		{
5440		try {
5441	<	result = (bool)prompt((std::string const &)*arg1);
5441	>	result = (PyObject )BossTask_jobPrograms((BossTask const )arg1,(std::string const &)*arg2);
5442
5443	+	}catch (const BossSchedFailure & e) {
5444	+	PyErr_SetString ( SchedulerError, e.what() );
5445	+	return NULL;
5446		}catch (const std::exception& e) {
5447	<	SWIG_exception(SWIG_RuntimeError, e.what());
5447	>	PyErr_SetString ( BossError, e.what() );
5448	>	return NULL;
5449		}
5450		}
5451	<	resultobj = PyInt_FromLong((long)result);
5451	>	resultobj = result;
5452		return resultobj;
5453		fail:
5454		return NULL;
5455		}
5456
5457
5458	+	static PyObject * BossTask_swigregister(PyObject self, PyObject args) {
5459	+	PyObject *obj;
5460	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5461	+	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5462	+	Py_INCREF(obj);
5463	+	return Py_BuildValue((char *)"");
5464	+	}
5465		static PyObject _wrap_new_BossAdministratorSession(PyObject self, PyObject *args) {
5466		PyObject *resultobj;
5467		std::string arg1 = (std::string) "" ;
5468	<	bool arg2 = (bool) false ;
5468	>	std::string arg2 = (std::string) "2" ;
5469	>	std::string arg3 = (std::string) "" ;
5470	>	std::string arg4 = (std::string) "" ;
5471	>	bool arg5 = (bool) false ;
5472		BossAdministratorSession *result;
5473		PyObject * obj0 = 0 ;
5474		PyObject * obj1 = 0 ;
5475	+	PyObject * obj2 = 0 ;
5476	+	PyObject * obj3 = 0 ;
5477	+	PyObject * obj4 = 0 ;
5478
5479	<	if(!PyArg_ParseTuple(args,(char *)"\|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
5479	>	if(!PyArg_ParseTuple(args,(char *)"\|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5480		if (obj0) {
5481		{
5482		if (PyString_Check(obj0))
#	Line 4817 \| Line 5486 \| *static PyObject _wrap_new_BossAdministr**
5486		}
5487		}
5488		if (obj1) {
5489	<	arg2 = PyInt_AsLong(obj1) ? true : false;
5489	>	{
5490	>	if (PyString_Check(obj1))
5491	>	arg2 = std::string(PyString_AsString(obj1));
5492	>	else
5493	>	SWIG_exception(SWIG_TypeError, "string expected");
5494	>	}
5495	>	}
5496	>	if (obj2) {
5497	>	{
5498	>	if (PyString_Check(obj2))
5499	>	arg3 = std::string(PyString_AsString(obj2));
5500	>	else
5501	>	SWIG_exception(SWIG_TypeError, "string expected");
5502	>	}
5503	>	}
5504	>	if (obj3) {
5505	>	{
5506	>	if (PyString_Check(obj3))
5507	>	arg4 = std::string(PyString_AsString(obj3));
5508	>	else
5509	>	SWIG_exception(SWIG_TypeError, "string expected");
5510	>	}
5511	>	}
5512	>	if (obj4) {
5513	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5514		if (PyErr_Occurred()) SWIG_fail;
5515		}
5516		{
5517		try {
5518	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
5518	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5519
5520	+	}catch (const BossSchedFailure & e) {
5521	+	PyErr_SetString ( SchedulerError, e.what() );
5522	+	return NULL;
5523		}catch (const std::exception& e) {
5524	<	SWIG_exception(SWIG_RuntimeError, e.what());
5524	>	PyErr_SetString ( BossError, e.what() );
5525	>	return NULL;
5526		}
5527		}
5528		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4846 \| Line 5543 \| *static PyObject _wrap_delete_BossAdmini**
5543		try {
5544		delete arg1;
5545
5546	+	}catch (const BossSchedFailure & e) {
5547	+	PyErr_SetString ( SchedulerError, e.what() );
5548	+	return NULL;
5549		}catch (const std::exception& e) {
5550	<	SWIG_exception(SWIG_RuntimeError, e.what());
5550	>	PyErr_SetString ( BossError, e.what() );
5551	>	return NULL;
5552		}
5553		}
5554		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4869 \| Line 5570 \| *static PyObject _wrap_BossAdministrator**
5570		try {
5571		result = (int)(arg1)->configureDB();
5572
5573	+	}catch (const BossSchedFailure & e) {
5574	+	PyErr_SetString ( SchedulerError, e.what() );
5575	+	return NULL;
5576		}catch (const std::exception& e) {
5577	<	SWIG_exception(SWIG_RuntimeError, e.what());
5577	>	PyErr_SetString ( BossError, e.what() );
5578	>	return NULL;
5579		}
5580		}
5581		resultobj = PyInt_FromLong((long)result);
#	Line 4903 \| Line 5608 \| *static PyObject _wrap_BossAdministrator**
5608		try {
5609		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5610
5611	+	}catch (const BossSchedFailure & e) {
5612	+	PyErr_SetString ( SchedulerError, e.what() );
5613	+	return NULL;
5614		}catch (const std::exception& e) {
5615	<	SWIG_exception(SWIG_RuntimeError, e.what());
5615	>	PyErr_SetString ( BossError, e.what() );
5616	>	return NULL;
5617		}
5618		}
5619		resultobj = PyInt_FromLong((long)result);
#	Line 4937 \| Line 5646 \| *static PyObject _wrap_BossAdministrator**
5646		try {
5647		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5648
5649	+	}catch (const BossSchedFailure & e) {
5650	+	PyErr_SetString ( SchedulerError, e.what() );
5651	+	return NULL;
5652		}catch (const std::exception& e) {
5653	<	SWIG_exception(SWIG_RuntimeError, e.what());
5653	>	PyErr_SetString ( BossError, e.what() );
5654	>	return NULL;
5655		}
5656		}
5657		resultobj = PyInt_FromLong((long)result);
#	Line 4971 \| Line 5684 \| *static PyObject _wrap_BossAdministrator**
5684		try {
5685		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5686
5687	+	}catch (const BossSchedFailure & e) {
5688	+	PyErr_SetString ( SchedulerError, e.what() );
5689	+	return NULL;
5690		}catch (const std::exception& e) {
5691	<	SWIG_exception(SWIG_RuntimeError, e.what());
5691	>	PyErr_SetString ( BossError, e.what() );
5692	>	return NULL;
5693		}
5694		}
5695		resultobj = PyInt_FromLong((long)result);
#	Line 5005 \| Line 5722 \| *static PyObject _wrap_BossAdministrator**
5722		try {
5723		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5724
5725	+	}catch (const BossSchedFailure & e) {
5726	+	PyErr_SetString ( SchedulerError, e.what() );
5727	+	return NULL;
5728		}catch (const std::exception& e) {
5729	<	SWIG_exception(SWIG_RuntimeError, e.what());
5729	>	PyErr_SetString ( BossError, e.what() );
5730	>	return NULL;
5731		}
5732		}
5733		resultobj = PyInt_FromLong((long)result);
#	Line 5039 \| Line 5760 \| *static PyObject _wrap_BossAdministrator**
5760		try {
5761		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5762
5763	+	}catch (const BossSchedFailure & e) {
5764	+	PyErr_SetString ( SchedulerError, e.what() );
5765	+	return NULL;
5766		}catch (const std::exception& e) {
5767	<	SWIG_exception(SWIG_RuntimeError, e.what());
5767	>	PyErr_SetString ( BossError, e.what() );
5768	>	return NULL;
5769		}
5770		}
5771		resultobj = PyInt_FromLong((long)result);
#	Line 5105 \| Line 5830 \| *static PyObject _wrap_BossAdministrator**
5830		try {
5831		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5832
5833	+	}catch (const BossSchedFailure & e) {
5834	+	PyErr_SetString ( SchedulerError, e.what() );
5835	+	return NULL;
5836		}catch (const std::exception& e) {
5837	<	SWIG_exception(SWIG_RuntimeError, e.what());
5837	>	PyErr_SetString ( BossError, e.what() );
5838	>	return NULL;
5839		}
5840		}
5841		resultobj = PyInt_FromLong((long)result);
#	Line 5195 \| Line 5924 \| *static PyObject _wrap_BossAdministrator**
5924		try {
5925		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5926
5927	+	}catch (const BossSchedFailure & e) {
5928	+	PyErr_SetString ( SchedulerError, e.what() );
5929	+	return NULL;
5930		}catch (const std::exception& e) {
5931	<	SWIG_exception(SWIG_RuntimeError, e.what());
5931	>	PyErr_SetString ( BossError, e.what() );
5932	>	return NULL;
5933		}
5934		}
5935		resultobj = PyInt_FromLong((long)result);
#	Line 5271 \| Line 6004 \| *static PyObject _wrap_BossAdministrator**
6004		try {
6005		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6006
6007	+	}catch (const BossSchedFailure & e) {
6008	+	PyErr_SetString ( SchedulerError, e.what() );
6009	+	return NULL;
6010		}catch (const std::exception& e) {
6011	<	SWIG_exception(SWIG_RuntimeError, e.what());
6011	>	PyErr_SetString ( BossError, e.what() );
6012	>	return NULL;
6013		}
6014		}
6015		resultobj = PyInt_FromLong((long)result);
#	Line 5300 \| Line 6037 \| *static PyObject _wrap_BossAdministrator**
6037		std::string arg13 = (std::string) "" ;
6038		bool arg14 = (bool) false ;
6039		bool arg15 = (bool) false ;
6040	+	bool arg16 = (bool) false ;
6041	+	bool arg17 = (bool) false ;
6042		int result;
6043		std::string temp2 ;
6044		std::string temp11 ;
#	Line 5318 \| Line 6057 \| *static PyObject _wrap_BossAdministrator**
6057		PyObject * obj12 = 0 ;
6058		PyObject * obj13 = 0 ;
6059		PyObject * obj14 = 0 ;
6060	+	PyObject * obj15 = 0 ;
6061	+	PyObject * obj16 = 0 ;
6062
6063	<	if(!PyArg_ParseTuple(args,(char *)"OO\|OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) goto fail;
6063	>	if(!PyArg_ParseTuple(args,(char *)"OO\|OOOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) goto fail;
6064		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
6065		{
6066		if (PyString_Check(obj1)) {
#	Line 5427 \| Line 6168 \| *static PyObject _wrap_BossAdministrator**
6168		arg15 = PyInt_AsLong(obj14) ? true : false;
6169		if (PyErr_Occurred()) SWIG_fail;
6170		}
6171	+	if (obj15) {
6172	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6173	+	if (PyErr_Occurred()) SWIG_fail;
6174	+	}
6175	+	if (obj16) {
6176	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6177	+	if (PyErr_Occurred()) SWIG_fail;
6178	+	}
6179		{
6180		try {
6181	<	result = (int)(arg1)->registerScheduler((std::string const &)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)arg11,arg12,arg13,arg14,arg15);
6181	>	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);
6182
6183	+	}catch (const BossSchedFailure & e) {
6184	+	PyErr_SetString ( SchedulerError, e.what() );
6185	+	return NULL;
6186		}catch (const std::exception& e) {
6187	<	SWIG_exception(SWIG_RuntimeError, e.what());
6187	>	PyErr_SetString ( BossError, e.what() );
6188	>	return NULL;
6189		}
6190		}
6191		resultobj = PyInt_FromLong((long)result);
#	Line 5454 \| Line 6207 \| *static PyObject _wrap_BossAdministrator**
6207		try {
6208		result = (arg1)->help();
6209
6210	+	}catch (const BossSchedFailure & e) {
6211	+	PyErr_SetString ( SchedulerError, e.what() );
6212	+	return NULL;
6213		}catch (const std::exception& e) {
6214	<	SWIG_exception(SWIG_RuntimeError, e.what());
6214	>	PyErr_SetString ( BossError, e.what() );
6215	>	return NULL;
6216		}
6217		}
6218		{
#	Line 5493 \| Line 6250 \| *static PyObject _wrap_BossAdministrator**
6250		try {
6251		result = (arg1)->SQL(arg2,arg3);
6252
6253	+	}catch (const BossSchedFailure & e) {
6254	+	PyErr_SetString ( SchedulerError, e.what() );
6255	+	return NULL;
6256		}catch (const std::exception& e) {
6257	<	SWIG_exception(SWIG_RuntimeError, e.what());
6257	>	PyErr_SetString ( BossError, e.what() );
6258	>	return NULL;
6259		}
6260		}
6261		{
#	Line 5565 \| Line 6326 \| *static PyObject _wrap_BossAdministrator**
6326		try {
6327		result = (int)(arg1)->purge((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5);
6328
6329	+	}catch (const BossSchedFailure & e) {
6330	+	PyErr_SetString ( SchedulerError, e.what() );
6331	+	return NULL;
6332		}catch (const std::exception& e) {
6333	<	SWIG_exception(SWIG_RuntimeError, e.what());
6333	>	PyErr_SetString ( BossError, e.what() );
6334	>	return NULL;
6335		}
6336		}
6337		resultobj = PyInt_FromLong((long)result);
#	Line 5596 \| Line 6361 \| *static PyObject _wrap_BossAdministrator**
6361		try {
6362		result = (int)(arg1)->registerPlugins(arg2);
6363
6364	+	}catch (const BossSchedFailure & e) {
6365	+	PyErr_SetString ( SchedulerError, e.what() );
6366	+	return NULL;
6367		}catch (const std::exception& e) {
6368	<	SWIG_exception(SWIG_RuntimeError, e.what());
6368	>	PyErr_SetString ( BossError, e.what() );
6369	>	return NULL;
6370		}
6371		}
6372		resultobj = PyInt_FromLong((long)result);
#	Line 5644 \| Line 6413 \| static PyMethodDef SwigMethods[] = {
6413		{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6414		{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6415		{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5647	–	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5648	–	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5649	–	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5650	–	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5651	–	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5652	–	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5653	–	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6416		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6417		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6418	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6419		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6420		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6421		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6422	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6423	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6424	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6425	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6426		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6427		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6428		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5667 \| Line 6434 \| static PyMethodDef SwigMethods[] = {
6434		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6435		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6436		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6437	+	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
6438		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6439	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
6440	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6441	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6442	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6443	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6444	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6445	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6446	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6447		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6448		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6449		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5675 \| Line 6451 \| static PyMethodDef SwigMethods[] = {
6451		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6452		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6453		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5678	–	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5679	–	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5680	–	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
5681	–	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5682	–	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6454		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6455		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6456		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
#	Line 5698 \| Line 6469 \| static PyMethodDef SwigMethods[] = {
6469		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6470		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6471		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6472	<	{ (char *)"BossTask_getAllOutput", _wrap_BossTask_getAllOutput, METH_VARARGS },
6472	>	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
6473	>	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6474		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6475		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6476		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6477	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6478	+	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6479	+	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6480	+	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6481	+	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6482		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5706	–	{ (char *)"prompt", _wrap_prompt, METH_VARARGS },
6483		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6484		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
6485		{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
#	Line 5727 \| Line 6503 \| static PyMethodDef SwigMethods[] = {
6503
6504		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6505
6506	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6507		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}};
6508		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}};
5732	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6509		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}};
6510		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}};
6511	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6512		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6513		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5737	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
5738	–	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6514		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6515	+	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6516		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6517		static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6518		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6519		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}};
6520		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}};
6521		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5746	–	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}};
6522		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}};
6523	+	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}};
6524		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6525
6526		static swig_type_info *swig_types_initial[] = {
6527	+	_swigt__p_XMLDoc,
6528		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6529		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
5753	–	_swigt__p_XMLDoc,
6530		_swigt__p_std__vectorTBossTask_p_t,
6531		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6532	+	_swigt__p_std__ostream,
6533		_swigt__p_BossTask,
6534		_swigt__p_BossTaskException,
5758	–	_swigt__p_std__ostream,
5759	–	_swigt__p_BossAttributeContainer,
6535		_swigt__p_printOption,
6536	+	_swigt__p_BossAttributeContainer,
6537		_swigt__p_BossJob,
6538		_swigt__p_BossDatabase,
6539		_swigt__p_BossSession,
6540		_swigt__p_std__vectorTstd__string_t,
6541		_swigt__p_std__mapTstd__string_std__string_t,
6542		_swigt__p_BossAdministratorSession,
5767	–	_swigt__p_BossTask__job_iterator,
6543		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6544	+	_swigt__p_BossTask__job_iterator,
6545		_swigt__p_jobStates,
6546		0
6547		};
#	Line 5809 \| Line 6585 \| SWIGEXPORT(void) SWIG_init(void) {
6585		}
6586		SWIG_InstallConstants(d,swig_const_table);
6587
6588	+
6589	+	// define custom exceptions
6590	+	PyObject *e;
6591	+	PyMethodDef tp_methods = {
6592	+	NULL, NULL, 0, NULL
6593	+	};
6594	+	e = Py_InitModule("BossSession", &tp_methods);
6595	+	// generic BOSS exception
6596	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6597	+	Py_INCREF(BossError);
6598	+	PyModule_AddObject(e, "BossError", BossError);
6599	+	// scheduler interaction BOSS exception
6600	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6601	+	Py_INCREF(SchedulerError);
6602	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6603	+
6604		}
6605

Diff Legend

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents): Revision 1.11 by gcodispo, Mon Oct 30 14:00:27 2006 UTC vs. Revision 1.27 by gcodispo, Thu Mar 8 17:52:39 2007 UTC

Diff Legend

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.11 by gcodispo, Mon Oct 30 14:00:27 2006 UTC vs.
Revision 1.27 by gcodispo, Thu Mar 8 17:52:39 2007 UTC