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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.17 by gcodispo, Thu Dec 7 09:31:22 2006 UTC vs.
Revision 1.37 by gcodispo, Wed Jul 18 13:53:45 2007 UTC

#	Line 655 \| Line 655 \| *SWIG_InstallConstants(PyObject d, swig_**
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]
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]
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]
675	<	#define SWIGTYPE_p_jobStates swig_types[18]
676	<	static swig_type_info *swig_types[20];
658	>	#define SWIGTYPE_p_XMLDoc swig_types[1]
659	>	#define SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660	>	#define SWIGTYPE_p_BossProgramExec swig_types[3]
661	>	#define SWIGTYPE_p_BossChain swig_types[4]
662	>	#define SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[5]
663	>	#define SWIGTYPE_p_BossTask swig_types[6]
664	>	#define SWIGTYPE_p_BossTaskException swig_types[7]
665	>	#define SWIGTYPE_p_std__ostream swig_types[8]
666	>	#define SWIGTYPE_p_BossProgram swig_types[9]
667	>	#define SWIGTYPE_p_printOption swig_types[10]
668	>	#define SWIGTYPE_p_BossAttributeContainer swig_types[11]
669	>	#define SWIGTYPE_p_BossJob swig_types[12]
670	>	#define SWIGTYPE_p_BossDatabase swig_types[13]
671	>	#define SWIGTYPE_p_BossSession swig_types[14]
672	>	#define SWIGTYPE_p_std__vectorTstd__string_t swig_types[15]
673	>	#define SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[16]
674	>	#define SWIGTYPE_p_BossAdministratorSession swig_types[17]
675	>	#define SWIGTYPE_p_BossTask__job_iterator swig_types[18]
676	>	#define SWIGTYPE_p_BossSession__task_iterator swig_types[19]
677	>	#define SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[20]
678	>	#define SWIGTYPE_p_jobStates swig_types[21]
679	>	static swig_type_info *swig_types[23];
680
681		/* -------- TYPES TABLE (END) -------- */
682
#	Line 917 \| Line 920 \| void std_vectorlstd_string_g___delslice_
920		self->erase(self->begin()+i,self->begin()+j);
921		}
922
923	+	static PyObject * BossError;
924	+	static PyObject * SchedulerError;
925		#include "BossSession.h"
926		#include "BossAdministratorSession.h"
927		#include "BossTask.h"
928		#include "BossJob.h"
929	+	#include "BossChain.h"
930		#include "BossTaskCore.h"
931		#include "BossAttributeContainer.h"
932		#include "BossDBObject.h"
#	Line 928 \| Line 934 \| void std_vectorlstd_string_g___delslice_
934		#include "BossProgramExec.h"
935		#include "BossDatabase.h"
936		#include "BossScheduler.h"
937	+	#include "BossDeclaration.h"
938
939		PyObject BossSession_show(BossSession self,std::vector<std::string > &my_vec){
940		PyObject * my_list = PyList_New( my_vec.size());
#	Line 954 \| Line 961 \| *PyObject BossSession_schedulers(BossSes**
961		std::vector<std::string> my_vec = self->showSchedulers();
962		return BossSession_show( self, my_vec );
963		}
964	<	PyObject BossSession_schedListMatch(BossSession self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
964	>	PyObject BossSession_schedListMatch(BossSession self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout){
965		std::vector<std::string> my_vec = self->listMatch( scheduler,
966		schclassad,
960	–	keepfile,
967		taskid,
968	<	jobid);
968	>	jobid,
969	>	timeout);
970		return BossSession_show( self, my_vec );
971		}
972	<	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){
973	<	if ( !avoidCheck ) {
974	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
968	<	type, user, after, before);
969	<	}
970	<	PyObject * job_dict = PyList_New(0);
971	<	std::vector <std::string>
972	<	taskList = self->selectTasks( taskRange, before, after, user);
973	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
974	<	it!= taskList.end(); ++it ) {
975	<	PyList_Append( job_dict, PyString_FromString(it->c_str() ) );
976	<	}
977	<	return job_dict;
978	<	}
979	<	PyObject BossTask_appendToPyDict(BossTask const self,PyObject *dict,BossAttributeContainer const &obj){
980	<	std::string tmp;
981	<	BossAttributeContainer::const_iterator it_end = obj.end ();
982	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
983	<	it != it_end; ++it) {
984	<	tmp = (*it).first.name ();
985	<	char * key = new char[ tmp.size() ];
986	<	key = strdup(tmp.c_str());
987	<	tmp = (*it).second.value ();
988	<	PyObject * val = PyString_FromString( tmp.c_str() );
989	<	PyDict_SetItemString( dict, key, val );
990	<	delete [] key;
991	<	}
992	<	return dict;
972	>	void BossSession_schedulerQuery(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,unsigned int timeout,bool avoidCheck){
973	>	self->query ( filter_opt, taskRange, jobRange, subn, type, user, after, before, timeout, avoidCheck );
974	>	return;
975		}
976	<	PyObject BossTask_jobDict(BossTask const self,std::vector<BossJob * >::const_iterator &jit){
976	>	void BossTask_appendToPyDict(BossTask const self,PyObject dict,BossAttributeContainer const &obj){
977	>	std::string tmp;
978	>	BossAttributeContainer::const_iterator it_end = obj.end ();
979	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
980	>	it != it_end; ++it) {
981	>
982	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
983	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
984	>	PyDict_SetItem( dict, key, val);
985	>	Py_DECREF(key);
986	>	Py_DECREF(val);
987	>	}
988	>	return;
989	>	}
990	>	void BossTask_jobDict(BossTask const self,BossJob const jobH,PyObject *job_dict){
991
992	<	PyObject * job_dict = PyDict_New();
992	>	// PyObject * job_dict = PyDict_New();
993		std::string tmp;
994
995	<	BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
996	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
995	>	BossAttributeContainer obj = jobH->getTableEntries("JOB");
996	>	BossTask_appendToPyDict ( self, job_dict, obj );
997
998	<	std::set<std::string> sch = (*jit)->getSchedulerElements();
998	>	std::set<std::string> sch = jobH->getSchedulerElements();
999		std::set<std::string>::const_iterator sch_end = sch.end();
1000		for (std::set<std::string>::const_iterator it =sch.begin();
1001		it != sch_end; ++ it ) {
1002	<	tmp = (*it);
1003	<	char * key = new char[ tmp.size() ];
1004	<	key = strdup(tmp.c_str());
1009	<	tmp = (*jit)["JOB_SCHED_INFO."+(it)];
1002	>
1003	>	tmp = (jobH)["JOB_SCHED_INFO."+(it)];
1004	>	PyObject * key = PyString_FromString( it->c_str() );
1005		PyObject * val = PyString_FromString( tmp.c_str() );
1006	<	PyDict_SetItemString( job_dict, key, val );
1007	<	delete [] key;
1006	>	PyDict_SetItem( job_dict, key, val);
1007	>	Py_DECREF(key);
1008	>	Py_DECREF(val);
1009		}
1010	<	return job_dict;
1010	>	return;
1011		}
1012		PyObject BossTask_jobsDict(BossTask self){
1013
#	Line 1019 \| Line 1015 \| *PyObject BossTask_jobsDict(BossTask se*
1015		if ( self->job_begin () == self->job_end ()) self->load(ALL);
1016		for (BossTask::job_iterator jit = self->job_begin ();
1017		jit != self->job_end (); ++jit) {
1018	<	std::string id = (*jit)->chainId();
1019	<	PyObject * tmp = BossTask_jobDict( self, jit );
1020	<	PyObject * myid = PyString_FromString(id.c_str() );
1021	<	PyDict_SetItem( job_dict, myid,tmp );
1018	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1019	>	PyObject * tmp_dict = PyDict_New();
1020	>	BossTask_jobDict( self, *jit, tmp_dict );
1021	>	PyDict_SetItem( job_dict, id, tmp_dict );
1022	>	Py_DECREF(id);
1023	>	Py_DECREF(tmp_dict);
1024	>	}
1025	>	return job_dict;
1026	>	}
1027	>	PyObject BossTask_job(BossTask self,std::string const &jobid){
1028	>	if ( ! self->jobsInMemory() ) self->load( ALL, jobid );
1029	>	PyObject * job_dict = PyDict_New();
1030	>	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1031	>	return job_dict;
1032	>	}
1033	>	PyObject BossTask_Chain(BossTask self,std::string const &jobid){
1034	>
1035	>	PyObject * chain_dict = PyDict_New();
1036	>	BossAttributeContainer obj =
1037	>	self->chain( jobid ).getTableEntries("CHAIN");
1038	>	BossTask_appendToPyDict ( self, chain_dict, obj );
1039	>	return chain_dict;
1040	>	}
1041	>	PyObject BossTask_jobStates(BossTask self){
1042	>
1043	>	PyObject * job_dict = PyDict_New();
1044	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1045	>	for (BossTask::job_iterator jit = self->job_begin ();
1046	>	jit != self->job_end (); ++jit) {
1047	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1048	>	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1049	>	PyDict_SetItem( job_dict, id, status );
1050	>	Py_DECREF(id);
1051	>	Py_DECREF(status);
1052	>	}
1053	>	return job_dict;
1054	>	}
1055	>	PyObject BossTask_joblist(BossTask self){
1056	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1057	>	PyObject * job_list = PyList_New( self->jobsInMemory() );
1058	>	unsigned int index = 0;
1059	>	for (BossTask::job_iterator jit = self->job_begin ();
1060	>	jit != self->job_end (); ++jit, ++index) {
1061	>	PyList_SetItem( job_list,
1062	>	index,
1063	>	PyString_FromString( ( (*jit)->chainId() ).c_str() )
1064	>	);
1065	>	}
1066	>	return job_list;
1067	>	}
1068	>	PyObject BossTask_jobStatistic(BossTask self){
1069	>
1070	>	PyObject * job_dict = PyDict_New();
1071	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1072	>	std::map< std::string, int > states;
1073	>	for (BossTask::job_iterator jit = self->job_begin ();
1074	>	jit != self->job_end (); ++jit) {
1075	>	++states[(**jit)["JOB.STATUS"]];
1076	>	}
1077	>
1078	>	std::map< std::string, int >::const_iterator end = states.end ();
1079	>	for (std::map< std::string, int >::const_iterator it = states.begin ();
1080	>	it != end; ++it) {
1081	>	PyObject * status = PyString_FromString( (it->first).c_str() );
1082	>	PyObject * jobs = PyString_FromFormat( "%d", it->second );
1083	>	PyDict_SetItem( job_dict, status, jobs );
1084	>	Py_DECREF(jobs);
1085	>	Py_DECREF(status);
1086		}
1087		return job_dict;
1088		}
#	Line 1067 \| Line 1127 \| *PyObject BossTask_jobPrograms(BossTask**
1127		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1128		++programs_it ) {
1129		std::string id = (programs_it->first)["PROGRAM.ID"];
1130	<	PyObject * tmp = BossTask_progDict( self, programs_it );
1130	>	PyObject * tmp_dict = BossTask_progDict( self, programs_it );
1131		PyObject * myid = PyString_FromString(id.c_str() );
1132	<	PyDict_SetItem( job_dict, myid,tmp );
1132	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1133	>	Py_DECREF(myid);
1134	>	Py_DECREF(tmp_dict);
1135	>	}
1136	>	return job_dict;
1137	>	}
1138	>	PyObject BossTask_program(BossTask self,std::string const &jobid,std::string const &programId){
1139	>
1140	>	PyObject * job_dict = PyDict_New();
1141	>
1142	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1143	>	BossAttributeContainer obj =
1144	>	self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1145	>	BossTask_appendToPyDict ( self, job_dict, obj );
1146	>	return job_dict;
1147	>	}
1148	>	PyObject BossTask_programExec(BossTask self,std::string const &jobid,std::string const &programId){
1149	>
1150	>	PyObject * job_dict = PyDict_New();
1151	>
1152	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1153	>
1154	>	// PROGRAM_EXEC
1155	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1156	>	BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1157	>	BossTask_appendToPyDict ( self, job_dict, obj );
1158	>
1159	>	// SPECIFICS
1160	>	std::vector < BossAttributeContainer >::const_iterator it;
1161	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1162	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1163	>	BossTask_appendToPyDict ( self, job_dict, *it );
1164	>	}
1165	>	return job_dict;
1166	>	}
1167	>	PyObject BossTask_specific(BossTask self,std::string const &jobid,std::string const &programId){
1168	>
1169	>	PyObject * job_dict = PyDict_New();
1170	>
1171	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1172	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1173	>	BossAttributeContainer obj = programExec.getKeys ();
1174	>	BossTask_appendToPyDict ( self, job_dict, obj );
1175	>
1176	>	std::vector < BossAttributeContainer >::const_iterator it;
1177	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1178	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1179	>	BossTask_appendToPyDict ( self, job_dict, *it );
1180		}
1181		return job_dict;
1182		}
#	Line 1086 \| Line 1193 \| *static PyObject _wrap_new_objectMap__SW**
1193		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1194
1195		}catch (const BossSchedFailure & e) {
1196	<	SWIG_exception(SWIG_ValueError, e.what());
1196	>	PyErr_SetString ( SchedulerError, e.what() );
1197	>	return NULL;
1198		}catch (const std::exception& e) {
1199	<	SWIG_exception(SWIG_RuntimeError, e.what());
1199	>	PyErr_SetString ( BossError, e.what() );
1200	>	return NULL;
1201		}
1202		}
1203		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1147 \| Line 1256 \| *static PyObject _wrap_new_objectMap__SW**
1256		result = (std::map<std::string,std::string > )new std::map<std::string,std::string >((std::map<std::string,std::string > const &)arg1);
1257
1258		}catch (const BossSchedFailure & e) {
1259	<	SWIG_exception(SWIG_ValueError, e.what());
1259	>	PyErr_SetString ( SchedulerError, e.what() );
1260	>	return NULL;
1261		}catch (const std::exception& e) {
1262	<	SWIG_exception(SWIG_RuntimeError, e.what());
1262	>	PyErr_SetString ( BossError, e.what() );
1263	>	return NULL;
1264		}
1265		}
1266		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1264 \| Line 1375 \| *static PyObject _wrap_objectMap___len__**
1375		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1376
1377		}catch (const BossSchedFailure & e) {
1378	<	SWIG_exception(SWIG_ValueError, e.what());
1378	>	PyErr_SetString ( SchedulerError, e.what() );
1379	>	return NULL;
1380		}catch (const std::exception& e) {
1381	<	SWIG_exception(SWIG_RuntimeError, e.what());
1381	>	PyErr_SetString ( BossError, e.what() );
1382	>	return NULL;
1383		}
1384		}
1385		resultobj = PyInt_FromLong((long)result);
#	Line 1288 \| Line 1401 \| *static PyObject _wrap_objectMap_clear(P**
1401		(arg1)->clear();
1402
1403		}catch (const BossSchedFailure & e) {
1404	<	SWIG_exception(SWIG_ValueError, e.what());
1404	>	PyErr_SetString ( SchedulerError, e.what() );
1405	>	return NULL;
1406		}catch (const std::exception& e) {
1407	<	SWIG_exception(SWIG_RuntimeError, e.what());
1407	>	PyErr_SetString ( BossError, e.what() );
1408	>	return NULL;
1409		}
1410		}
1411		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1313 \| Line 1428 \| *static PyObject _wrap_objectMap___nonze**
1428		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1429
1430		}catch (const BossSchedFailure & e) {
1431	<	SWIG_exception(SWIG_ValueError, e.what());
1431	>	PyErr_SetString ( SchedulerError, e.what() );
1432	>	return NULL;
1433		}catch (const std::exception& e) {
1434	<	SWIG_exception(SWIG_RuntimeError, e.what());
1434	>	PyErr_SetString ( BossError, e.what() );
1435	>	return NULL;
1436		}
1437		}
1438		resultobj = PyInt_FromLong((long)result);
#	Line 1387 \| Line 1504 \| *static PyObject _wrap_objectMap___setit**
1504		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1505
1506		}catch (const BossSchedFailure & e) {
1507	<	SWIG_exception(SWIG_ValueError, e.what());
1507	>	PyErr_SetString ( SchedulerError, e.what() );
1508	>	return NULL;
1509		}catch (const std::exception& e) {
1510	<	SWIG_exception(SWIG_RuntimeError, e.what());
1510	>	PyErr_SetString ( BossError, e.what() );
1511	>	return NULL;
1512		}
1513		}
1514		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1451 \| Line 1570 \| *static PyObject _wrap_objectMap_has_key**
1570		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1571
1572		}catch (const BossSchedFailure & e) {
1573	<	SWIG_exception(SWIG_ValueError, e.what());
1573	>	PyErr_SetString ( SchedulerError, e.what() );
1574	>	return NULL;
1575		}catch (const std::exception& e) {
1576	<	SWIG_exception(SWIG_RuntimeError, e.what());
1576	>	PyErr_SetString ( BossError, e.what() );
1577	>	return NULL;
1578		}
1579		}
1580		resultobj = PyInt_FromLong((long)result);
#	Line 1476 \| Line 1597 \| *static PyObject _wrap_objectMap_keys(Py**
1597		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1598
1599		}catch (const BossSchedFailure & e) {
1600	<	SWIG_exception(SWIG_ValueError, e.what());
1600	>	PyErr_SetString ( SchedulerError, e.what() );
1601	>	return NULL;
1602		}catch (const std::exception& e) {
1603	<	SWIG_exception(SWIG_RuntimeError, e.what());
1603	>	PyErr_SetString ( BossError, e.what() );
1604	>	return NULL;
1605		}
1606		}
1607		resultobj = result;
#	Line 1501 \| Line 1624 \| *static PyObject _wrap_objectMap_values(**
1624		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1625
1626		}catch (const BossSchedFailure & e) {
1627	<	SWIG_exception(SWIG_ValueError, e.what());
1627	>	PyErr_SetString ( SchedulerError, e.what() );
1628	>	return NULL;
1629		}catch (const std::exception& e) {
1630	<	SWIG_exception(SWIG_RuntimeError, e.what());
1630	>	PyErr_SetString ( BossError, e.what() );
1631	>	return NULL;
1632		}
1633		}
1634		resultobj = result;
#	Line 1526 \| Line 1651 \| *static PyObject _wrap_objectMap_items(P**
1651		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1652
1653		}catch (const BossSchedFailure & e) {
1654	<	SWIG_exception(SWIG_ValueError, e.what());
1654	>	PyErr_SetString ( SchedulerError, e.what() );
1655	>	return NULL;
1656		}catch (const std::exception& e) {
1657	<	SWIG_exception(SWIG_RuntimeError, e.what());
1657	>	PyErr_SetString ( BossError, e.what() );
1658	>	return NULL;
1659		}
1660		}
1661		resultobj = result;
#	Line 1559 \| Line 1686 \| *static PyObject _wrap_objectMap___conta**
1686		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1687
1688		}catch (const BossSchedFailure & e) {
1689	<	SWIG_exception(SWIG_ValueError, e.what());
1689	>	PyErr_SetString ( SchedulerError, e.what() );
1690	>	return NULL;
1691		}catch (const std::exception& e) {
1692	<	SWIG_exception(SWIG_RuntimeError, e.what());
1692	>	PyErr_SetString ( BossError, e.what() );
1693	>	return NULL;
1694		}
1695		}
1696		resultobj = PyInt_FromLong((long)result);
#	Line 1607 \| Line 1736 \| *static PyObject _wrap_delete_objectMap(**
1736		delete arg1;
1737
1738		}catch (const BossSchedFailure & e) {
1739	<	SWIG_exception(SWIG_ValueError, e.what());
1739	>	PyErr_SetString ( SchedulerError, e.what() );
1740	>	return NULL;
1741		}catch (const std::exception& e) {
1742	<	SWIG_exception(SWIG_RuntimeError, e.what());
1742	>	PyErr_SetString ( BossError, e.what() );
1743	>	return NULL;
1744		}
1745		}
1746		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1642 \| Line 1773 \| *static PyObject _wrap_new_vector_string**
1773		result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1774
1775		}catch (const BossSchedFailure & e) {
1776	<	SWIG_exception(SWIG_ValueError, e.what());
1776	>	PyErr_SetString ( SchedulerError, e.what() );
1777	>	return NULL;
1778		}catch (const std::exception& e) {
1779	<	SWIG_exception(SWIG_RuntimeError, e.what());
1779	>	PyErr_SetString ( BossError, e.what() );
1780	>	return NULL;
1781		}
1782		}
1783		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1679 \| Line 1812 \| *static PyObject _wrap_new_vector_string**
1812		result = (std::vector<std::string > )new std::vector<std::string >(arg1,(std::string const &)arg2);
1813
1814		}catch (const BossSchedFailure & e) {
1815	<	SWIG_exception(SWIG_ValueError, e.what());
1815	>	PyErr_SetString ( SchedulerError, e.what() );
1816	>	return NULL;
1817		}catch (const std::exception& e) {
1818	<	SWIG_exception(SWIG_RuntimeError, e.what());
1818	>	PyErr_SetString ( BossError, e.what() );
1819	>	return NULL;
1820		}
1821		}
1822		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1733 \| Line 1868 \| *static PyObject _wrap_new_vector_string**
1868		result = (std::vector<std::string > )new std::vector<std::string >((std::vector<std::string > const &)arg1);
1869
1870		}catch (const BossSchedFailure & e) {
1871	<	SWIG_exception(SWIG_ValueError, e.what());
1871	>	PyErr_SetString ( SchedulerError, e.what() );
1872	>	return NULL;
1873		}catch (const std::exception& e) {
1874	<	SWIG_exception(SWIG_RuntimeError, e.what());
1874	>	PyErr_SetString ( BossError, e.what() );
1875	>	return NULL;
1876		}
1877		}
1878		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1862 \| Line 1999 \| *static PyObject _wrap_vector_string___l**
1999		result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
2000
2001		}catch (const BossSchedFailure & e) {
2002	<	SWIG_exception(SWIG_ValueError, e.what());
2002	>	PyErr_SetString ( SchedulerError, e.what() );
2003	>	return NULL;
2004		}catch (const std::exception& e) {
2005	<	SWIG_exception(SWIG_RuntimeError, e.what());
2005	>	PyErr_SetString ( BossError, e.what() );
2006	>	return NULL;
2007		}
2008		}
2009		resultobj = PyInt_FromLong((long)result);
#	Line 1916 \| Line 2055 \| *static PyObject _wrap_vector_string___n**
2055		result = (bool)((std::vector<std::string > const *)arg1)->empty();
2056
2057		}catch (const BossSchedFailure & e) {
2058	<	SWIG_exception(SWIG_ValueError, e.what());
2058	>	PyErr_SetString ( SchedulerError, e.what() );
2059	>	return NULL;
2060		}catch (const std::exception& e) {
2061	<	SWIG_exception(SWIG_RuntimeError, e.what());
2061	>	PyErr_SetString ( BossError, e.what() );
2062	>	return NULL;
2063		}
2064		}
2065		resultobj = PyInt_FromLong((long)result);
#	Line 1940 \| Line 2081 \| *static PyObject _wrap_vector_string_cle**
2081		(arg1)->clear();
2082
2083		}catch (const BossSchedFailure & e) {
2084	<	SWIG_exception(SWIG_ValueError, e.what());
2084	>	PyErr_SetString ( SchedulerError, e.what() );
2085	>	return NULL;
2086		}catch (const std::exception& e) {
2087	<	SWIG_exception(SWIG_RuntimeError, e.what());
2087	>	PyErr_SetString ( BossError, e.what() );
2088	>	return NULL;
2089		}
2090		}
2091		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1972 \| Line 2115 \| *static PyObject _wrap_vector_string_app**
2115		(arg1)->push_back(arg2);
2116
2117		}catch (const BossSchedFailure & e) {
2118	<	SWIG_exception(SWIG_ValueError, e.what());
2118	>	PyErr_SetString ( SchedulerError, e.what() );
2119	>	return NULL;
2120		}catch (const std::exception& e) {
2121	<	SWIG_exception(SWIG_RuntimeError, e.what());
2121	>	PyErr_SetString ( BossError, e.what() );
2122	>	return NULL;
2123		}
2124		}
2125		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2050 \| Line 2195 \| *static PyObject _wrap_vector_string___g**
2195		result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2196
2197		}catch (const BossSchedFailure & e) {
2198	<	SWIG_exception(SWIG_ValueError, e.what());
2198	>	PyErr_SetString ( SchedulerError, e.what() );
2199	>	return NULL;
2200		}catch (const std::exception& e) {
2201	<	SWIG_exception(SWIG_RuntimeError, e.what());
2201	>	PyErr_SetString ( BossError, e.what() );
2202	>	return NULL;
2203		}
2204		}
2205		{
#	Line 2144 \| Line 2291 \| *static PyObject _wrap_vector_string___s**
2291		std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2292
2293		}catch (const BossSchedFailure & e) {
2294	<	SWIG_exception(SWIG_ValueError, e.what());
2294	>	PyErr_SetString ( SchedulerError, e.what() );
2295	>	return NULL;
2296		}catch (const std::exception& e) {
2297	<	SWIG_exception(SWIG_RuntimeError, e.what());
2297	>	PyErr_SetString ( BossError, e.what() );
2298	>	return NULL;
2299		}
2300		}
2301		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2193 \| Line 2342 \| *static PyObject _wrap_vector_string___d**
2342		std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2343
2344		}catch (const BossSchedFailure & e) {
2345	<	SWIG_exception(SWIG_ValueError, e.what());
2345	>	PyErr_SetString ( SchedulerError, e.what() );
2346	>	return NULL;
2347		}catch (const std::exception& e) {
2348	<	SWIG_exception(SWIG_RuntimeError, e.what());
2348	>	PyErr_SetString ( BossError, e.what() );
2349	>	return NULL;
2350		}
2351		}
2352		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2217 \| Line 2368 \| *static PyObject _wrap_delete_vector_str**
2368		delete arg1;
2369
2370		}catch (const BossSchedFailure & e) {
2371	<	SWIG_exception(SWIG_ValueError, e.what());
2371	>	PyErr_SetString ( SchedulerError, e.what() );
2372	>	return NULL;
2373		}catch (const std::exception& e) {
2374	<	SWIG_exception(SWIG_RuntimeError, e.what());
2374	>	PyErr_SetString ( BossError, e.what() );
2375	>	return NULL;
2376		}
2377		}
2378		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2236 \| Line 2389 \| *static PyObject vector_string_swigregi**
2389		Py_INCREF(obj);
2390		return Py_BuildValue((char *)"");
2391		}
2392	<	static PyObject _wrap_BossSession_show(PyObject self, PyObject *args) {
2392	>	static PyObject _wrap_new_BossSession(PyObject self, PyObject *args) {
2393		PyObject *resultobj;
2394	<	BossSession arg1 = (BossSession ) 0 ;
2395	<	std::vector<std::string > *arg2 = 0 ;
2396	<	PyObject *result;
2394	>	std::string arg1 = (std::string) "" ;
2395	>	std::string arg2 = (std::string) "2" ;
2396	>	std::string arg3 = (std::string) "" ;
2397	>	std::string arg4 = (std::string) "" ;
2398	>	BossSession *result;
2399		PyObject * obj0 = 0 ;
2400		PyObject * obj1 = 0 ;
2401	+	PyObject * obj2 = 0 ;
2402	+	PyObject * obj3 = 0 ;
2403
2404	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2405	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2406	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2407	<	if (arg2 == NULL) {
2408	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2404	>	if(!PyArg_ParseTuple(args,(char *)"\|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2405	>	if (obj0) {
2406	>	{
2407	>	if (PyString_Check(obj0))
2408	>	arg1 = std::string(PyString_AsString(obj0));
2409	>	else
2410	>	SWIG_exception(SWIG_TypeError, "string expected");
2411	>	}
2412	>	}
2413	>	if (obj1) {
2414	>	{
2415	>	if (PyString_Check(obj1))
2416	>	arg2 = std::string(PyString_AsString(obj1));
2417	>	else
2418	>	SWIG_exception(SWIG_TypeError, "string expected");
2419	>	}
2420	>	}
2421	>	if (obj2) {
2422	>	{
2423	>	if (PyString_Check(obj2))
2424	>	arg3 = std::string(PyString_AsString(obj2));
2425	>	else
2426	>	SWIG_exception(SWIG_TypeError, "string expected");
2427	>	}
2428	>	}
2429	>	if (obj3) {
2430	>	{
2431	>	if (PyString_Check(obj3))
2432	>	arg4 = std::string(PyString_AsString(obj3));
2433	>	else
2434	>	SWIG_exception(SWIG_TypeError, "string expected");
2435	>	}
2436		}
2437		{
2438		try {
2439	<	result = (PyObject )BossSession_show(arg1,arg2);
2439	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2440
2441		}catch (const BossSchedFailure & e) {
2442	<	SWIG_exception(SWIG_ValueError, e.what());
2442	>	PyErr_SetString ( SchedulerError, e.what() );
2443	>	return NULL;
2444		}catch (const std::exception& e) {
2445	<	SWIG_exception(SWIG_RuntimeError, e.what());
2445	>	PyErr_SetString ( BossError, e.what() );
2446	>	return NULL;
2447		}
2448		}
2449	<	resultobj = result;
2449	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2450		return resultobj;
2451		fail:
2452		return NULL;
2453		}
2454
2455
2456	<	static PyObject _wrap_BossSession_CHTools(PyObject self, PyObject *args) {
2456	>	static PyObject _wrap_delete_BossSession(PyObject self, PyObject *args) {
2457		PyObject *resultobj;
2458		BossSession arg1 = (BossSession ) 0 ;
2273	–	PyObject *result;
2459		PyObject * obj0 = 0 ;
2460
2461	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2461	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2462		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2463		{
2464		try {
2465	<	result = (PyObject *)BossSession_CHTools(arg1);
2465	>	delete arg1;
2466
2467		}catch (const BossSchedFailure & e) {
2468	<	SWIG_exception(SWIG_ValueError, e.what());
2468	>	PyErr_SetString ( SchedulerError, e.what() );
2469	>	return NULL;
2470		}catch (const std::exception& e) {
2471	<	SWIG_exception(SWIG_RuntimeError, e.what());
2471	>	PyErr_SetString ( BossError, e.what() );
2472	>	return NULL;
2473		}
2474		}
2475	<	resultobj = result;
2475	>	Py_INCREF(Py_None); resultobj = Py_None;
2476		return resultobj;
2477		fail:
2478		return NULL;
2479		}
2480
2481
2482	<	static PyObject _wrap_BossSession_ProgramTypes(PyObject self, PyObject *args) {
2482	>	static PyObject _wrap_BossSession_resetDB(PyObject self, PyObject *args) {
2483		PyObject *resultobj;
2484		BossSession arg1 = (BossSession ) 0 ;
2298	–	PyObject *result;
2485		PyObject * obj0 = 0 ;
2486
2487	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2487	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2488		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2489		{
2490		try {
2491	<	result = (PyObject *)BossSession_ProgramTypes(arg1);
2491	>	(arg1)->resetDB();
2492
2493		}catch (const BossSchedFailure & e) {
2494	<	SWIG_exception(SWIG_ValueError, e.what());
2494	>	PyErr_SetString ( SchedulerError, e.what() );
2495	>	return NULL;
2496		}catch (const std::exception& e) {
2497	<	SWIG_exception(SWIG_RuntimeError, e.what());
2497	>	PyErr_SetString ( BossError, e.what() );
2498	>	return NULL;
2499		}
2500		}
2501	<	resultobj = result;
2501	>	Py_INCREF(Py_None); resultobj = Py_None;
2502		return resultobj;
2503		fail:
2504		return NULL;
2505		}
2506
2507
2508	<	static PyObject _wrap_BossSession_RTMons(PyObject self, PyObject *args) {
2508	>	static PyObject _wrap_BossSession_clear(PyObject self, PyObject *args) {
2509		PyObject *resultobj;
2510		BossSession arg1 = (BossSession ) 0 ;
2323	–	PyObject *result;
2511		PyObject * obj0 = 0 ;
2512
2513	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2513	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2514		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2515		{
2516		try {
2517	<	result = (PyObject *)BossSession_RTMons(arg1);
2517	>	(arg1)->clear();
2518
2519		}catch (const BossSchedFailure & e) {
2520	<	SWIG_exception(SWIG_ValueError, e.what());
2520	>	PyErr_SetString ( SchedulerError, e.what() );
2521	>	return NULL;
2522		}catch (const std::exception& e) {
2523	<	SWIG_exception(SWIG_RuntimeError, e.what());
2523	>	PyErr_SetString ( BossError, e.what() );
2524	>	return NULL;
2525		}
2526		}
2527	<	resultobj = result;
2527	>	Py_INCREF(Py_None); resultobj = Py_None;
2528		return resultobj;
2529		fail:
2530		return NULL;
2531		}
2532
2533
2534	<	static PyObject _wrap_BossSession_schedulers(PyObject self, PyObject *args) {
2534	>	static PyObject _wrap_BossSession_task_begin(PyObject self, PyObject *args) {
2535		PyObject *resultobj;
2536		BossSession arg1 = (BossSession ) 0 ;
2537	<	PyObject *result;
2537	>	BossSession::task_iterator result;
2538		PyObject * obj0 = 0 ;
2539
2540	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2540	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_begin",&obj0)) goto fail;
2541		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2542		{
2543		try {
2544	<	result = (PyObject *)BossSession_schedulers(arg1);
2544	>	result = ((BossSession const *)arg1)->task_begin();
2545
2546		}catch (const BossSchedFailure & e) {
2547	<	SWIG_exception(SWIG_ValueError, e.what());
2547	>	PyErr_SetString ( SchedulerError, e.what() );
2548	>	return NULL;
2549		}catch (const std::exception& e) {
2550	<	SWIG_exception(SWIG_RuntimeError, e.what());
2550	>	PyErr_SetString ( BossError, e.what() );
2551	>	return NULL;
2552		}
2553		}
2554	<	resultobj = result;
2554	>	{
2555	>	BossSession::task_iterator * resultptr;
2556	>	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2557	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2558	>	}
2559		return resultobj;
2560		fail:
2561		return NULL;
2562		}
2563
2564
2565	<	static PyObject _wrap_BossSession_schedListMatch(PyObject self, PyObject *args) {
2565	>	static PyObject _wrap_BossSession_task_end(PyObject self, PyObject *args) {
2566		PyObject *resultobj;
2567		BossSession arg1 = (BossSession ) 0 ;
2568	<	std::string *arg2 = 0 ;
2374	<	std::string *arg3 = 0 ;
2375	<	std::string const &arg4_defvalue = "" ;
2376	<	std::string arg4 = (std::string ) &arg4_defvalue ;
2377	<	std::string const &arg5_defvalue = "" ;
2378	<	std::string arg5 = (std::string ) &arg5_defvalue ;
2379	<	bool arg6 = (bool) false ;
2380	<	PyObject *result;
2381	<	std::string temp2 ;
2382	<	std::string temp3 ;
2383	<	std::string temp4 ;
2384	<	std::string temp5 ;
2568	>	BossSession::task_iterator result;
2569		PyObject * obj0 = 0 ;
2386	–	PyObject * obj1 = 0 ;
2387	–	PyObject * obj2 = 0 ;
2388	–	PyObject * obj3 = 0 ;
2389	–	PyObject * obj4 = 0 ;
2390	–	PyObject * obj5 = 0 ;
2570
2571	<	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2571	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_end",&obj0)) goto fail;
2572		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2573		{
2574	<	if (PyString_Check(obj1)) {
2575	<	temp2 = std::string(PyString_AsString(obj1));
2576	<	arg2 = &temp2;
2577	<	}else {
2578	<	SWIG_exception(SWIG_TypeError, "string expected");
2574	>	try {
2575	>	result = ((BossSession const *)arg1)->task_end();
2576	>
2577	>	}catch (const BossSchedFailure & e) {
2578	>	PyErr_SetString ( SchedulerError, e.what() );
2579	>	return NULL;
2580	>	}catch (const std::exception& e) {
2581	>	PyErr_SetString ( BossError, e.what() );
2582	>	return NULL;
2583		}
2584		}
2585		{
2586	<	if (PyString_Check(obj2)) {
2587	<	temp3 = std::string(PyString_AsString(obj2));
2588	<	arg3 = &temp3;
2406	<	}else {
2407	<	SWIG_exception(SWIG_TypeError, "string expected");
2408	<	}
2409	<	}
2410	<	if (obj3) {
2411	<	{
2412	<	if (PyString_Check(obj3)) {
2413	<	temp4 = std::string(PyString_AsString(obj3));
2414	<	arg4 = &temp4;
2415	<	}else {
2416	<	SWIG_exception(SWIG_TypeError, "string expected");
2417	<	}
2418	<	}
2419	<	}
2420	<	if (obj4) {
2421	<	{
2422	<	if (PyString_Check(obj4)) {
2423	<	temp5 = std::string(PyString_AsString(obj4));
2424	<	arg5 = &temp5;
2425	<	}else {
2426	<	SWIG_exception(SWIG_TypeError, "string expected");
2427	<	}
2428	<	}
2429	<	}
2430	<	if (obj5) {
2431	<	arg6 = PyInt_AsLong(obj5) ? true : false;
2432	<	if (PyErr_Occurred()) SWIG_fail;
2586	>	BossSession::task_iterator * resultptr;
2587	>	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2588	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2589		}
2590	+	return resultobj;
2591	+	fail:
2592	+	return NULL;
2593	+	}
2594	+
2595	+
2596	+	static PyObject _wrap_BossSession_tasksInMemory(PyObject self, PyObject *args) {
2597	+	PyObject *resultobj;
2598	+	BossSession arg1 = (BossSession ) 0 ;
2599	+	unsigned int result;
2600	+	PyObject * obj0 = 0 ;
2601	+
2602	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
2603	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2604		{
2605		try {
2606	<	result = (PyObject )BossSession_schedListMatch(arg1,(std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6);
2606	>	result = (unsigned int)((BossSession const *)arg1)->tasksInMemory();
2607
2608		}catch (const BossSchedFailure & e) {
2609	<	SWIG_exception(SWIG_ValueError, e.what());
2609	>	PyErr_SetString ( SchedulerError, e.what() );
2610	>	return NULL;
2611		}catch (const std::exception& e) {
2612	<	SWIG_exception(SWIG_RuntimeError, e.what());
2612	>	PyErr_SetString ( BossError, e.what() );
2613	>	return NULL;
2614		}
2615		}
2616	<	resultobj = result;
2616	>	resultobj = PyInt_FromLong((long)result);
2617		return resultobj;
2618		fail:
2619		return NULL;
2620		}
2621
2622
2623	<	static PyObject _wrap_BossSession_queryTasks(PyObject self, PyObject *args) {
2623	>	static PyObject _wrap_BossSession_locate(PyObject self, PyObject *args) {
2624		PyObject *resultobj;
2625		BossSession arg1 = (BossSession ) 0 ;
2626	<	int arg2 = (int) SCHEDULED ;
2627	<	std::string const &arg3_defvalue = "all" ;
2456	<	std::string arg3 = (std::string ) &arg3_defvalue ;
2457	<	std::string const &arg4_defvalue = "all" ;
2458	<	std::string arg4 = (std::string ) &arg4_defvalue ;
2459	<	std::string const &arg5_defvalue = "" ;
2460	<	std::string arg5 = (std::string ) &arg5_defvalue ;
2461	<	std::string arg6 = (std::string) "" ;
2462	<	std::string arg7 = (std::string) "" ;
2463	<	std::string arg8 = (std::string) "" ;
2464	<	std::string arg9 = (std::string) "" ;
2465	<	bool arg10 = (bool) false ;
2466	<	PyObject *result;
2467	<	std::string temp3 ;
2468	<	std::string temp4 ;
2469	<	std::string temp5 ;
2626	>	unsigned int arg2 ;
2627	>	BossTask *result;
2628		PyObject * obj0 = 0 ;
2629	<	PyObject * obj2 = 0 ;
2472	<	PyObject * obj3 = 0 ;
2473	<	PyObject * obj4 = 0 ;
2474	<	PyObject * obj5 = 0 ;
2475	<	PyObject * obj6 = 0 ;
2476	<	PyObject * obj7 = 0 ;
2477	<	PyObject * obj8 = 0 ;
2478	<	PyObject * obj9 = 0 ;
2629	>	PyObject * obj1 = 0 ;
2630
2631	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2631	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
2632		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2633	<	if (obj2) {
2634	<	{
2484	<	if (PyString_Check(obj2)) {
2485	<	temp3 = std::string(PyString_AsString(obj2));
2486	<	arg3 = &temp3;
2487	<	}else {
2488	<	SWIG_exception(SWIG_TypeError, "string expected");
2489	<	}
2490	<	}
2491	<	}
2492	<	if (obj3) {
2493	<	{
2494	<	if (PyString_Check(obj3)) {
2495	<	temp4 = std::string(PyString_AsString(obj3));
2496	<	arg4 = &temp4;
2497	<	}else {
2498	<	SWIG_exception(SWIG_TypeError, "string expected");
2499	<	}
2500	<	}
2501	<	}
2502	<	if (obj4) {
2503	<	{
2504	<	if (PyString_Check(obj4)) {
2505	<	temp5 = std::string(PyString_AsString(obj4));
2506	<	arg5 = &temp5;
2507	<	}else {
2508	<	SWIG_exception(SWIG_TypeError, "string expected");
2509	<	}
2510	<	}
2511	<	}
2512	<	if (obj5) {
2513	<	{
2514	<	if (PyString_Check(obj5))
2515	<	arg6 = std::string(PyString_AsString(obj5));
2516	<	else
2517	<	SWIG_exception(SWIG_TypeError, "string expected");
2518	<	}
2519	<	}
2520	<	if (obj6) {
2521	<	{
2522	<	if (PyString_Check(obj6))
2523	<	arg7 = std::string(PyString_AsString(obj6));
2524	<	else
2525	<	SWIG_exception(SWIG_TypeError, "string expected");
2526	<	}
2527	<	}
2528	<	if (obj7) {
2529	<	{
2530	<	if (PyString_Check(obj7))
2531	<	arg8 = std::string(PyString_AsString(obj7));
2532	<	else
2533	<	SWIG_exception(SWIG_TypeError, "string expected");
2534	<	}
2535	<	}
2536	<	if (obj8) {
2537	<	{
2538	<	if (PyString_Check(obj8))
2539	<	arg9 = std::string(PyString_AsString(obj8));
2540	<	else
2541	<	SWIG_exception(SWIG_TypeError, "string expected");
2542	<	}
2543	<	}
2544	<	if (obj9) {
2545	<	arg10 = PyInt_AsLong(obj9) ? true : false;
2546	<	if (PyErr_Occurred()) SWIG_fail;
2547	<	}
2633	>	arg2 = (unsigned int) PyInt_AsLong(obj1);
2634	>	if (PyErr_Occurred()) SWIG_fail;
2635		{
2636		try {
2637	<	result = (PyObject )BossSession_queryTasks(arg1,arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5,arg6,arg7,arg8,arg9,arg10);
2637	>	result = (BossTask )((BossSession const )arg1)->locate(arg2);
2638
2639		}catch (const BossSchedFailure & e) {
2640	<	SWIG_exception(SWIG_ValueError, e.what());
2640	>	PyErr_SetString ( SchedulerError, e.what() );
2641	>	return NULL;
2642		}catch (const std::exception& e) {
2643	<	SWIG_exception(SWIG_RuntimeError, e.what());
2643	>	PyErr_SetString ( BossError, e.what() );
2644	>	return NULL;
2645		}
2646		}
2647	<	resultobj = result;
2647	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2648		return resultobj;
2649		fail:
2650		return NULL;
2651		}
2652
2653
2654	<	static PyObject _wrap_new_BossSession(PyObject self, PyObject *args) {
2654	>	static PyObject _wrap_BossSession_makeBossTask(PyObject self, PyObject *args) {
2655		PyObject *resultobj;
2656	<	std::string arg1 = (std::string) "" ;
2657	<	std::string arg2 = (std::string) "2" ;
2658	<	std::string arg3 = (std::string) "" ;
2659	<	BossSession *result;
2656	>	BossSession arg1 = (BossSession ) 0 ;
2657	>	std::string const &arg2_defvalue = "" ;
2658	>	std::string arg2 = (std::string ) &arg2_defvalue ;
2659	>	BossTask *result;
2660	>	std::string temp2 ;
2661		PyObject * obj0 = 0 ;
2662		PyObject * obj1 = 0 ;
2573	–	PyObject * obj2 = 0 ;
2663
2664	<	if(!PyArg_ParseTuple(args,(char *)"\|OOO:new_BossSession",&obj0,&obj1,&obj2)) goto fail;
2665	<	if (obj0) {
2577	<	{
2578	<	if (PyString_Check(obj0))
2579	<	arg1 = std::string(PyString_AsString(obj0));
2580	<	else
2581	<	SWIG_exception(SWIG_TypeError, "string expected");
2582	<	}
2583	<	}
2664	>	if(!PyArg_ParseTuple(args,(char *)"O\|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2665	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2666		if (obj1) {
2667		{
2668	<	if (PyString_Check(obj1))
2669	<	arg2 = std::string(PyString_AsString(obj1));
2670	<	else
2671	<	SWIG_exception(SWIG_TypeError, "string expected");
2672	<	}
2673	<	}
2592	<	if (obj2) {
2593	<	{
2594	<	if (PyString_Check(obj2))
2595	<	arg3 = std::string(PyString_AsString(obj2));
2596	<	else
2597	<	SWIG_exception(SWIG_TypeError, "string expected");
2668	>	if (PyString_Check(obj1)) {
2669	>	temp2 = std::string(PyString_AsString(obj1));
2670	>	arg2 = &temp2;
2671	>	}else {
2672	>	SWIG_exception(SWIG_TypeError, "string expected");
2673	>	}
2674		}
2675		}
2676		{
2677		try {
2678	<	result = (BossSession *)new BossSession(arg1,arg2,arg3);
2678	>	result = (BossTask )(arg1)->makeBossTask((std::string const &)arg2);
2679
2680		}catch (const BossSchedFailure & e) {
2681	<	SWIG_exception(SWIG_ValueError, e.what());
2681	>	PyErr_SetString ( SchedulerError, e.what() );
2682	>	return NULL;
2683		}catch (const std::exception& e) {
2684	<	SWIG_exception(SWIG_RuntimeError, e.what());
2684	>	PyErr_SetString ( BossError, e.what() );
2685	>	return NULL;
2686		}
2687		}
2688	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2688	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2689		return resultobj;
2690		fail:
2691		return NULL;
2692		}
2693
2694
2695	<	static PyObject _wrap_delete_BossSession(PyObject self, PyObject *args) {
2695	>	static PyObject _wrap_BossSession_destroyBossTask(PyObject self, PyObject *args) {
2696		PyObject *resultobj;
2697		BossSession arg1 = (BossSession ) 0 ;
2698	+	BossTask arg2 = (BossTask ) 0 ;
2699		PyObject * obj0 = 0 ;
2700	+	PyObject * obj1 = 0 ;
2701
2702	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2702	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2703		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2704	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2705		{
2706		try {
2707	<	delete arg1;
2707	>	(arg1)->destroyBossTask(arg2);
2708
2709		}catch (const BossSchedFailure & e) {
2710	<	SWIG_exception(SWIG_ValueError, e.what());
2710	>	PyErr_SetString ( SchedulerError, e.what() );
2711	>	return NULL;
2712		}catch (const std::exception& e) {
2713	<	SWIG_exception(SWIG_RuntimeError, e.what());
2713	>	PyErr_SetString ( BossError, e.what() );
2714	>	return NULL;
2715		}
2716		}
2717		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2638 \| Line 2721 \| *static PyObject _wrap_delete_BossSessio**
2721		}
2722
2723
2724	<	static PyObject _wrap_BossSession_resetDB(PyObject self, PyObject *args) {
2724	>	static PyObject _wrap_BossSession_showCHTools(PyObject self, PyObject *args) {
2725		PyObject *resultobj;
2726		BossSession arg1 = (BossSession ) 0 ;
2727	+	std::vector<std::string > result;
2728		PyObject * obj0 = 0 ;
2729
2730	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2730	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2731		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2732		{
2733		try {
2734	<	(arg1)->resetDB();
2734	>	result = (arg1)->showCHTools();
2735
2736		}catch (const BossSchedFailure & e) {
2737	<	SWIG_exception(SWIG_ValueError, e.what());
2737	>	PyErr_SetString ( SchedulerError, e.what() );
2738	>	return NULL;
2739		}catch (const std::exception& e) {
2740	<	SWIG_exception(SWIG_RuntimeError, e.what());
2740	>	PyErr_SetString ( BossError, e.what() );
2741	>	return NULL;
2742		}
2743		}
2744	<	Py_INCREF(Py_None); resultobj = Py_None;
2744	>	{
2745	>	resultobj = PyTuple_New((&result)->size());
2746	>	for (unsigned int i=0; i<(&result)->size(); i++)
2747	>	PyTuple_SetItem(resultobj,i,
2748	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2749	>	}
2750		return resultobj;
2751		fail:
2752		return NULL;
2753		}
2754
2755
2756	<	static PyObject _wrap_BossSession_clear(PyObject self, PyObject *args) {
2756	>	static PyObject _wrap_BossSession_showProgramTypes(PyObject self, PyObject *args) {
2757		PyObject *resultobj;
2758		BossSession arg1 = (BossSession ) 0 ;
2759	+	std::vector<std::string > result;
2760		PyObject * obj0 = 0 ;
2761
2762	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2762	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2763		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2764		{
2765		try {
2766	<	(arg1)->clear();
2766	>	result = (arg1)->showProgramTypes();
2767
2768		}catch (const BossSchedFailure & e) {
2769	<	SWIG_exception(SWIG_ValueError, e.what());
2769	>	PyErr_SetString ( SchedulerError, e.what() );
2770	>	return NULL;
2771		}catch (const std::exception& e) {
2772	<	SWIG_exception(SWIG_RuntimeError, e.what());
2772	>	PyErr_SetString ( BossError, e.what() );
2773	>	return NULL;
2774		}
2775		}
2776	<	Py_INCREF(Py_None); resultobj = Py_None;
2776	>	{
2777	>	resultobj = PyTuple_New((&result)->size());
2778	>	for (unsigned int i=0; i<(&result)->size(); i++)
2779	>	PyTuple_SetItem(resultobj,i,
2780	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2781	>	}
2782		return resultobj;
2783		fail:
2784		return NULL;
2785		}
2786
2787
2788	<	static PyObject _wrap_BossSession_makeBossTask(PyObject self, PyObject *args) {
2788	>	static PyObject _wrap_BossSession_showRTMon(PyObject self, PyObject *args) {
2789		PyObject *resultobj;
2790		BossSession arg1 = (BossSession ) 0 ;
2791	<	std::string const &arg2_defvalue = "" ;
2693	<	std::string arg2 = (std::string ) &arg2_defvalue ;
2694	<	BossTask *result;
2695	<	std::string temp2 ;
2791	>	std::vector<std::string > result;
2792		PyObject * obj0 = 0 ;
2697	–	PyObject * obj1 = 0 ;
2793
2794	<	if(!PyArg_ParseTuple(args,(char *)"O\|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2794	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2795		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2701	–	if (obj1) {
2702	–	{
2703	–	if (PyString_Check(obj1)) {
2704	–	temp2 = std::string(PyString_AsString(obj1));
2705	–	arg2 = &temp2;
2706	–	}else {
2707	–	SWIG_exception(SWIG_TypeError, "string expected");
2708	–	}
2709	–	}
2710	–	}
2796		{
2797		try {
2798	<	result = (BossTask )(arg1)->makeBossTask((std::string const &)arg2);
2798	>	result = (arg1)->showRTMon();
2799
2800		}catch (const BossSchedFailure & e) {
2801	<	SWIG_exception(SWIG_ValueError, e.what());
2801	>	PyErr_SetString ( SchedulerError, e.what() );
2802	>	return NULL;
2803		}catch (const std::exception& e) {
2804	<	SWIG_exception(SWIG_RuntimeError, e.what());
2804	>	PyErr_SetString ( BossError, e.what() );
2805	>	return NULL;
2806		}
2807		}
2808	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2808	>	{
2809	>	resultobj = PyTuple_New((&result)->size());
2810	>	for (unsigned int i=0; i<(&result)->size(); i++)
2811	>	PyTuple_SetItem(resultobj,i,
2812	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2813	>	}
2814		return resultobj;
2815		fail:
2816		return NULL;
2817		}
2818
2819
2820	<	static PyObject _wrap_BossSession_destroyBossTask(PyObject self, PyObject *args) {
2820	>	static PyObject _wrap_BossSession_showSchedulers(PyObject self, PyObject *args) {
2821		PyObject *resultobj;
2822		BossSession arg1 = (BossSession ) 0 ;
2823	<	BossTask arg2 = (BossTask ) 0 ;
2823	>	std::vector<std::string > result;
2824		PyObject * obj0 = 0 ;
2733	–	PyObject * obj1 = 0 ;
2825
2826	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2826	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2827		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2737	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2828		{
2829		try {
2830	<	(arg1)->destroyBossTask(arg2);
2830	>	result = (arg1)->showSchedulers();
2831
2832		}catch (const BossSchedFailure & e) {
2833	<	SWIG_exception(SWIG_ValueError, e.what());
2833	>	PyErr_SetString ( SchedulerError, e.what() );
2834	>	return NULL;
2835		}catch (const std::exception& e) {
2836	<	SWIG_exception(SWIG_RuntimeError, e.what());
2836	>	PyErr_SetString ( BossError, e.what() );
2837	>	return NULL;
2838		}
2839		}
2840	<	Py_INCREF(Py_None); resultobj = Py_None;
2840	>	{
2841	>	resultobj = PyTuple_New((&result)->size());
2842	>	for (unsigned int i=0; i<(&result)->size(); i++)
2843	>	PyTuple_SetItem(resultobj,i,
2844	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2845	>	}
2846		return resultobj;
2847		fail:
2848		return NULL;
#	Line 2765 \| Line 2862 \| *static PyObject _wrap_BossSession_defau**
2862		result = (arg1)->defaultCHTool();
2863
2864		}catch (const BossSchedFailure & e) {
2865	<	SWIG_exception(SWIG_ValueError, e.what());
2865	>	PyErr_SetString ( SchedulerError, e.what() );
2866	>	return NULL;
2867		}catch (const std::exception& e) {
2868	<	SWIG_exception(SWIG_RuntimeError, e.what());
2868	>	PyErr_SetString ( BossError, e.what() );
2869	>	return NULL;
2870		}
2871		}
2872		{
#	Line 2792 \| Line 2891 \| *static PyObject _wrap_BossSession_defau**
2891		result = (arg1)->defaultProgramType();
2892
2893		}catch (const BossSchedFailure & e) {
2894	<	SWIG_exception(SWIG_ValueError, e.what());
2894	>	PyErr_SetString ( SchedulerError, e.what() );
2895	>	return NULL;
2896		}catch (const std::exception& e) {
2897	<	SWIG_exception(SWIG_RuntimeError, e.what());
2897	>	PyErr_SetString ( BossError, e.what() );
2898	>	return NULL;
2899		}
2900		}
2901		{
#	Line 2819 \| Line 2920 \| *static PyObject _wrap_BossSession_defau**
2920		result = (arg1)->defaultRTMon();
2921
2922		}catch (const BossSchedFailure & e) {
2923	<	SWIG_exception(SWIG_ValueError, e.what());
2923	>	PyErr_SetString ( SchedulerError, e.what() );
2924	>	return NULL;
2925		}catch (const std::exception& e) {
2926	<	SWIG_exception(SWIG_RuntimeError, e.what());
2926	>	PyErr_SetString ( BossError, e.what() );
2927	>	return NULL;
2928		}
2929		}
2930		{
#	Line 2846 \| Line 2949 \| *static PyObject _wrap_BossSession_defau**
2949		result = (arg1)->defaultScheduler();
2950
2951		}catch (const BossSchedFailure & e) {
2952	<	SWIG_exception(SWIG_ValueError, e.what());
2952	>	PyErr_SetString ( SchedulerError, e.what() );
2953	>	return NULL;
2954		}catch (const std::exception& e) {
2955	<	SWIG_exception(SWIG_RuntimeError, e.what());
2955	>	PyErr_SetString ( BossError, e.what() );
2956	>	return NULL;
2957		}
2958		}
2959		{
#	Line 2873 \| Line 2978 \| *static PyObject _wrap_BossSession_versi**
2978		result = (arg1)->version();
2979
2980		}catch (const BossSchedFailure & e) {
2981	<	SWIG_exception(SWIG_ValueError, e.what());
2981	>	PyErr_SetString ( SchedulerError, e.what() );
2982	>	return NULL;
2983		}catch (const std::exception& e) {
2984	<	SWIG_exception(SWIG_RuntimeError, e.what());
2984	>	PyErr_SetString ( BossError, e.what() );
2985	>	return NULL;
2986		}
2987		}
2988		{
#	Line 2900 \| Line 3007 \| *static PyObject _wrap_BossSession_clien**
3007		result = (arg1)->clientID();
3008
3009		}catch (const BossSchedFailure & e) {
3010	<	SWIG_exception(SWIG_ValueError, e.what());
3010	>	PyErr_SetString ( SchedulerError, e.what() );
3011	>	return NULL;
3012		}catch (const std::exception& e) {
3013	<	SWIG_exception(SWIG_RuntimeError, e.what());
3013	>	PyErr_SetString ( BossError, e.what() );
3014	>	return NULL;
3015		}
3016		}
3017		{
#	Line 2933 \| Line 3042 \| *static PyObject _wrap_BossSession_showC**
3042		result = (int)(arg1)->showConfigs(arg2);
3043
3044		}catch (const BossSchedFailure & e) {
3045	<	SWIG_exception(SWIG_ValueError, e.what());
3045	>	PyErr_SetString ( SchedulerError, e.what() );
3046	>	return NULL;
3047		}catch (const std::exception& e) {
3048	<	SWIG_exception(SWIG_RuntimeError, e.what());
3048	>	PyErr_SetString ( BossError, e.what() );
3049	>	return NULL;
3050		}
3051		}
3052		resultobj = PyInt_FromLong((long)result);
#	Line 2988 \| Line 3099 \| *static PyObject _wrap_BossSession_RTupd**
3099		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
3100
3101		}catch (const BossSchedFailure & e) {
3102	<	SWIG_exception(SWIG_ValueError, e.what());
3102	>	PyErr_SetString ( SchedulerError, e.what() );
3103	>	return NULL;
3104		}catch (const std::exception& e) {
3105	<	SWIG_exception(SWIG_RuntimeError, e.what());
3105	>	PyErr_SetString ( BossError, e.what() );
3106	>	return NULL;
3107		}
3108		}
3109		resultobj = PyInt_FromLong((long)result);
#	Line 3005 \| Line 3118 \| *static PyObject _wrap_BossSession_listM**
3118		BossSession arg1 = (BossSession ) 0 ;
3119		std::string *arg2 = 0 ;
3120		std::string *arg3 = 0 ;
3121	<	bool arg4 = (bool) false ;
3121	>	std::string const &arg4_defvalue = "" ;
3122	>	std::string arg4 = (std::string ) &arg4_defvalue ;
3123		std::string const &arg5_defvalue = "" ;
3124		std::string arg5 = (std::string ) &arg5_defvalue ;
3125	<	std::string const &arg6_defvalue = "" ;
3012	<	std::string arg6 = (std::string ) &arg6_defvalue ;
3125	>	unsigned int arg6 = (unsigned int) 0 ;
3126		std::vector<std::string > result;
3127		std::string temp2 ;
3128		std::string temp3 ;
3129	+	std::string temp4 ;
3130		std::string temp5 ;
3017	–	std::string temp6 ;
3131		PyObject * obj0 = 0 ;
3132		PyObject * obj1 = 0 ;
3133		PyObject * obj2 = 0 ;
#	Line 3041 \| Line 3154 \| *static PyObject _wrap_BossSession_listM**
3154		}
3155		}
3156		if (obj3) {
3157	<	arg4 = PyInt_AsLong(obj3) ? true : false;
3158	<	if (PyErr_Occurred()) SWIG_fail;
3157	>	{
3158	>	if (PyString_Check(obj3)) {
3159	>	temp4 = std::string(PyString_AsString(obj3));
3160	>	arg4 = &temp4;
3161	>	}else {
3162	>	SWIG_exception(SWIG_TypeError, "string expected");
3163	>	}
3164	>	}
3165		}
3166		if (obj4) {
3167		{
#	Line 3055 \| Line 3174 \| *static PyObject _wrap_BossSession_listM**
3174		}
3175		}
3176		if (obj5) {
3177	<	{
3178	<	if (PyString_Check(obj5)) {
3060	<	temp6 = std::string(PyString_AsString(obj5));
3061	<	arg6 = &temp6;
3062	<	}else {
3063	<	SWIG_exception(SWIG_TypeError, "string expected");
3064	<	}
3065	<	}
3177	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3178	>	if (PyErr_Occurred()) SWIG_fail;
3179		}
3180		{
3181		try {
3182	<	result = (arg1)->listMatch((std::string const &)arg2,(std::string const &)arg3,arg4,(std::string const &)arg5,(std::string const &)arg6);
3182	>	result = (arg1)->listMatch((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5,arg6);
3183
3184		}catch (const BossSchedFailure & e) {
3185	<	SWIG_exception(SWIG_ValueError, e.what());
3185	>	PyErr_SetString ( SchedulerError, e.what() );
3186	>	return NULL;
3187		}catch (const std::exception& e) {
3188	<	SWIG_exception(SWIG_RuntimeError, e.what());
3188	>	PyErr_SetString ( BossError, e.what() );
3189	>	return NULL;
3190		}
3191		}
3192		{
#	Line 3086 \| Line 3201 \| *static PyObject _wrap_BossSession_listM**
3201		}
3202
3203
3204	<	static PyObject _wrap_BossSession_schedulerQuery(PyObject self, PyObject *args) {
3204	>	static PyObject _wrap_BossSession_query(PyObject self, PyObject *args) {
3205		PyObject *resultobj;
3206		BossSession arg1 = (BossSession ) 0 ;
3207		int arg2 = (int) SCHEDULED ;
#	Line 3100 \| Line 3215 \| *static PyObject _wrap_BossSession_sched**
3215		std::string arg7 = (std::string) "" ;
3216		std::string arg8 = (std::string) "" ;
3217		std::string arg9 = (std::string) "" ;
3218	+	unsigned int arg10 = (unsigned int) 0 ;
3219	+	bool arg11 = (bool) false ;
3220		std::string temp3 ;
3221		std::string temp4 ;
3222		std::string temp5 ;
#	Line 3111 \| Line 3228 \| *static PyObject _wrap_BossSession_sched**
3228		PyObject * obj6 = 0 ;
3229		PyObject * obj7 = 0 ;
3230		PyObject * obj8 = 0 ;
3231	+	PyObject * obj9 = 0 ;
3232	+	PyObject * obj10 = 0 ;
3233
3234	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3234	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3235		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3236		if (obj2) {
3237		{
#	Line 3176 \| Line 3295 \| *static PyObject _wrap_BossSession_sched**
3295		SWIG_exception(SWIG_TypeError, "string expected");
3296		}
3297		}
3298	+	if (obj9) {
3299	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3300	+	if (PyErr_Occurred()) SWIG_fail;
3301	+	}
3302	+	if (obj10) {
3303	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3304	+	if (PyErr_Occurred()) SWIG_fail;
3305	+	}
3306		{
3307		try {
3308	<	(arg1)->schedulerQuery(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3308	>	(arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3309
3310		}catch (const BossSchedFailure & e) {
3311	<	SWIG_exception(SWIG_ValueError, e.what());
3311	>	PyErr_SetString ( SchedulerError, e.what() );
3312	>	return NULL;
3313		}catch (const std::exception& e) {
3314	<	SWIG_exception(SWIG_RuntimeError, e.what());
3314	>	PyErr_SetString ( BossError, e.what() );
3315	>	return NULL;
3316		}
3317		}
3318		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3193 \| Line 3322 \| *static PyObject _wrap_BossSession_sched**
3322		}
3323
3324
3325	<	static PyObject _wrap_BossSession_selectTasks(PyObject self, PyObject *args) {
3325	>	static PyObject _wrap_BossSession_getTasksByName(PyObject self, PyObject *args) {
3326		PyObject *resultobj;
3327		BossSession arg1 = (BossSession ) 0 ;
3328	<	std::string const &arg2_defvalue = "all" ;
3329	<	std::string arg2 = (std::string ) &arg2_defvalue ;
3330	<	std::string const &arg3_defvalue = "" ;
3331	<	std::string arg3 = (std::string ) &arg3_defvalue ;
3328	>	std::string *arg2 = 0 ;
3329	>	unsigned int result;
3330	>	std::string temp2 ;
3331	>	PyObject * obj0 = 0 ;
3332	>	PyObject * obj1 = 0 ;
3333	>
3334	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3335	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3336	>	{
3337	>	if (PyString_Check(obj1)) {
3338	>	temp2 = std::string(PyString_AsString(obj1));
3339	>	arg2 = &temp2;
3340	>	}else {
3341	>	SWIG_exception(SWIG_TypeError, "string expected");
3342	>	}
3343	>	}
3344	>	{
3345	>	try {
3346	>	result = (unsigned int)(arg1)->getTasksByName((std::string const &)*arg2);
3347	>
3348	>	}catch (const BossSchedFailure & e) {
3349	>	PyErr_SetString ( SchedulerError, e.what() );
3350	>	return NULL;
3351	>	}catch (const std::exception& e) {
3352	>	PyErr_SetString ( BossError, e.what() );
3353	>	return NULL;
3354	>	}
3355	>	}
3356	>	resultobj = PyInt_FromLong((long)result);
3357	>	return resultobj;
3358	>	fail:
3359	>	return NULL;
3360	>	}
3361	>
3362	>
3363	>	static PyObject _wrap_BossSession_getTasksByTaskInfo(PyObject self, PyObject *args) {
3364	>	PyObject *resultobj;
3365	>	BossSession arg1 = (BossSession ) 0 ;
3366	>	std::string *arg2 = 0 ;
3367	>	unsigned int result;
3368	>	std::string temp2 ;
3369	>	PyObject * obj0 = 0 ;
3370	>	PyObject * obj1 = 0 ;
3371	>
3372	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByTaskInfo",&obj0,&obj1)) goto fail;
3373	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3374	>	{
3375	>	if (PyString_Check(obj1)) {
3376	>	temp2 = std::string(PyString_AsString(obj1));
3377	>	arg2 = &temp2;
3378	>	}else {
3379	>	SWIG_exception(SWIG_TypeError, "string expected");
3380	>	}
3381	>	}
3382	>	{
3383	>	try {
3384	>	result = (unsigned int)(arg1)->getTasksByTaskInfo((std::string const &)*arg2);
3385	>
3386	>	}catch (const BossSchedFailure & e) {
3387	>	PyErr_SetString ( SchedulerError, e.what() );
3388	>	return NULL;
3389	>	}catch (const std::exception& e) {
3390	>	PyErr_SetString ( BossError, e.what() );
3391	>	return NULL;
3392	>	}
3393	>	}
3394	>	resultobj = PyInt_FromLong((long)result);
3395	>	return resultobj;
3396	>	fail:
3397	>	return NULL;
3398	>	}
3399	>
3400	>
3401	>	static PyObject _wrap_BossSession_getTasksByJobName(PyObject self, PyObject *args) {
3402	>	PyObject *resultobj;
3403	>	BossSession arg1 = (BossSession ) 0 ;
3404	>	std::string *arg2 = 0 ;
3405	>	unsigned int result;
3406	>	std::string temp2 ;
3407	>	PyObject * obj0 = 0 ;
3408	>	PyObject * obj1 = 0 ;
3409	>
3410	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3411	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3412	>	{
3413	>	if (PyString_Check(obj1)) {
3414	>	temp2 = std::string(PyString_AsString(obj1));
3415	>	arg2 = &temp2;
3416	>	}else {
3417	>	SWIG_exception(SWIG_TypeError, "string expected");
3418	>	}
3419	>	}
3420	>	{
3421	>	try {
3422	>	result = (unsigned int)(arg1)->getTasksByJobName((std::string const &)*arg2);
3423	>
3424	>	}catch (const BossSchedFailure & e) {
3425	>	PyErr_SetString ( SchedulerError, e.what() );
3426	>	return NULL;
3427	>	}catch (const std::exception& e) {
3428	>	PyErr_SetString ( BossError, e.what() );
3429	>	return NULL;
3430	>	}
3431	>	}
3432	>	resultobj = PyInt_FromLong((long)result);
3433	>	return resultobj;
3434	>	fail:
3435	>	return NULL;
3436	>	}
3437	>
3438	>
3439	>	static PyObject _wrap_BossSession_show(PyObject self, PyObject *args) {
3440	>	PyObject *resultobj;
3441	>	BossSession arg1 = (BossSession ) 0 ;
3442	>	std::vector<std::string > *arg2 = 0 ;
3443	>	PyObject *result;
3444	>	PyObject * obj0 = 0 ;
3445	>	PyObject * obj1 = 0 ;
3446	>
3447	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3448	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3449	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3450	>	if (arg2 == NULL) {
3451	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3452	>	}
3453	>	{
3454	>	try {
3455	>	result = (PyObject )BossSession_show(arg1,arg2);
3456	>
3457	>	}catch (const BossSchedFailure & e) {
3458	>	PyErr_SetString ( SchedulerError, e.what() );
3459	>	return NULL;
3460	>	}catch (const std::exception& e) {
3461	>	PyErr_SetString ( BossError, e.what() );
3462	>	return NULL;
3463	>	}
3464	>	}
3465	>	resultobj = result;
3466	>	return resultobj;
3467	>	fail:
3468	>	return NULL;
3469	>	}
3470	>
3471	>
3472	>	static PyObject _wrap_BossSession_CHTools(PyObject self, PyObject *args) {
3473	>	PyObject *resultobj;
3474	>	BossSession arg1 = (BossSession ) 0 ;
3475	>	PyObject *result;
3476	>	PyObject * obj0 = 0 ;
3477	>
3478	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3479	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3480	>	{
3481	>	try {
3482	>	result = (PyObject *)BossSession_CHTools(arg1);
3483	>
3484	>	}catch (const BossSchedFailure & e) {
3485	>	PyErr_SetString ( SchedulerError, e.what() );
3486	>	return NULL;
3487	>	}catch (const std::exception& e) {
3488	>	PyErr_SetString ( BossError, e.what() );
3489	>	return NULL;
3490	>	}
3491	>	}
3492	>	resultobj = result;
3493	>	return resultobj;
3494	>	fail:
3495	>	return NULL;
3496	>	}
3497	>
3498	>
3499	>	static PyObject _wrap_BossSession_ProgramTypes(PyObject self, PyObject *args) {
3500	>	PyObject *resultobj;
3501	>	BossSession arg1 = (BossSession ) 0 ;
3502	>	PyObject *result;
3503	>	PyObject * obj0 = 0 ;
3504	>
3505	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3506	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3507	>	{
3508	>	try {
3509	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3510	>
3511	>	}catch (const BossSchedFailure & e) {
3512	>	PyErr_SetString ( SchedulerError, e.what() );
3513	>	return NULL;
3514	>	}catch (const std::exception& e) {
3515	>	PyErr_SetString ( BossError, e.what() );
3516	>	return NULL;
3517	>	}
3518	>	}
3519	>	resultobj = result;
3520	>	return resultobj;
3521	>	fail:
3522	>	return NULL;
3523	>	}
3524	>
3525	>
3526	>	static PyObject _wrap_BossSession_RTMons(PyObject self, PyObject *args) {
3527	>	PyObject *resultobj;
3528	>	BossSession arg1 = (BossSession ) 0 ;
3529	>	PyObject *result;
3530	>	PyObject * obj0 = 0 ;
3531	>
3532	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3533	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3534	>	{
3535	>	try {
3536	>	result = (PyObject *)BossSession_RTMons(arg1);
3537	>
3538	>	}catch (const BossSchedFailure & e) {
3539	>	PyErr_SetString ( SchedulerError, e.what() );
3540	>	return NULL;
3541	>	}catch (const std::exception& e) {
3542	>	PyErr_SetString ( BossError, e.what() );
3543	>	return NULL;
3544	>	}
3545	>	}
3546	>	resultobj = result;
3547	>	return resultobj;
3548	>	fail:
3549	>	return NULL;
3550	>	}
3551	>
3552	>
3553	>	static PyObject _wrap_BossSession_schedulers(PyObject self, PyObject *args) {
3554	>	PyObject *resultobj;
3555	>	BossSession arg1 = (BossSession ) 0 ;
3556	>	PyObject *result;
3557	>	PyObject * obj0 = 0 ;
3558	>
3559	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3560	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3561	>	{
3562	>	try {
3563	>	result = (PyObject *)BossSession_schedulers(arg1);
3564	>
3565	>	}catch (const BossSchedFailure & e) {
3566	>	PyErr_SetString ( SchedulerError, e.what() );
3567	>	return NULL;
3568	>	}catch (const std::exception& e) {
3569	>	PyErr_SetString ( BossError, e.what() );
3570	>	return NULL;
3571	>	}
3572	>	}
3573	>	resultobj = result;
3574	>	return resultobj;
3575	>	fail:
3576	>	return NULL;
3577	>	}
3578	>
3579	>
3580	>	static PyObject _wrap_BossSession_schedListMatch(PyObject self, PyObject *args) {
3581	>	PyObject *resultobj;
3582	>	BossSession arg1 = (BossSession ) 0 ;
3583	>	std::string *arg2 = 0 ;
3584	>	std::string *arg3 = 0 ;
3585		std::string const &arg4_defvalue = "" ;
3586		std::string arg4 = (std::string ) &arg4_defvalue ;
3587		std::string const &arg5_defvalue = "" ;
3588		std::string arg5 = (std::string ) &arg5_defvalue ;
3589	<	std::vector<std::string > result;
3589	>	unsigned int arg6 = (unsigned int) 0 ;
3590	>	PyObject *result;
3591		std::string temp2 ;
3592		std::string temp3 ;
3593		std::string temp4 ;
#	Line 3214 \| Line 3597 \| *static PyObject _wrap_BossSession_selec**
3597		PyObject * obj2 = 0 ;
3598		PyObject * obj3 = 0 ;
3599		PyObject * obj4 = 0 ;
3600	+	PyObject * obj5 = 0 ;
3601
3602	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3602	>	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3603		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3604	<	if (obj1) {
3605	<	{
3606	<	if (PyString_Check(obj1)) {
3607	<	temp2 = std::string(PyString_AsString(obj1));
3608	<	arg2 = &temp2;
3609	<	}else {
3226	<	SWIG_exception(SWIG_TypeError, "string expected");
3227	<	}
3604	>	{
3605	>	if (PyString_Check(obj1)) {
3606	>	temp2 = std::string(PyString_AsString(obj1));
3607	>	arg2 = &temp2;
3608	>	}else {
3609	>	SWIG_exception(SWIG_TypeError, "string expected");
3610		}
3611		}
3612	<	if (obj2) {
3613	<	{
3614	<	if (PyString_Check(obj2)) {
3615	<	temp3 = std::string(PyString_AsString(obj2));
3616	<	arg3 = &temp3;
3617	<	}else {
3236	<	SWIG_exception(SWIG_TypeError, "string expected");
3237	<	}
3612	>	{
3613	>	if (PyString_Check(obj2)) {
3614	>	temp3 = std::string(PyString_AsString(obj2));
3615	>	arg3 = &temp3;
3616	>	}else {
3617	>	SWIG_exception(SWIG_TypeError, "string expected");
3618		}
3619		}
3620		if (obj3) {
#	Line 3257 \| Line 3637 \| *static PyObject _wrap_BossSession_selec**
3637		}
3638		}
3639		}
3640	+	if (obj5) {
3641	+	arg6 = (unsigned int) PyInt_AsLong(obj5);
3642	+	if (PyErr_Occurred()) SWIG_fail;
3643	+	}
3644		{
3645		try {
3646	<	result = (arg1)->selectTasks((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5);
3646	>	result = (PyObject )BossSession_schedListMatch(arg1,(std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6);
3647
3648		}catch (const BossSchedFailure & e) {
3649	<	SWIG_exception(SWIG_ValueError, e.what());
3649	>	PyErr_SetString ( SchedulerError, e.what() );
3650	>	return NULL;
3651		}catch (const std::exception& e) {
3652	<	SWIG_exception(SWIG_RuntimeError, e.what());
3652	>	PyErr_SetString ( BossError, e.what() );
3653	>	return NULL;
3654		}
3655		}
3656	<	{
3271	<	resultobj = PyTuple_New((&result)->size());
3272	<	for (unsigned int i=0; i<(&result)->size(); i++)
3273	<	PyTuple_SetItem(resultobj,i,
3274	<	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3275	<	}
3656	>	resultobj = result;
3657		return resultobj;
3658		fail:
3659		return NULL;
3660		}
3661
3662
3663	<	static PyObject _wrap_BossSession_query(PyObject self, PyObject *args) {
3663	>	static PyObject _wrap_BossSession_schedulerQuery(PyObject self, PyObject *args) {
3664		PyObject *resultobj;
3665		BossSession arg1 = (BossSession ) 0 ;
3666		int arg2 = (int) SCHEDULED ;
#	Line 3293 \| Line 3674 \| *static PyObject _wrap_BossSession_query**
3674		std::string arg7 = (std::string) "" ;
3675		std::string arg8 = (std::string) "" ;
3676		std::string arg9 = (std::string) "" ;
3677	<	bool arg10 = (bool) false ;
3678	<	SwigValueWrapper< std::vector<BossTask * > > result;
3677	>	unsigned int arg10 = (unsigned int) 0 ;
3678	>	bool arg11 = (bool) false ;
3679		std::string temp3 ;
3680		std::string temp4 ;
3681		std::string temp5 ;
#	Line 3307 \| Line 3688 \| *static PyObject _wrap_BossSession_query**
3688		PyObject * obj7 = 0 ;
3689		PyObject * obj8 = 0 ;
3690		PyObject * obj9 = 0 ;
3691	+	PyObject * obj10 = 0 ;
3692
3693	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3693	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3694		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3695		if (obj2) {
3696		{
#	Line 3373 \| Line 3755 \| *static PyObject _wrap_BossSession_query**
3755		}
3756		}
3757		if (obj9) {
3758	<	arg10 = PyInt_AsLong(obj9) ? true : false;
3758	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3759	>	if (PyErr_Occurred()) SWIG_fail;
3760	>	}
3761	>	if (obj10) {
3762	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3763		if (PyErr_Occurred()) SWIG_fail;
3764		}
3765		{
3766		try {
3767	<	result = (arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3767	>	BossSession_schedulerQuery(arg1,arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3768
3769		}catch (const BossSchedFailure & e) {
3770	<	SWIG_exception(SWIG_ValueError, e.what());
3770	>	PyErr_SetString ( SchedulerError, e.what() );
3771	>	return NULL;
3772		}catch (const std::exception& e) {
3773	<	SWIG_exception(SWIG_RuntimeError, e.what());
3773	>	PyErr_SetString ( BossError, e.what() );
3774	>	return NULL;
3775		}
3776		}
3777	<	{
3390	<	std::vector<BossTask * > * resultptr;
3391	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3392	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3393	<	}
3777	>	Py_INCREF(Py_None); resultobj = Py_None;
3778		return resultobj;
3779		fail:
3780		return NULL;
#	Line 3404 \| Line 3788 \| *static PyObject BossSession_swigregist**
3788		Py_INCREF(obj);
3789		return Py_BuildValue((char *)"");
3790		}
3407	–	static PyObject _wrap_BossTaskException_key_set(PyObject self, PyObject *args) {
3408	–	PyObject *resultobj;
3409	–	BossTaskException arg1 = (BossTaskException ) 0 ;
3410	–	char *arg2 ;
3411	–	PyObject * obj0 = 0 ;
3412	–
3413	–	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3414	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3415	–	{
3416	–	if (arg2) {
3417	–	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3418	–	strcpy((char *) arg1->key,arg2);
3419	–	}else {
3420	–	arg1->key = 0;
3421	–	}
3422	–	}
3423	–	Py_INCREF(Py_None); resultobj = Py_None;
3424	–	return resultobj;
3425	–	fail:
3426	–	return NULL;
3427	–	}
3428	–
3429	–
3430	–	static PyObject _wrap_BossTaskException_key_get(PyObject self, PyObject *args) {
3431	–	PyObject *resultobj;
3432	–	BossTaskException arg1 = (BossTaskException ) 0 ;
3433	–	char *result;
3434	–	PyObject * obj0 = 0 ;
3435	–
3436	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3437	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3438	–	result = (char *) ((arg1)->key);
3439	–
3440	–	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3441	–	return resultobj;
3442	–	fail:
3443	–	return NULL;
3444	–	}
3445	–
3446	–
3791		static PyObject _wrap_new_BossTaskException(PyObject self, PyObject *args) {
3792		PyObject *resultobj;
3793		char *arg1 ;
#	Line 3455 \| Line 3799 \| *static PyObject _wrap_new_BossTaskExcep**
3799		result = (BossTaskException )new BossTaskException((char const )arg1);
3800
3801		}catch (const BossSchedFailure & e) {
3802	<	SWIG_exception(SWIG_ValueError, e.what());
3802	>	PyErr_SetString ( SchedulerError, e.what() );
3803	>	return NULL;
3804		}catch (const std::exception& e) {
3805	<	SWIG_exception(SWIG_RuntimeError, e.what());
3805	>	PyErr_SetString ( BossError, e.what() );
3806	>	return NULL;
3807		}
3808		}
3809		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
#	Line 3467 \| Line 3813 \| *static PyObject _wrap_new_BossTaskExcep**
3813		}
3814
3815
3816	<	static PyObject _wrap_BossTaskException_what(PyObject self, PyObject *args) {
3816	>	static PyObject _wrap_delete_BossTaskException(PyObject self, PyObject *args) {
3817		PyObject *resultobj;
3818		BossTaskException arg1 = (BossTaskException ) 0 ;
3473	–	char *result;
3819		PyObject * obj0 = 0 ;
3820
3821	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3821	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3822		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3823		{
3824		try {
3825	<	result = (char )((BossTaskException const )arg1)->what();
3825	>	delete arg1;
3826
3827		}catch (const BossSchedFailure & e) {
3828	<	SWIG_exception(SWIG_ValueError, e.what());
3828	>	PyErr_SetString ( SchedulerError, e.what() );
3829	>	return NULL;
3830		}catch (const std::exception& e) {
3831	<	SWIG_exception(SWIG_RuntimeError, e.what());
3831	>	PyErr_SetString ( BossError, e.what() );
3832	>	return NULL;
3833		}
3834		}
3835	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3835	>	Py_INCREF(Py_None); resultobj = Py_None;
3836		return resultobj;
3837		fail:
3838		return NULL;
3839		}
3840
3841
3842	<	static PyObject _wrap_delete_BossTaskException(PyObject self, PyObject *args) {
3842	>	static PyObject * BossTaskException_swigregister(PyObject self, PyObject args) {
3843	>	PyObject *obj;
3844	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3845	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3846	>	Py_INCREF(obj);
3847	>	return Py_BuildValue((char *)"");
3848	>	}
3849	>	static PyObject _wrap_BossTask_job_begin(PyObject self, PyObject *args) {
3850		PyObject *resultobj;
3851	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3851	>	BossTask arg1 = (BossTask ) 0 ;
3852	>	BossTask::job_iterator result;
3853		PyObject * obj0 = 0 ;
3854
3855	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3856	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3855	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3856	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3857		{
3858		try {
3859	<	delete arg1;
3859	>	result = ((BossTask const *)arg1)->job_begin();
3860
3861		}catch (const BossSchedFailure & e) {
3862	<	SWIG_exception(SWIG_ValueError, e.what());
3862	>	PyErr_SetString ( SchedulerError, e.what() );
3863	>	return NULL;
3864		}catch (const std::exception& e) {
3865	<	SWIG_exception(SWIG_RuntimeError, e.what());
3865	>	PyErr_SetString ( BossError, e.what() );
3866	>	return NULL;
3867		}
3868		}
3869	<	Py_INCREF(Py_None); resultobj = Py_None;
3869	>	{
3870	>	BossTask::job_iterator * resultptr;
3871	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3872	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3873	>	}
3874		return resultobj;
3875		fail:
3876		return NULL;
3877		}
3878
3879
3880	<	static PyObject * BossTaskException_swigregister(PyObject self, PyObject args) {
3520	<	PyObject *obj;
3521	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3522	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3523	<	Py_INCREF(obj);
3524	<	return Py_BuildValue((char *)"");
3525	<	}
3526	<	static PyObject _wrap_BossTask_appendToPyDict(PyObject self, PyObject *args) {
3880	>	static PyObject _wrap_BossTask_job_end(PyObject self, PyObject *args) {
3881		PyObject *resultobj;
3882		BossTask arg1 = (BossTask ) 0 ;
3883	<	PyObject arg2 = (PyObject ) 0 ;
3530	<	BossAttributeContainer *arg3 = 0 ;
3531	<	PyObject *result;
3883	>	BossTask::job_iterator result;
3884		PyObject * obj0 = 0 ;
3533	–	PyObject * obj1 = 0 ;
3534	–	PyObject * obj2 = 0 ;
3885
3886	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3886	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3887		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3538	–	arg2 = obj1;
3539	–	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3540	–	if (arg3 == NULL) {
3541	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3542	–	}
3888		{
3889		try {
3890	<	result = (PyObject )BossTask_appendToPyDict((BossTask const )arg1,arg2,(BossAttributeContainer const &)*arg3);
3890	>	result = ((BossTask const *)arg1)->job_end();
3891
3892		}catch (const BossSchedFailure & e) {
3893	<	SWIG_exception(SWIG_ValueError, e.what());
3893	>	PyErr_SetString ( SchedulerError, e.what() );
3894	>	return NULL;
3895		}catch (const std::exception& e) {
3896	<	SWIG_exception(SWIG_RuntimeError, e.what());
3896	>	PyErr_SetString ( BossError, e.what() );
3897	>	return NULL;
3898		}
3899		}
3900	<	resultobj = result;
3900	>	{
3901	>	BossTask::job_iterator * resultptr;
3902	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3903	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3904	>	}
3905		return resultobj;
3906		fail:
3907		return NULL;
3908		}
3909
3910
3911	<	static PyObject _wrap_BossTask_jobDict(PyObject self, PyObject *args) {
3911	>	static PyObject _wrap_BossTask_jobsInMemory(PyObject self, PyObject *args) {
3912		PyObject *resultobj;
3913		BossTask arg1 = (BossTask ) 0 ;
3914	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3564	<	PyObject *result;
3914	>	unsigned int result;
3915		PyObject * obj0 = 0 ;
3566	–	PyObject * obj1 = 0 ;
3916
3917	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3917	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsInMemory",&obj0)) goto fail;
3918		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3570	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3571	–	if (arg2 == NULL) {
3572	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3573	–	}
3919		{
3920		try {
3921	<	result = (PyObject )BossTask_jobDict((BossTask const )arg1,*arg2);
3921	>	result = (unsigned int)((BossTask const *)arg1)->jobsInMemory();
3922
3923		}catch (const BossSchedFailure & e) {
3924	<	SWIG_exception(SWIG_ValueError, e.what());
3924	>	PyErr_SetString ( SchedulerError, e.what() );
3925	>	return NULL;
3926		}catch (const std::exception& e) {
3927	<	SWIG_exception(SWIG_RuntimeError, e.what());
3927	>	PyErr_SetString ( BossError, e.what() );
3928	>	return NULL;
3929		}
3930		}
3931	<	resultobj = result;
3931	>	resultobj = PyInt_FromLong((long)result);
3932		return resultobj;
3933		fail:
3934		return NULL;
3935		}
3936
3937
3938	<	static PyObject _wrap_BossTask_jobsDict(PyObject self, PyObject *args) {
3938	>	static PyObject _wrap_BossTask_queryJobPrograms(PyObject self, PyObject *args) {
3939		PyObject *resultobj;
3940		BossTask arg1 = (BossTask ) 0 ;
3941	<	PyObject *result;
3941	>	BossJob arg2 = (BossJob ) 0 ;
3942	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3943		PyObject * obj0 = 0 ;
3944	+	PyObject * obj1 = 0 ;
3945
3946	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3946	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3947		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3948	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3949		{
3950		try {
3951	<	result = (PyObject *)BossTask_jobsDict(arg1);
3951	>	result = ((BossTask const )arg1)->queryJobPrograms((BossJob const )arg2);
3952
3953		}catch (const BossSchedFailure & e) {
3954	<	SWIG_exception(SWIG_ValueError, e.what());
3954	>	PyErr_SetString ( SchedulerError, e.what() );
3955	>	return NULL;
3956		}catch (const std::exception& e) {
3957	<	SWIG_exception(SWIG_RuntimeError, e.what());
3957	>	PyErr_SetString ( BossError, e.what() );
3958	>	return NULL;
3959		}
3960		}
3961	<	resultobj = result;
3961	>	{
3962	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3963	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3964	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3965	>	}
3966		return resultobj;
3967		fail:
3968		return NULL;
3969		}
3970
3971
3972	<	static PyObject _wrap_BossTask_progDict(PyObject self, PyObject *args) {
3972	>	static PyObject _wrap_BossTask_queryProgram(PyObject self, PyObject *args) {
3973		PyObject *resultobj;
3974		BossTask arg1 = (BossTask ) 0 ;
3975	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3976	<	PyObject *result;
3975	>	BossJob arg2 = (BossJob ) 0 ;
3976	>	std::string *arg3 = 0 ;
3977	>	BossProgram result;
3978	>	std::string temp3 ;
3979		PyObject * obj0 = 0 ;
3980		PyObject * obj1 = 0 ;
3981	+	PyObject * obj2 = 0 ;
3982
3983	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3983	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
3984		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3985	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3986	<	if (arg2 == NULL) {
3987	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3985	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3986	>	{
3987	>	if (PyString_Check(obj2)) {
3988	>	temp3 = std::string(PyString_AsString(obj2));
3989	>	arg3 = &temp3;
3990	>	}else {
3991	>	SWIG_exception(SWIG_TypeError, "string expected");
3992	>	}
3993		}
3994		{
3995		try {
3996	<	result = (PyObject )BossTask_progDict((BossTask const )arg1,*arg2);
3996	>	result = ((BossTask const )arg1)->queryProgram((BossJob const )arg2,(std::string const &)*arg3);
3997
3998		}catch (const BossSchedFailure & e) {
3999	<	SWIG_exception(SWIG_ValueError, e.what());
3999	>	PyErr_SetString ( SchedulerError, e.what() );
4000	>	return NULL;
4001		}catch (const std::exception& e) {
4002	<	SWIG_exception(SWIG_RuntimeError, e.what());
4002	>	PyErr_SetString ( BossError, e.what() );
4003	>	return NULL;
4004		}
4005		}
4006	<	resultobj = result;
4006	>	{
4007	>	BossProgram * resultptr;
4008	>	resultptr = new BossProgram((BossProgram &) result);
4009	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4010	>	}
4011		return resultobj;
4012		fail:
4013		return NULL;
4014		}
4015
4016
4017	<	static PyObject _wrap_BossTask_jobPrograms(PyObject self, PyObject *args) {
4017	>	static PyObject _wrap_BossTask_queryProgramExec(PyObject self, PyObject *args) {
4018		PyObject *resultobj;
4019		BossTask arg1 = (BossTask ) 0 ;
4020	<	std::string *arg2 = 0 ;
4021	<	PyObject *result;
4022	<	std::string temp2 ;
4020	>	BossJob arg2 = (BossJob ) 0 ;
4021	>	std::string *arg3 = 0 ;
4022	>	BossProgramExec result;
4023	>	std::string temp3 ;
4024		PyObject * obj0 = 0 ;
4025		PyObject * obj1 = 0 ;
4026	+	PyObject * obj2 = 0 ;
4027
4028	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
4028	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4029		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4030	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4031		{
4032	<	if (PyString_Check(obj1)) {
4033	<	temp2 = std::string(PyString_AsString(obj1));
4034	<	arg2 = &temp2;
4032	>	if (PyString_Check(obj2)) {
4033	>	temp3 = std::string(PyString_AsString(obj2));
4034	>	arg3 = &temp3;
4035		}else {
4036		SWIG_exception(SWIG_TypeError, "string expected");
4037		}
4038		}
4039		{
4040		try {
4041	<	result = (PyObject )BossTask_jobPrograms((BossTask const )arg1,(std::string const &)*arg2);
4041	>	result = ((BossTask const )arg1)->queryProgramExec((BossJob const )arg2,(std::string const &)*arg3);
4042
4043		}catch (const BossSchedFailure & e) {
4044	<	SWIG_exception(SWIG_ValueError, e.what());
4044	>	PyErr_SetString ( SchedulerError, e.what() );
4045	>	return NULL;
4046		}catch (const std::exception& e) {
4047	<	SWIG_exception(SWIG_RuntimeError, e.what());
4047	>	PyErr_SetString ( BossError, e.what() );
4048	>	return NULL;
4049		}
4050		}
4051	<	resultobj = result;
4051	>	{
4052	>	BossProgramExec * resultptr;
4053	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4054	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4055	>	}
4056		return resultobj;
4057		fail:
4058		return NULL;
#	Line 3693 \| Line 4072 \| *static PyObject _wrap_new_BossTask__SWI**
4072		result = (BossTask *)new BossTask(arg1);
4073
4074		}catch (const BossSchedFailure & e) {
4075	<	SWIG_exception(SWIG_ValueError, e.what());
4075	>	PyErr_SetString ( SchedulerError, e.what() );
4076	>	return NULL;
4077		}catch (const std::exception& e) {
4078	<	SWIG_exception(SWIG_RuntimeError, e.what());
4078	>	PyErr_SetString ( BossError, e.what() );
4079	>	return NULL;
4080		}
4081		}
4082		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3729 \| Line 4110 \| *static PyObject _wrap_new_BossTask__SWI**
4110		result = (BossTask )new BossTask(arg1,(std::string const &)arg2);
4111
4112		}catch (const BossSchedFailure & e) {
4113	<	SWIG_exception(SWIG_ValueError, e.what());
4113	>	PyErr_SetString ( SchedulerError, e.what() );
4114	>	return NULL;
4115		}catch (const std::exception& e) {
4116	<	SWIG_exception(SWIG_RuntimeError, e.what());
4116	>	PyErr_SetString ( BossError, e.what() );
4117	>	return NULL;
4118		}
4119		}
4120		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3753 \| Line 4136 \| *static PyObject _wrap_delete_BossTask(P**
4136		delete arg1;
4137
4138		}catch (const BossSchedFailure & e) {
4139	<	SWIG_exception(SWIG_ValueError, e.what());
4139	>	PyErr_SetString ( SchedulerError, e.what() );
4140	>	return NULL;
4141		}catch (const std::exception& e) {
4142	<	SWIG_exception(SWIG_RuntimeError, e.what());
4142	>	PyErr_SetString ( BossError, e.what() );
4143	>	return NULL;
4144		}
4145		}
4146		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3781 \| Line 4166 \| *static PyObject _wrap_new_BossTask__SWI**
4166		result = (BossTask )new BossTask((BossTask const &)arg1);
4167
4168		}catch (const BossSchedFailure & e) {
4169	<	SWIG_exception(SWIG_ValueError, e.what());
4169	>	PyErr_SetString ( SchedulerError, e.what() );
4170	>	return NULL;
4171		}catch (const std::exception& e) {
4172	<	SWIG_exception(SWIG_RuntimeError, e.what());
4172	>	PyErr_SetString ( BossError, e.what() );
4173	>	return NULL;
4174		}
4175		}
4176		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3874 \| Line 4261 \| *static PyObject _wrap_BossTask_id(PyObj**
4261		}
4262
4263		}catch (const BossSchedFailure & e) {
4264	<	SWIG_exception(SWIG_ValueError, e.what());
4264	>	PyErr_SetString ( SchedulerError, e.what() );
4265	>	return NULL;
4266		}catch (const std::exception& e) {
4267	<	SWIG_exception(SWIG_RuntimeError, e.what());
4267	>	PyErr_SetString ( BossError, e.what() );
4268	>	return NULL;
4269		}
4270		}
4271		{
#	Line 3904 \| Line 4293 \| *static PyObject _wrap_BossTask_name(PyO**
4293		}
4294
4295		}catch (const BossSchedFailure & e) {
4296	<	SWIG_exception(SWIG_ValueError, e.what());
4296	>	PyErr_SetString ( SchedulerError, e.what() );
4297	>	return NULL;
4298		}catch (const std::exception& e) {
4299	<	SWIG_exception(SWIG_RuntimeError, e.what());
4299	>	PyErr_SetString ( BossError, e.what() );
4300	>	return NULL;
4301		}
4302		}
4303		{
#	Line 3918 \| Line 4309 \| *static PyObject _wrap_BossTask_name(PyO**
4309		}
4310
4311
4312	<	static PyObject _wrap_BossTask_taskMap(PyObject self, PyObject *args) {
4312	>	static PyObject _wrap_BossTask_chain(PyObject self, PyObject *args) {
4313		PyObject *resultobj;
4314		BossTask arg1 = (BossTask ) 0 ;
4315	<	std::map<std::string,std::string > result;
4315	>	std::string *arg2 = 0 ;
4316	>	BossChain result;
4317	>	std::string temp2 ;
4318		PyObject * obj0 = 0 ;
4319	+	PyObject * obj1 = 0 ;
4320
4321	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4321	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4322		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4323		{
4324	<	try {
4325	<	result = ((BossTask const *)arg1)->taskMap();
4326	<
4327	<	}catch (const BossSchedFailure & e) {
4328	<	SWIG_exception(SWIG_ValueError, e.what());
3935	<	}catch (const std::exception& e) {
3936	<	SWIG_exception(SWIG_RuntimeError, e.what());
3937	<	}
3938	<	}
3939	<	{
3940	<	resultobj = PyDict_New();
3941	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3942	<	PyDict_SetItem(resultobj,
3943	<	SwigString_FromString(i->first),
3944	<	SwigString_FromString(i->second));
4324	>	if (PyString_Check(obj1)) {
4325	>	temp2 = std::string(PyString_AsString(obj1));
4326	>	arg2 = &temp2;
4327	>	}else {
4328	>	SWIG_exception(SWIG_TypeError, "string expected");
4329		}
4330		}
3947	–	return resultobj;
3948	–	fail:
3949	–	return NULL;
3950	–	}
3951	–
3952	–
3953	–	static PyObject _wrap_BossTask_job_begin(PyObject self, PyObject *args) {
3954	–	PyObject *resultobj;
3955	–	BossTask arg1 = (BossTask ) 0 ;
3956	–	BossTask::job_iterator result;
3957	–	PyObject * obj0 = 0 ;
3958	–
3959	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3960	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4331		{
4332		try {
4333	<	result = ((BossTask const *)arg1)->job_begin();
4333	>	result = ((BossTask const )arg1)->chain((std::string const &)arg2);
4334
4335		}catch (const BossSchedFailure & e) {
4336	<	SWIG_exception(SWIG_ValueError, e.what());
4336	>	PyErr_SetString ( SchedulerError, e.what() );
4337	>	return NULL;
4338		}catch (const std::exception& e) {
4339	<	SWIG_exception(SWIG_RuntimeError, e.what());
4339	>	PyErr_SetString ( BossError, e.what() );
4340	>	return NULL;
4341		}
4342		}
4343		{
4344	<	BossTask::job_iterator * resultptr;
4345	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4346	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4344	>	BossChain * resultptr;
4345	>	resultptr = new BossChain((BossChain &) result);
4346	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4347		}
4348		return resultobj;
4349		fail:
#	Line 3979 \| Line 4351 \| *static PyObject _wrap_BossTask_job_begi**
4351		}
4352
4353
4354	<	static PyObject _wrap_BossTask_job_end(PyObject self, PyObject *args) {
4354	>	static PyObject _wrap_BossTask_taskMap(PyObject self, PyObject *args) {
4355		PyObject *resultobj;
4356		BossTask arg1 = (BossTask ) 0 ;
4357	<	BossTask::job_iterator result;
4357	>	std::map<std::string,std::string > result;
4358		PyObject * obj0 = 0 ;
4359
4360	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4360	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4361		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4362		{
4363		try {
4364	<	result = ((BossTask const *)arg1)->job_end();
4364	>	result = ((BossTask const *)arg1)->taskMap();
4365
4366		}catch (const BossSchedFailure & e) {
4367	<	SWIG_exception(SWIG_ValueError, e.what());
4367	>	PyErr_SetString ( SchedulerError, e.what() );
4368	>	return NULL;
4369		}catch (const std::exception& e) {
4370	<	SWIG_exception(SWIG_RuntimeError, e.what());
4370	>	PyErr_SetString ( BossError, e.what() );
4371	>	return NULL;
4372		}
4373		}
4374		{
4375	<	BossTask::job_iterator * resultptr;
4376	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4377	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4375	>	resultobj = PyDict_New();
4376	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4377	>	PyDict_SetItem(resultobj,
4378	>	SwigString_FromString(i->first),
4379	>	SwigString_FromString(i->second));
4380	>	}
4381		}
4382		return resultobj;
4383		fail:
#	Line 4021 \| Line 4398 \| *static PyObject _wrap_BossTask_jobsMap(**
4398		result = ((BossTask const *)arg1)->jobsMap();
4399
4400		}catch (const BossSchedFailure & e) {
4401	<	SWIG_exception(SWIG_ValueError, e.what());
4401	>	PyErr_SetString ( SchedulerError, e.what() );
4402	>	return NULL;
4403		}catch (const std::exception& e) {
4404	<	SWIG_exception(SWIG_RuntimeError, e.what());
4404	>	PyErr_SetString ( BossError, e.what() );
4405	>	return NULL;
4406		}
4407		}
4408		{
#	Line 4061 \| Line 4440 \| *static PyObject _wrap_BossTask_jobMap__**
4440		result = ((BossTask const )arg1)->jobMap(arg2,arg3);
4441
4442		}catch (const BossSchedFailure & e) {
4443	<	SWIG_exception(SWIG_ValueError, e.what());
4443	>	PyErr_SetString ( SchedulerError, e.what() );
4444	>	return NULL;
4445		}catch (const std::exception& e) {
4446	<	SWIG_exception(SWIG_RuntimeError, e.what());
4446	>	PyErr_SetString ( BossError, e.what() );
4447	>	return NULL;
4448		}
4449		}
4450		{
#	Line 4092 \| Line 4473 \| *static PyObject _wrap_BossTask_jobMap__**
4473		result = ((BossTask const *)arg1)->jobMap(arg2);
4474
4475		}catch (const BossSchedFailure & e) {
4476	<	SWIG_exception(SWIG_ValueError, e.what());
4476	>	PyErr_SetString ( SchedulerError, e.what() );
4477	>	return NULL;
4478		}catch (const std::exception& e) {
4479	<	SWIG_exception(SWIG_RuntimeError, e.what());
4479	>	PyErr_SetString ( BossError, e.what() );
4480	>	return NULL;
4481		}
4482		}
4483		{
#	Line 4199 \| Line 4582 \| *static PyObject _wrap_BossTask_programs**
4582		result = ((BossTask const )arg1)->programsMap((BossJob const )arg2);
4583
4584		}catch (const BossSchedFailure & e) {
4585	<	SWIG_exception(SWIG_ValueError, e.what());
4585	>	PyErr_SetString ( SchedulerError, e.what() );
4586	>	return NULL;
4587		}catch (const std::exception& e) {
4588	<	SWIG_exception(SWIG_RuntimeError, e.what());
4588	>	PyErr_SetString ( BossError, e.what() );
4589	>	return NULL;
4590		}
4591		}
4592		{
#	Line 4215 \| Line 4600 \| *static PyObject _wrap_BossTask_programs**
4600		}
4601
4602
4218	–	static PyObject _wrap_BossTask_queryJobPrograms(PyObject self, PyObject *args) {
4219	–	PyObject *resultobj;
4220	–	BossTask arg1 = (BossTask ) 0 ;
4221	–	BossJob arg2 = (BossJob ) 0 ;
4222	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4223	–	PyObject * obj0 = 0 ;
4224	–	PyObject * obj1 = 0 ;
4225	–
4226	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4227	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4228	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4229	–	{
4230	–	try {
4231	–	result = ((BossTask const )arg1)->queryJobPrograms((BossJob const )arg2);
4232	–
4233	–	}catch (const BossSchedFailure & e) {
4234	–	SWIG_exception(SWIG_ValueError, e.what());
4235	–	}catch (const std::exception& e) {
4236	–	SWIG_exception(SWIG_RuntimeError, e.what());
4237	–	}
4238	–	}
4239	–	{
4240	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4241	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4242	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4243	–	}
4244	–	return resultobj;
4245	–	fail:
4246	–	return NULL;
4247	–	}
4248	–
4249	–
4603		static PyObject _wrap_BossTask_declare__SWIG_0(PyObject self, PyObject *args) {
4604		PyObject *resultobj;
4605		BossTask arg1 = (BossTask ) 0 ;
#	Line 4284 \| Line 4637 \| *static PyObject _wrap_BossTask_declare_**
4637		(arg1)->declare((std::string const &)arg2,(std::string const &)arg3);
4638
4639		}catch (const BossSchedFailure & e) {
4640	<	SWIG_exception(SWIG_ValueError, e.what());
4640	>	PyErr_SetString ( SchedulerError, e.what() );
4641	>	return NULL;
4642		}catch (const std::exception& e) {
4643	<	SWIG_exception(SWIG_RuntimeError, e.what());
4643	>	PyErr_SetString ( BossError, e.what() );
4644	>	return NULL;
4645		}
4646		}
4647		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4325 \| Line 4680 \| *static PyObject _wrap_BossTask_declare_**
4680		(arg1)->declare(arg2,(std::string const &)*arg3);
4681
4682		}catch (const BossSchedFailure & e) {
4683	<	SWIG_exception(SWIG_ValueError, e.what());
4683	>	PyErr_SetString ( SchedulerError, e.what() );
4684	>	return NULL;
4685		}catch (const std::exception& e) {
4686	<	SWIG_exception(SWIG_RuntimeError, e.what());
4686	>	PyErr_SetString ( BossError, e.what() );
4687	>	return NULL;
4688		}
4689		}
4690		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4426 \| Line 4783 \| *static PyObject _wrap_BossTask_remove(P**
4783		(arg1)->remove();
4784
4785		}catch (const BossSchedFailure & e) {
4786	<	SWIG_exception(SWIG_ValueError, e.what());
4786	>	PyErr_SetString ( SchedulerError, e.what() );
4787	>	return NULL;
4788		}catch (const std::exception& e) {
4789	<	SWIG_exception(SWIG_RuntimeError, e.what());
4789	>	PyErr_SetString ( BossError, e.what() );
4790	>	return NULL;
4791		}
4792		}
4793		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4464 \| Line 4823 \| *static PyObject _wrap_BossTask_archive(**
4823		(arg1)->archive((std::string const &)*arg2);
4824
4825		}catch (const BossSchedFailure & e) {
4826	<	SWIG_exception(SWIG_ValueError, e.what());
4826	>	PyErr_SetString ( SchedulerError, e.what() );
4827	>	return NULL;
4828		}catch (const std::exception& e) {
4829	<	SWIG_exception(SWIG_RuntimeError, e.what());
4829	>	PyErr_SetString ( BossError, e.what() );
4830	>	return NULL;
4831		}
4832		}
4833		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4489 \| Line 4850 \| *static PyObject _wrap_BossTask_submit(P**
4850		std::string arg5 = (std::string ) &arg5_defvalue ;
4851		std::string const &arg6_defvalue = "" ;
4852		std::string arg6 = (std::string ) &arg6_defvalue ;
4853	<	bool arg7 = (bool) false ;
4853	>	unsigned int arg7 = (unsigned int) 0 ;
4854	>	bool arg8 = (bool) false ;
4855		int result;
4856		std::string temp2 ;
4857		std::string temp3 ;
#	Line 4503 \| Line 4865 \| *static PyObject _wrap_BossTask_submit(P**
4865		PyObject * obj4 = 0 ;
4866		PyObject * obj5 = 0 ;
4867		PyObject * obj6 = 0 ;
4868	+	PyObject * obj7 = 0 ;
4869
4870	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4870	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4871		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4872		if (obj1) {
4873		{
#	Line 4557 \| Line 4920 \| *static PyObject _wrap_BossTask_submit(P**
4920		}
4921		}
4922		if (obj6) {
4923	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4923	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4924	>	if (PyErr_Occurred()) SWIG_fail;
4925	>	}
4926	>	if (obj7) {
4927	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4928		if (PyErr_Occurred()) SWIG_fail;
4929		}
4930		{
4931		try {
4932	<	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);
4932	>	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);
4933
4934		}catch (const BossSchedFailure & e) {
4935	<	SWIG_exception(SWIG_ValueError, e.what());
4935	>	PyErr_SetString ( SchedulerError, e.what() );
4936	>	return NULL;
4937		}catch (const std::exception& e) {
4938	<	SWIG_exception(SWIG_RuntimeError, e.what());
4938	>	PyErr_SetString ( BossError, e.what() );
4939	>	return NULL;
4940		}
4941		}
4942		resultobj = PyInt_FromLong((long)result);
#	Line 4607 \| Line 4976 \| *static PyObject _wrap_BossTask_reSubmit**
4976		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4977
4978		}catch (const BossSchedFailure & e) {
4979	<	SWIG_exception(SWIG_ValueError, e.what());
4979	>	PyErr_SetString ( SchedulerError, e.what() );
4980	>	return NULL;
4981		}catch (const std::exception& e) {
4982	<	SWIG_exception(SWIG_RuntimeError, e.what());
4982	>	PyErr_SetString ( BossError, e.what() );
4983	>	return NULL;
4984		}
4985		}
4986		resultobj = PyInt_FromLong((long)result);
#	Line 4623 \| Line 4994 \| *static PyObject _wrap_BossTask_kill(PyO**
4994		PyObject *resultobj;
4995		BossTask arg1 = (BossTask ) 0 ;
4996		std::string *arg2 = 0 ;
4997	<	bool arg3 = (bool) false ;
4997	>	unsigned int arg3 = (unsigned int) 0 ;
4998	>	bool arg4 = (bool) false ;
4999		int result;
5000		std::string temp2 ;
5001		PyObject * obj0 = 0 ;
5002		PyObject * obj1 = 0 ;
5003		PyObject * obj2 = 0 ;
5004	+	PyObject * obj3 = 0 ;
5005
5006	<	if(!PyArg_ParseTuple(args,(char *)"OO\|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
5006	>	if(!PyArg_ParseTuple(args,(char *)"OO\|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
5007		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5008		{
5009		if (PyString_Check(obj1)) {
#	Line 4641 \| Line 5014 \| *static PyObject _wrap_BossTask_kill(PyO**
5014		}
5015		}
5016		if (obj2) {
5017	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5017	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
5018	>	if (PyErr_Occurred()) SWIG_fail;
5019	>	}
5020	>	if (obj3) {
5021	>	arg4 = PyInt_AsLong(obj3) ? true : false;
5022		if (PyErr_Occurred()) SWIG_fail;
5023		}
5024		{
5025		try {
5026	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
5026	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
5027
5028		}catch (const BossSchedFailure & e) {
5029	<	SWIG_exception(SWIG_ValueError, e.what());
5029	>	PyErr_SetString ( SchedulerError, e.what() );
5030	>	return NULL;
5031		}catch (const std::exception& e) {
5032	<	SWIG_exception(SWIG_RuntimeError, e.what());
5032	>	PyErr_SetString ( BossError, e.what() );
5033	>	return NULL;
5034		}
5035		}
5036		resultobj = PyInt_FromLong((long)result);
#	Line 4668 \| Line 5047 \| *static PyObject _wrap_BossTask_getOutpu**
5047		std::string arg2 = (std::string ) &arg2_defvalue ;
5048		std::string const &arg3_defvalue = "" ;
5049		std::string arg3 = (std::string ) &arg3_defvalue ;
5050	<	bool arg4 = (bool) false ;
5050	>	unsigned int arg4 = (unsigned int) 0 ;
5051		bool arg5 = (bool) false ;
5052	+	bool arg6 = (bool) false ;
5053		int result;
5054		std::string temp2 ;
5055		std::string temp3 ;
#	Line 4678 \| Line 5058 \| *static PyObject _wrap_BossTask_getOutpu**
5058		PyObject * obj2 = 0 ;
5059		PyObject * obj3 = 0 ;
5060		PyObject * obj4 = 0 ;
5061	+	PyObject * obj5 = 0 ;
5062
5063	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5063	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5064		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5065		if (obj1) {
5066		{
#	Line 4702 \| Line 5083 \| *static PyObject _wrap_BossTask_getOutpu**
5083		}
5084		}
5085		if (obj3) {
5086	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5086	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
5087		if (PyErr_Occurred()) SWIG_fail;
5088		}
5089		if (obj4) {
5090		arg5 = PyInt_AsLong(obj4) ? true : false;
5091		if (PyErr_Occurred()) SWIG_fail;
5092		}
5093	+	if (obj5) {
5094	+	arg6 = PyInt_AsLong(obj5) ? true : false;
5095	+	if (PyErr_Occurred()) SWIG_fail;
5096	+	}
5097		{
5098		try {
5099	<	result = (int)(arg1)->getOutput((std::string const &)arg2,(std::string const &)arg3,arg4,arg5);
5099	>	result = (int)(arg1)->getOutput((std::string const &)arg2,(std::string const &)arg3,arg4,arg5,arg6);
5100
5101		}catch (const BossSchedFailure & e) {
5102	<	SWIG_exception(SWIG_ValueError, e.what());
5102	>	PyErr_SetString ( SchedulerError, e.what() );
5103	>	return NULL;
5104		}catch (const std::exception& e) {
5105	<	SWIG_exception(SWIG_RuntimeError, e.what());
5105	>	PyErr_SetString ( BossError, e.what() );
5106	>	return NULL;
5107	>	}
5108	>	}
5109	>	resultobj = PyInt_FromLong((long)result);
5110	>	return resultobj;
5111	>	fail:
5112	>	return NULL;
5113	>	}
5114	>
5115	>
5116	>	static PyObject _wrap_BossTask_loadByName(PyObject self, PyObject *args) {
5117	>	PyObject *resultobj;
5118	>	BossTask arg1 = (BossTask ) 0 ;
5119	>	std::string *arg2 = 0 ;
5120	>	int result;
5121	>	std::string temp2 ;
5122	>	PyObject * obj0 = 0 ;
5123	>	PyObject * obj1 = 0 ;
5124	>
5125	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5126	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5127	>	{
5128	>	if (PyString_Check(obj1)) {
5129	>	temp2 = std::string(PyString_AsString(obj1));
5130	>	arg2 = &temp2;
5131	>	}else {
5132	>	SWIG_exception(SWIG_TypeError, "string expected");
5133	>	}
5134	>	}
5135	>	{
5136	>	try {
5137	>	result = (int)(arg1)->loadByName((std::string const &)*arg2);
5138	>
5139	>	}catch (const BossSchedFailure & e) {
5140	>	PyErr_SetString ( SchedulerError, e.what() );
5141	>	return NULL;
5142	>	}catch (const std::exception& e) {
5143	>	PyErr_SetString ( BossError, e.what() );
5144	>	return NULL;
5145		}
5146		}
5147		resultobj = PyInt_FromLong((long)result);
#	Line 4808 \| Line 5233 \| *static PyObject _wrap_BossTask_load(PyO**
5233		result = (int)(arg1)->load(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8);
5234
5235		}catch (const BossSchedFailure & e) {
5236	<	SWIG_exception(SWIG_ValueError, e.what());
5236	>	PyErr_SetString ( SchedulerError, e.what() );
5237	>	return NULL;
5238	>	}catch (const std::exception& e) {
5239	>	PyErr_SetString ( BossError, e.what() );
5240	>	return NULL;
5241	>	}
5242	>	}
5243	>	resultobj = PyInt_FromLong((long)result);
5244	>	return resultobj;
5245	>	fail:
5246	>	return NULL;
5247	>	}
5248	>
5249	>
5250	>	static PyObject _wrap_BossTask_schedulerQuery(PyObject self, PyObject *args) {
5251	>	PyObject *resultobj;
5252	>	BossTask arg1 = (BossTask ) 0 ;
5253	>	int arg2 = (int) SCHEDULED ;
5254	>	std::string const &arg3_defvalue = "all" ;
5255	>	std::string arg3 = (std::string ) &arg3_defvalue ;
5256	>	std::string const &arg4_defvalue = "" ;
5257	>	std::string arg4 = (std::string ) &arg4_defvalue ;
5258	>	std::string arg5 = (std::string) "" ;
5259	>	std::string arg6 = (std::string) "" ;
5260	>	std::string arg7 = (std::string) "" ;
5261	>	std::string arg8 = (std::string) "" ;
5262	>	unsigned int arg9 = (unsigned int) 0 ;
5263	>	int result;
5264	>	std::string temp3 ;
5265	>	std::string temp4 ;
5266	>	PyObject * obj0 = 0 ;
5267	>	PyObject * obj2 = 0 ;
5268	>	PyObject * obj3 = 0 ;
5269	>	PyObject * obj4 = 0 ;
5270	>	PyObject * obj5 = 0 ;
5271	>	PyObject * obj6 = 0 ;
5272	>	PyObject * obj7 = 0 ;
5273	>	PyObject * obj8 = 0 ;
5274	>
5275	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5276	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5277	>	if (obj2) {
5278	>	{
5279	>	if (PyString_Check(obj2)) {
5280	>	temp3 = std::string(PyString_AsString(obj2));
5281	>	arg3 = &temp3;
5282	>	}else {
5283	>	SWIG_exception(SWIG_TypeError, "string expected");
5284	>	}
5285	>	}
5286	>	}
5287	>	if (obj3) {
5288	>	{
5289	>	if (PyString_Check(obj3)) {
5290	>	temp4 = std::string(PyString_AsString(obj3));
5291	>	arg4 = &temp4;
5292	>	}else {
5293	>	SWIG_exception(SWIG_TypeError, "string expected");
5294	>	}
5295	>	}
5296	>	}
5297	>	if (obj4) {
5298	>	{
5299	>	if (PyString_Check(obj4))
5300	>	arg5 = std::string(PyString_AsString(obj4));
5301	>	else
5302	>	SWIG_exception(SWIG_TypeError, "string expected");
5303	>	}
5304	>	}
5305	>	if (obj5) {
5306	>	{
5307	>	if (PyString_Check(obj5))
5308	>	arg6 = std::string(PyString_AsString(obj5));
5309	>	else
5310	>	SWIG_exception(SWIG_TypeError, "string expected");
5311	>	}
5312	>	}
5313	>	if (obj6) {
5314	>	{
5315	>	if (PyString_Check(obj6))
5316	>	arg7 = std::string(PyString_AsString(obj6));
5317	>	else
5318	>	SWIG_exception(SWIG_TypeError, "string expected");
5319	>	}
5320	>	}
5321	>	if (obj7) {
5322	>	{
5323	>	if (PyString_Check(obj7))
5324	>	arg8 = std::string(PyString_AsString(obj7));
5325	>	else
5326	>	SWIG_exception(SWIG_TypeError, "string expected");
5327	>	}
5328	>	}
5329	>	if (obj8) {
5330	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5331	>	if (PyErr_Occurred()) SWIG_fail;
5332	>	}
5333	>	{
5334	>	try {
5335	>	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9);
5336	>
5337	>	}catch (const BossSchedFailure & e) {
5338	>	PyErr_SetString ( SchedulerError, e.what() );
5339	>	return NULL;
5340		}catch (const std::exception& e) {
5341	<	SWIG_exception(SWIG_RuntimeError, e.what());
5341	>	PyErr_SetString ( BossError, e.what() );
5342	>	return NULL;
5343		}
5344		}
5345		resultobj = PyInt_FromLong((long)result);
#	Line 4832 \| Line 5361 \| *static PyObject _wrap_BossTask_query(Py**
5361		std::string arg6 = (std::string) "" ;
5362		std::string arg7 = (std::string) "" ;
5363		std::string arg8 = (std::string) "" ;
5364	<	bool arg9 = (bool) false ;
5364	>	unsigned int arg9 = (unsigned int) 0 ;
5365	>	bool arg10 = (bool) false ;
5366		int result;
5367		std::string temp3 ;
5368		std::string temp4 ;
#	Line 4844 \| Line 5374 \| *static PyObject _wrap_BossTask_query(Py**
5374		PyObject * obj6 = 0 ;
5375		PyObject * obj7 = 0 ;
5376		PyObject * obj8 = 0 ;
5377	+	PyObject * obj9 = 0 ;
5378
5379	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5379	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5380		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5381		if (obj2) {
5382		{
#	Line 4900 \| Line 5431 \| *static PyObject _wrap_BossTask_query(Py**
5431		}
5432		}
5433		if (obj8) {
5434	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5434	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5435	>	if (PyErr_Occurred()) SWIG_fail;
5436	>	}
5437	>	if (obj9) {
5438	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5439		if (PyErr_Occurred()) SWIG_fail;
5440		}
5441		{
5442		try {
5443	<	result = (int)(arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9);
5443	>	result = (int)(arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5444
5445		}catch (const BossSchedFailure & e) {
5446	<	SWIG_exception(SWIG_ValueError, e.what());
5446	>	PyErr_SetString ( SchedulerError, e.what() );
5447	>	return NULL;
5448		}catch (const std::exception& e) {
5449	<	SWIG_exception(SWIG_RuntimeError, e.what());
5449	>	PyErr_SetString ( BossError, e.what() );
5450	>	return NULL;
5451		}
5452		}
5453		resultobj = PyInt_FromLong((long)result);
#	Line 4969 \| Line 5506 \| *static PyObject _wrap_BossTask_query_ou**
5506		((BossTask const )arg1)->query_out(arg2,(jobStates const &)arg3,(printOption const &)arg4,arg5);
5507
5508		}catch (const BossSchedFailure & e) {
5509	<	SWIG_exception(SWIG_ValueError, e.what());
5509	>	PyErr_SetString ( SchedulerError, e.what() );
5510	>	return NULL;
5511		}catch (const std::exception& e) {
5512	<	SWIG_exception(SWIG_RuntimeError, e.what());
5512	>	PyErr_SetString ( BossError, e.what() );
5513	>	return NULL;
5514		}
5515		}
5516		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4993 \| Line 5532 \| *static PyObject _wrap_BossTask_clear(Py**
5532		(arg1)->clear();
5533
5534		}catch (const BossSchedFailure & e) {
5535	<	SWIG_exception(SWIG_ValueError, e.what());
5535	>	PyErr_SetString ( SchedulerError, e.what() );
5536	>	return NULL;
5537	>	}catch (const std::exception& e) {
5538	>	PyErr_SetString ( BossError, e.what() );
5539	>	return NULL;
5540	>	}
5541	>	}
5542	>	Py_INCREF(Py_None); resultobj = Py_None;
5543	>	return resultobj;
5544	>	fail:
5545	>	return NULL;
5546	>	}
5547	>
5548	>
5549	>	static PyObject _wrap_BossTask_appendToPyDict(PyObject self, PyObject *args) {
5550	>	PyObject *resultobj;
5551	>	BossTask arg1 = (BossTask ) 0 ;
5552	>	PyObject arg2 = (PyObject ) 0 ;
5553	>	BossAttributeContainer *arg3 = 0 ;
5554	>	PyObject * obj0 = 0 ;
5555	>	PyObject * obj1 = 0 ;
5556	>	PyObject * obj2 = 0 ;
5557	>
5558	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5559	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5560	>	arg2 = obj1;
5561	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5562	>	if (arg3 == NULL) {
5563	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5564	>	}
5565	>	{
5566	>	try {
5567	>	BossTask_appendToPyDict((BossTask const )arg1,arg2,(BossAttributeContainer const &)arg3);
5568	>
5569	>	}catch (const BossSchedFailure & e) {
5570	>	PyErr_SetString ( SchedulerError, e.what() );
5571	>	return NULL;
5572	>	}catch (const std::exception& e) {
5573	>	PyErr_SetString ( BossError, e.what() );
5574	>	return NULL;
5575	>	}
5576	>	}
5577	>	Py_INCREF(Py_None); resultobj = Py_None;
5578	>	return resultobj;
5579	>	fail:
5580	>	return NULL;
5581	>	}
5582	>
5583	>
5584	>	static PyObject _wrap_BossTask_jobDict(PyObject self, PyObject *args) {
5585	>	PyObject *resultobj;
5586	>	BossTask arg1 = (BossTask ) 0 ;
5587	>	BossJob arg2 = (BossJob ) 0 ;
5588	>	PyObject arg3 = (PyObject ) 0 ;
5589	>	PyObject * obj0 = 0 ;
5590	>	PyObject * obj1 = 0 ;
5591	>	PyObject * obj2 = 0 ;
5592	>
5593	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5594	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5595	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5596	>	arg3 = obj2;
5597	>	{
5598	>	try {
5599	>	BossTask_jobDict((BossTask const )arg1,(BossJob const )arg2,arg3);
5600	>
5601	>	}catch (const BossSchedFailure & e) {
5602	>	PyErr_SetString ( SchedulerError, e.what() );
5603	>	return NULL;
5604		}catch (const std::exception& e) {
5605	<	SWIG_exception(SWIG_RuntimeError, e.what());
5605	>	PyErr_SetString ( BossError, e.what() );
5606	>	return NULL;
5607		}
5608		}
5609		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5005 \| Line 5613 \| *static PyObject _wrap_BossTask_clear(Py**
5613		}
5614
5615
5616	+	static PyObject _wrap_BossTask_jobsDict(PyObject self, PyObject *args) {
5617	+	PyObject *resultobj;
5618	+	BossTask arg1 = (BossTask ) 0 ;
5619	+	PyObject *result;
5620	+	PyObject * obj0 = 0 ;
5621	+
5622	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5623	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5624	+	{
5625	+	try {
5626	+	result = (PyObject *)BossTask_jobsDict(arg1);
5627	+
5628	+	}catch (const BossSchedFailure & e) {
5629	+	PyErr_SetString ( SchedulerError, e.what() );
5630	+	return NULL;
5631	+	}catch (const std::exception& e) {
5632	+	PyErr_SetString ( BossError, e.what() );
5633	+	return NULL;
5634	+	}
5635	+	}
5636	+	resultobj = result;
5637	+	return resultobj;
5638	+	fail:
5639	+	return NULL;
5640	+	}
5641	+
5642	+
5643	+	static PyObject _wrap_BossTask_job(PyObject self, PyObject *args) {
5644	+	PyObject *resultobj;
5645	+	BossTask arg1 = (BossTask ) 0 ;
5646	+	std::string *arg2 = 0 ;
5647	+	PyObject *result;
5648	+	std::string temp2 ;
5649	+	PyObject * obj0 = 0 ;
5650	+	PyObject * obj1 = 0 ;
5651	+
5652	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5653	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5654	+	{
5655	+	if (PyString_Check(obj1)) {
5656	+	temp2 = std::string(PyString_AsString(obj1));
5657	+	arg2 = &temp2;
5658	+	}else {
5659	+	SWIG_exception(SWIG_TypeError, "string expected");
5660	+	}
5661	+	}
5662	+	{
5663	+	try {
5664	+	result = (PyObject )BossTask_job(arg1,(std::string const &)arg2);
5665	+
5666	+	}catch (const BossSchedFailure & e) {
5667	+	PyErr_SetString ( SchedulerError, e.what() );
5668	+	return NULL;
5669	+	}catch (const std::exception& e) {
5670	+	PyErr_SetString ( BossError, e.what() );
5671	+	return NULL;
5672	+	}
5673	+	}
5674	+	resultobj = result;
5675	+	return resultobj;
5676	+	fail:
5677	+	return NULL;
5678	+	}
5679	+
5680	+
5681	+	static PyObject _wrap_BossTask_Chain(PyObject self, PyObject *args) {
5682	+	PyObject *resultobj;
5683	+	BossTask arg1 = (BossTask ) 0 ;
5684	+	std::string *arg2 = 0 ;
5685	+	PyObject *result;
5686	+	std::string temp2 ;
5687	+	PyObject * obj0 = 0 ;
5688	+	PyObject * obj1 = 0 ;
5689	+
5690	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5691	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5692	+	{
5693	+	if (PyString_Check(obj1)) {
5694	+	temp2 = std::string(PyString_AsString(obj1));
5695	+	arg2 = &temp2;
5696	+	}else {
5697	+	SWIG_exception(SWIG_TypeError, "string expected");
5698	+	}
5699	+	}
5700	+	{
5701	+	try {
5702	+	result = (PyObject )BossTask_Chain(arg1,(std::string const &)arg2);
5703	+
5704	+	}catch (const BossSchedFailure & e) {
5705	+	PyErr_SetString ( SchedulerError, e.what() );
5706	+	return NULL;
5707	+	}catch (const std::exception& e) {
5708	+	PyErr_SetString ( BossError, e.what() );
5709	+	return NULL;
5710	+	}
5711	+	}
5712	+	resultobj = result;
5713	+	return resultobj;
5714	+	fail:
5715	+	return NULL;
5716	+	}
5717	+
5718	+
5719	+	static PyObject _wrap_BossTask_jobStates(PyObject self, PyObject *args) {
5720	+	PyObject *resultobj;
5721	+	BossTask arg1 = (BossTask ) 0 ;
5722	+	PyObject *result;
5723	+	PyObject * obj0 = 0 ;
5724	+
5725	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5726	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5727	+	{
5728	+	try {
5729	+	result = (PyObject *)BossTask_jobStates(arg1);
5730	+
5731	+	}catch (const BossSchedFailure & e) {
5732	+	PyErr_SetString ( SchedulerError, e.what() );
5733	+	return NULL;
5734	+	}catch (const std::exception& e) {
5735	+	PyErr_SetString ( BossError, e.what() );
5736	+	return NULL;
5737	+	}
5738	+	}
5739	+	resultobj = result;
5740	+	return resultobj;
5741	+	fail:
5742	+	return NULL;
5743	+	}
5744	+
5745	+
5746	+	static PyObject _wrap_BossTask_joblist(PyObject self, PyObject *args) {
5747	+	PyObject *resultobj;
5748	+	BossTask arg1 = (BossTask ) 0 ;
5749	+	PyObject *result;
5750	+	PyObject * obj0 = 0 ;
5751	+
5752	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_joblist",&obj0)) goto fail;
5753	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5754	+	{
5755	+	try {
5756	+	result = (PyObject *)BossTask_joblist(arg1);
5757	+
5758	+	}catch (const BossSchedFailure & e) {
5759	+	PyErr_SetString ( SchedulerError, e.what() );
5760	+	return NULL;
5761	+	}catch (const std::exception& e) {
5762	+	PyErr_SetString ( BossError, e.what() );
5763	+	return NULL;
5764	+	}
5765	+	}
5766	+	resultobj = result;
5767	+	return resultobj;
5768	+	fail:
5769	+	return NULL;
5770	+	}
5771	+
5772	+
5773	+	static PyObject _wrap_BossTask_jobStatistic(PyObject self, PyObject *args) {
5774	+	PyObject *resultobj;
5775	+	BossTask arg1 = (BossTask ) 0 ;
5776	+	PyObject *result;
5777	+	PyObject * obj0 = 0 ;
5778	+
5779	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5780	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5781	+	{
5782	+	try {
5783	+	result = (PyObject *)BossTask_jobStatistic(arg1);
5784	+
5785	+	}catch (const BossSchedFailure & e) {
5786	+	PyErr_SetString ( SchedulerError, e.what() );
5787	+	return NULL;
5788	+	}catch (const std::exception& e) {
5789	+	PyErr_SetString ( BossError, e.what() );
5790	+	return NULL;
5791	+	}
5792	+	}
5793	+	resultobj = result;
5794	+	return resultobj;
5795	+	fail:
5796	+	return NULL;
5797	+	}
5798	+
5799	+
5800	+	static PyObject _wrap_BossTask_progDict(PyObject self, PyObject *args) {
5801	+	PyObject *resultobj;
5802	+	BossTask arg1 = (BossTask ) 0 ;
5803	+	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5804	+	PyObject *result;
5805	+	PyObject * obj0 = 0 ;
5806	+	PyObject * obj1 = 0 ;
5807	+
5808	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5809	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5810	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5811	+	if (arg2 == NULL) {
5812	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5813	+	}
5814	+	{
5815	+	try {
5816	+	result = (PyObject )BossTask_progDict((BossTask const )arg1,*arg2);
5817	+
5818	+	}catch (const BossSchedFailure & e) {
5819	+	PyErr_SetString ( SchedulerError, e.what() );
5820	+	return NULL;
5821	+	}catch (const std::exception& e) {
5822	+	PyErr_SetString ( BossError, e.what() );
5823	+	return NULL;
5824	+	}
5825	+	}
5826	+	resultobj = result;
5827	+	return resultobj;
5828	+	fail:
5829	+	return NULL;
5830	+	}
5831	+
5832	+
5833	+	static PyObject _wrap_BossTask_jobPrograms(PyObject self, PyObject *args) {
5834	+	PyObject *resultobj;
5835	+	BossTask arg1 = (BossTask ) 0 ;
5836	+	std::string *arg2 = 0 ;
5837	+	PyObject *result;
5838	+	std::string temp2 ;
5839	+	PyObject * obj0 = 0 ;
5840	+	PyObject * obj1 = 0 ;
5841	+
5842	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5843	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5844	+	{
5845	+	if (PyString_Check(obj1)) {
5846	+	temp2 = std::string(PyString_AsString(obj1));
5847	+	arg2 = &temp2;
5848	+	}else {
5849	+	SWIG_exception(SWIG_TypeError, "string expected");
5850	+	}
5851	+	}
5852	+	{
5853	+	try {
5854	+	result = (PyObject )BossTask_jobPrograms((BossTask const )arg1,(std::string const &)*arg2);
5855	+
5856	+	}catch (const BossSchedFailure & e) {
5857	+	PyErr_SetString ( SchedulerError, e.what() );
5858	+	return NULL;
5859	+	}catch (const std::exception& e) {
5860	+	PyErr_SetString ( BossError, e.what() );
5861	+	return NULL;
5862	+	}
5863	+	}
5864	+	resultobj = result;
5865	+	return resultobj;
5866	+	fail:
5867	+	return NULL;
5868	+	}
5869	+
5870	+
5871	+	static PyObject _wrap_BossTask_program(PyObject self, PyObject *args) {
5872	+	PyObject *resultobj;
5873	+	BossTask arg1 = (BossTask ) 0 ;
5874	+	std::string *arg2 = 0 ;
5875	+	std::string *arg3 = 0 ;
5876	+	PyObject *result;
5877	+	std::string temp2 ;
5878	+	std::string temp3 ;
5879	+	PyObject * obj0 = 0 ;
5880	+	PyObject * obj1 = 0 ;
5881	+	PyObject * obj2 = 0 ;
5882	+
5883	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5884	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5885	+	{
5886	+	if (PyString_Check(obj1)) {
5887	+	temp2 = std::string(PyString_AsString(obj1));
5888	+	arg2 = &temp2;
5889	+	}else {
5890	+	SWIG_exception(SWIG_TypeError, "string expected");
5891	+	}
5892	+	}
5893	+	{
5894	+	if (PyString_Check(obj2)) {
5895	+	temp3 = std::string(PyString_AsString(obj2));
5896	+	arg3 = &temp3;
5897	+	}else {
5898	+	SWIG_exception(SWIG_TypeError, "string expected");
5899	+	}
5900	+	}
5901	+	{
5902	+	try {
5903	+	result = (PyObject )BossTask_program(arg1,(std::string const &)arg2,(std::string const &)*arg3);
5904	+
5905	+	}catch (const BossSchedFailure & e) {
5906	+	PyErr_SetString ( SchedulerError, e.what() );
5907	+	return NULL;
5908	+	}catch (const std::exception& e) {
5909	+	PyErr_SetString ( BossError, e.what() );
5910	+	return NULL;
5911	+	}
5912	+	}
5913	+	resultobj = result;
5914	+	return resultobj;
5915	+	fail:
5916	+	return NULL;
5917	+	}
5918	+
5919	+
5920	+	static PyObject _wrap_BossTask_programExec(PyObject self, PyObject *args) {
5921	+	PyObject *resultobj;
5922	+	BossTask arg1 = (BossTask ) 0 ;
5923	+	std::string *arg2 = 0 ;
5924	+	std::string *arg3 = 0 ;
5925	+	PyObject *result;
5926	+	std::string temp2 ;
5927	+	std::string temp3 ;
5928	+	PyObject * obj0 = 0 ;
5929	+	PyObject * obj1 = 0 ;
5930	+	PyObject * obj2 = 0 ;
5931	+
5932	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
5933	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5934	+	{
5935	+	if (PyString_Check(obj1)) {
5936	+	temp2 = std::string(PyString_AsString(obj1));
5937	+	arg2 = &temp2;
5938	+	}else {
5939	+	SWIG_exception(SWIG_TypeError, "string expected");
5940	+	}
5941	+	}
5942	+	{
5943	+	if (PyString_Check(obj2)) {
5944	+	temp3 = std::string(PyString_AsString(obj2));
5945	+	arg3 = &temp3;
5946	+	}else {
5947	+	SWIG_exception(SWIG_TypeError, "string expected");
5948	+	}
5949	+	}
5950	+	{
5951	+	try {
5952	+	result = (PyObject )BossTask_programExec(arg1,(std::string const &)arg2,(std::string const &)*arg3);
5953	+
5954	+	}catch (const BossSchedFailure & e) {
5955	+	PyErr_SetString ( SchedulerError, e.what() );
5956	+	return NULL;
5957	+	}catch (const std::exception& e) {
5958	+	PyErr_SetString ( BossError, e.what() );
5959	+	return NULL;
5960	+	}
5961	+	}
5962	+	resultobj = result;
5963	+	return resultobj;
5964	+	fail:
5965	+	return NULL;
5966	+	}
5967	+
5968	+
5969	+	static PyObject _wrap_BossTask_specific(PyObject self, PyObject *args) {
5970	+	PyObject *resultobj;
5971	+	BossTask arg1 = (BossTask ) 0 ;
5972	+	std::string *arg2 = 0 ;
5973	+	std::string *arg3 = 0 ;
5974	+	PyObject *result;
5975	+	std::string temp2 ;
5976	+	std::string temp3 ;
5977	+	PyObject * obj0 = 0 ;
5978	+	PyObject * obj1 = 0 ;
5979	+	PyObject * obj2 = 0 ;
5980	+
5981	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
5982	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5983	+	{
5984	+	if (PyString_Check(obj1)) {
5985	+	temp2 = std::string(PyString_AsString(obj1));
5986	+	arg2 = &temp2;
5987	+	}else {
5988	+	SWIG_exception(SWIG_TypeError, "string expected");
5989	+	}
5990	+	}
5991	+	{
5992	+	if (PyString_Check(obj2)) {
5993	+	temp3 = std::string(PyString_AsString(obj2));
5994	+	arg3 = &temp3;
5995	+	}else {
5996	+	SWIG_exception(SWIG_TypeError, "string expected");
5997	+	}
5998	+	}
5999	+	{
6000	+	try {
6001	+	result = (PyObject )BossTask_specific(arg1,(std::string const &)arg2,(std::string const &)*arg3);
6002	+
6003	+	}catch (const BossSchedFailure & e) {
6004	+	PyErr_SetString ( SchedulerError, e.what() );
6005	+	return NULL;
6006	+	}catch (const std::exception& e) {
6007	+	PyErr_SetString ( BossError, e.what() );
6008	+	return NULL;
6009	+	}
6010	+	}
6011	+	resultobj = result;
6012	+	return resultobj;
6013	+	fail:
6014	+	return NULL;
6015	+	}
6016	+
6017	+
6018		static PyObject * BossTask_swigregister(PyObject self, PyObject args) {
6019		PyObject *obj;
6020		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 5017 \| Line 6027 \| *static PyObject _wrap_new_BossAdministr**
6027		std::string arg1 = (std::string) "" ;
6028		std::string arg2 = (std::string) "2" ;
6029		std::string arg3 = (std::string) "" ;
6030	<	bool arg4 = (bool) false ;
6030	>	std::string arg4 = (std::string) "" ;
6031	>	bool arg5 = (bool) false ;
6032		BossAdministratorSession *result;
6033		PyObject * obj0 = 0 ;
6034		PyObject * obj1 = 0 ;
6035		PyObject * obj2 = 0 ;
6036		PyObject * obj3 = 0 ;
6037	+	PyObject * obj4 = 0 ;
6038
6039	<	if(!PyArg_ParseTuple(args,(char *)"\|OOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
6039	>	if(!PyArg_ParseTuple(args,(char *)"\|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6040		if (obj0) {
6041		{
6042		if (PyString_Check(obj0))
#	Line 5050 \| Line 6062 \| *static PyObject _wrap_new_BossAdministr**
6062		}
6063		}
6064		if (obj3) {
6065	<	arg4 = PyInt_AsLong(obj3) ? true : false;
6065	>	{
6066	>	if (PyString_Check(obj3))
6067	>	arg4 = std::string(PyString_AsString(obj3));
6068	>	else
6069	>	SWIG_exception(SWIG_TypeError, "string expected");
6070	>	}
6071	>	}
6072	>	if (obj4) {
6073	>	arg5 = PyInt_AsLong(obj4) ? true : false;
6074		if (PyErr_Occurred()) SWIG_fail;
6075		}
6076		{
6077		try {
6078	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4);
6078	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
6079
6080		}catch (const BossSchedFailure & e) {
6081	<	SWIG_exception(SWIG_ValueError, e.what());
6081	>	PyErr_SetString ( SchedulerError, e.what() );
6082	>	return NULL;
6083		}catch (const std::exception& e) {
6084	<	SWIG_exception(SWIG_RuntimeError, e.what());
6084	>	PyErr_SetString ( BossError, e.what() );
6085	>	return NULL;
6086		}
6087		}
6088		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 5082 \| Line 6104 \| *static PyObject _wrap_delete_BossAdmini**
6104		delete arg1;
6105
6106		}catch (const BossSchedFailure & e) {
6107	<	SWIG_exception(SWIG_ValueError, e.what());
6107	>	PyErr_SetString ( SchedulerError, e.what() );
6108	>	return NULL;
6109		}catch (const std::exception& e) {
6110	<	SWIG_exception(SWIG_RuntimeError, e.what());
6110	>	PyErr_SetString ( BossError, e.what() );
6111	>	return NULL;
6112		}
6113		}
6114		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5107 \| Line 6131 \| *static PyObject _wrap_BossAdministrator**
6131		result = (int)(arg1)->configureDB();
6132
6133		}catch (const BossSchedFailure & e) {
6134	<	SWIG_exception(SWIG_ValueError, e.what());
6134	>	PyErr_SetString ( SchedulerError, e.what() );
6135	>	return NULL;
6136		}catch (const std::exception& e) {
6137	<	SWIG_exception(SWIG_RuntimeError, e.what());
6137	>	PyErr_SetString ( BossError, e.what() );
6138	>	return NULL;
6139		}
6140		}
6141		resultobj = PyInt_FromLong((long)result);
#	Line 5143 \| Line 6169 \| *static PyObject _wrap_BossAdministrator**
6169		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
6170
6171		}catch (const BossSchedFailure & e) {
6172	<	SWIG_exception(SWIG_ValueError, e.what());
6172	>	PyErr_SetString ( SchedulerError, e.what() );
6173	>	return NULL;
6174		}catch (const std::exception& e) {
6175	<	SWIG_exception(SWIG_RuntimeError, e.what());
6175	>	PyErr_SetString ( BossError, e.what() );
6176	>	return NULL;
6177		}
6178		}
6179		resultobj = PyInt_FromLong((long)result);
#	Line 5179 \| Line 6207 \| *static PyObject _wrap_BossAdministrator**
6207		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
6208
6209		}catch (const BossSchedFailure & e) {
6210	<	SWIG_exception(SWIG_ValueError, e.what());
6210	>	PyErr_SetString ( SchedulerError, e.what() );
6211	>	return NULL;
6212		}catch (const std::exception& e) {
6213	<	SWIG_exception(SWIG_RuntimeError, e.what());
6213	>	PyErr_SetString ( BossError, e.what() );
6214	>	return NULL;
6215		}
6216		}
6217		resultobj = PyInt_FromLong((long)result);
#	Line 5215 \| Line 6245 \| *static PyObject _wrap_BossAdministrator**
6245		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
6246
6247		}catch (const BossSchedFailure & e) {
6248	<	SWIG_exception(SWIG_ValueError, e.what());
6248	>	PyErr_SetString ( SchedulerError, e.what() );
6249	>	return NULL;
6250		}catch (const std::exception& e) {
6251	<	SWIG_exception(SWIG_RuntimeError, e.what());
6251	>	PyErr_SetString ( BossError, e.what() );
6252	>	return NULL;
6253		}
6254		}
6255		resultobj = PyInt_FromLong((long)result);
#	Line 5251 \| Line 6283 \| *static PyObject _wrap_BossAdministrator**
6283		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
6284
6285		}catch (const BossSchedFailure & e) {
6286	<	SWIG_exception(SWIG_ValueError, e.what());
6286	>	PyErr_SetString ( SchedulerError, e.what() );
6287	>	return NULL;
6288		}catch (const std::exception& e) {
6289	<	SWIG_exception(SWIG_RuntimeError, e.what());
6289	>	PyErr_SetString ( BossError, e.what() );
6290	>	return NULL;
6291		}
6292		}
6293		resultobj = PyInt_FromLong((long)result);
#	Line 5287 \| Line 6321 \| *static PyObject _wrap_BossAdministrator**
6321		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
6322
6323		}catch (const BossSchedFailure & e) {
6324	<	SWIG_exception(SWIG_ValueError, e.what());
6324	>	PyErr_SetString ( SchedulerError, e.what() );
6325	>	return NULL;
6326		}catch (const std::exception& e) {
6327	<	SWIG_exception(SWIG_RuntimeError, e.what());
6327	>	PyErr_SetString ( BossError, e.what() );
6328	>	return NULL;
6329		}
6330		}
6331		resultobj = PyInt_FromLong((long)result);
#	Line 5355 \| Line 6391 \| *static PyObject _wrap_BossAdministrator**
6391		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
6392
6393		}catch (const BossSchedFailure & e) {
6394	<	SWIG_exception(SWIG_ValueError, e.what());
6394	>	PyErr_SetString ( SchedulerError, e.what() );
6395	>	return NULL;
6396		}catch (const std::exception& e) {
6397	<	SWIG_exception(SWIG_RuntimeError, e.what());
6397	>	PyErr_SetString ( BossError, e.what() );
6398	>	return NULL;
6399		}
6400		}
6401		resultobj = PyInt_FromLong((long)result);
#	Line 5447 \| Line 6485 \| *static PyObject _wrap_BossAdministrator**
6485		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
6486
6487		}catch (const BossSchedFailure & e) {
6488	<	SWIG_exception(SWIG_ValueError, e.what());
6488	>	PyErr_SetString ( SchedulerError, e.what() );
6489	>	return NULL;
6490		}catch (const std::exception& e) {
6491	<	SWIG_exception(SWIG_RuntimeError, e.what());
6491	>	PyErr_SetString ( BossError, e.what() );
6492	>	return NULL;
6493		}
6494		}
6495		resultobj = PyInt_FromLong((long)result);
#	Line 5525 \| Line 6565 \| *static PyObject _wrap_BossAdministrator**
6565		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6566
6567		}catch (const BossSchedFailure & e) {
6568	<	SWIG_exception(SWIG_ValueError, e.what());
6568	>	PyErr_SetString ( SchedulerError, e.what() );
6569	>	return NULL;
6570		}catch (const std::exception& e) {
6571	<	SWIG_exception(SWIG_RuntimeError, e.what());
6571	>	PyErr_SetString ( BossError, e.what() );
6572	>	return NULL;
6573		}
6574		}
6575		resultobj = PyInt_FromLong((long)result);
#	Line 5699 \| Line 6741 \| *static PyObject _wrap_BossAdministrator**
6741		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);
6742
6743		}catch (const BossSchedFailure & e) {
6744	<	SWIG_exception(SWIG_ValueError, e.what());
6744	>	PyErr_SetString ( SchedulerError, e.what() );
6745	>	return NULL;
6746		}catch (const std::exception& e) {
6747	<	SWIG_exception(SWIG_RuntimeError, e.what());
6747	>	PyErr_SetString ( BossError, e.what() );
6748	>	return NULL;
6749		}
6750		}
6751		resultobj = PyInt_FromLong((long)result);
#	Line 5724 \| Line 6768 \| *static PyObject _wrap_BossAdministrator**
6768		result = (arg1)->help();
6769
6770		}catch (const BossSchedFailure & e) {
6771	<	SWIG_exception(SWIG_ValueError, e.what());
6771	>	PyErr_SetString ( SchedulerError, e.what() );
6772	>	return NULL;
6773		}catch (const std::exception& e) {
6774	<	SWIG_exception(SWIG_RuntimeError, e.what());
6774	>	PyErr_SetString ( BossError, e.what() );
6775	>	return NULL;
6776		}
6777		}
6778		{
#	Line 5765 \| Line 6811 \| *static PyObject _wrap_BossAdministrator**
6811		result = (arg1)->SQL(arg2,arg3);
6812
6813		}catch (const BossSchedFailure & e) {
6814	<	SWIG_exception(SWIG_ValueError, e.what());
6814	>	PyErr_SetString ( SchedulerError, e.what() );
6815	>	return NULL;
6816		}catch (const std::exception& e) {
6817	<	SWIG_exception(SWIG_RuntimeError, e.what());
6817	>	PyErr_SetString ( BossError, e.what() );
6818	>	return NULL;
6819		}
6820		}
6821		{
#	Line 5839 \| Line 6887 \| *static PyObject _wrap_BossAdministrator**
6887		result = (int)(arg1)->purge((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5);
6888
6889		}catch (const BossSchedFailure & e) {
6890	<	SWIG_exception(SWIG_ValueError, e.what());
6890	>	PyErr_SetString ( SchedulerError, e.what() );
6891	>	return NULL;
6892		}catch (const std::exception& e) {
6893	<	SWIG_exception(SWIG_RuntimeError, e.what());
6893	>	PyErr_SetString ( BossError, e.what() );
6894	>	return NULL;
6895		}
6896		}
6897		resultobj = PyInt_FromLong((long)result);
#	Line 5872 \| Line 6922 \| *static PyObject _wrap_BossAdministrator**
6922		result = (int)(arg1)->registerPlugins(arg2);
6923
6924		}catch (const BossSchedFailure & e) {
6925	<	SWIG_exception(SWIG_ValueError, e.what());
6925	>	PyErr_SetString ( SchedulerError, e.what() );
6926	>	return NULL;
6927		}catch (const std::exception& e) {
6928	<	SWIG_exception(SWIG_RuntimeError, e.what());
6928	>	PyErr_SetString ( BossError, e.what() );
6929	>	return NULL;
6930		}
6931		}
6932		resultobj = PyInt_FromLong((long)result);
#	Line 5921 \| Line 6973 \| static PyMethodDef SwigMethods[] = {
6973		{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6974		{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6975		{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5924	–	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5925	–	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5926	–	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5927	–	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5928	–	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5929	–	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5930	–	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6976		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6977		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6978		{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6979		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6980	+	{ (char *)"BossSession_task_begin", _wrap_BossSession_task_begin, METH_VARARGS },
6981	+	{ (char *)"BossSession_task_end", _wrap_BossSession_task_end, METH_VARARGS },
6982	+	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
6983	+	{ (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
6984		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6985		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6986	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6987	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6988	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6989	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6990		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6991		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6992		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5943 \| Line 6996 \| static PyMethodDef SwigMethods[] = {
6996		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
6997		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6998		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
5946	–	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
5947	–	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6999		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
7000	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
7001	+	{ (char *)"BossSession_getTasksByTaskInfo", _wrap_BossSession_getTasksByTaskInfo, METH_VARARGS },
7002	+	{ (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
7003	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7004	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7005	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
7006	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
7007	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
7008	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7009	+	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7010		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5950	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5951	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7011		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
5953	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7012		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7013		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7014	<	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7015	<	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7016	<	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7017	<	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7018	<	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7014	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7015	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7016	>	{ (char *)"BossTask_jobsInMemory", _wrap_BossTask_jobsInMemory, METH_VARARGS },
7017	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7018	>	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7019	>	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
7020		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
7021		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7022		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7023		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7024	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7025		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5966	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5967	–	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7026		{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7027		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
7028		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
5971	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7029		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7030		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7031		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
#	Line 5976 \| Line 7033 \| static PyMethodDef SwigMethods[] = {
7033		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
7034		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
7035		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7036	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7037		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7038	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7039		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7040		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7041		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7042	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7043	+	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7044	+	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7045	+	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7046	+	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7047	+	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7048	+	{ (char *)"BossTask_joblist", _wrap_BossTask_joblist, METH_VARARGS },
7049	+	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7050	+	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7051	+	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7052	+	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7053	+	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7054	+	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7055		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
7056		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7057		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 6005 \| Line 7077 \| static PyMethodDef SwigMethods[] = {
7077		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7078
7079		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}};
6008	–	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}};
7080		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7081	<	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}};
7081	>	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}};
7082	>	static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7083	>	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7084		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}};
7085		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7086		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7087		static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7088	<	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7088	>	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7089		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7090	+	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7091		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
7092		static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
7093		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
#	Line 6021 \| Line 7095 \| static swig_type_info _swigt__p_std__vec
7095		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}};
7096		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
7097		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}};
7098	+	static swig_type_info _swigt__p_BossSession__task_iterator[] = {{"_p_BossSession__task_iterator", 0, "BossSession::task_iterator const *", 0},{"_p_BossSession__task_iterator"},{0}};
7099		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}};
7100		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7101
7102		static swig_type_info *swig_types_initial[] = {
7103		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6029	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7104		_swigt__p_XMLDoc,
7105	<	_swigt__p_std__vectorTBossTask_p_t,
7105	>	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7106	>	_swigt__p_BossProgramExec,
7107	>	_swigt__p_BossChain,
7108		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
7109		_swigt__p_BossTask,
7110		_swigt__p_BossTaskException,
7111		_swigt__p_std__ostream,
7112	<	_swigt__p_BossAttributeContainer,
7112	>	_swigt__p_BossProgram,
7113		_swigt__p_printOption,
7114	+	_swigt__p_BossAttributeContainer,
7115		_swigt__p_BossJob,
7116		_swigt__p_BossDatabase,
7117		_swigt__p_BossSession,
#	Line 6042 \| Line 7119 \| _swigt__p_std__vectorTstd__string_t,
7119		_swigt__p_std__mapTstd__string_std__string_t,
7120		_swigt__p_BossAdministratorSession,
7121		_swigt__p_BossTask__job_iterator,
7122	+	_swigt__p_BossSession__task_iterator,
7123		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7124		_swigt__p_jobStates,
7125		0
#	Line 6086 \| Line 7164 \| SWIGEXPORT(void) SWIG_init(void) {
7164		}
7165		SWIG_InstallConstants(d,swig_const_table);
7166
7167	+
7168	+	// define custom exceptions
7169	+	PyObject *e;
7170	+	PyMethodDef tp_methods = {
7171	+	NULL, NULL, 0, NULL
7172	+	};
7173	+	e = Py_InitModule("BossSession", &tp_methods);
7174	+	// generic BOSS exception
7175	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
7176	+	Py_INCREF(BossError);
7177	+	PyModule_AddObject(e, "BossError", BossError);
7178	+	// scheduler interaction BOSS exception
7179	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
7180	+	Py_INCREF(SchedulerError);
7181	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
7182	+
7183		}
7184

Diff Legend

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents): Revision 1.17 by gcodispo, Thu Dec 7 09:31:22 2006 UTC vs. Revision 1.37 by gcodispo, Wed Jul 18 13:53:45 2007 UTC

Diff Legend

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.17 by gcodispo, Thu Dec 7 09:31:22 2006 UTC vs.
Revision 1.37 by gcodispo, Wed Jul 18 13:53:45 2007 UTC