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

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

Diff Legend

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents): Revision 1.13 by gcodispo, Fri Nov 3 15:03:10 2006 UTC vs. Revision 1.36 by gcodispo, Wed Jul 18 08:59:17 2007 UTC

Diff Legend

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.13 by gcodispo, Fri Nov 3 15:03:10 2006 UTC vs.
Revision 1.36 by gcodispo, Wed Jul 18 08:59:17 2007 UTC