ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.18 by gcodispo, Mon Dec 11 09:16:06 2006 UTC vs.
Revision 1.33 by gcodispo, Fri Jun 8 15:49:19 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_std__vectorTBossTask_p_t swig_types[4]
662	>	#define  SWIGTYPE_p_BossChain swig_types[5]
663	>	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[6]
664	>	#define  SWIGTYPE_p_BossTask swig_types[7]
665	>	#define  SWIGTYPE_p_BossTaskException swig_types[8]
666	>	#define  SWIGTYPE_p_std__ostream swig_types[9]
667	>	#define  SWIGTYPE_p_BossProgram swig_types[10]
668	>	#define  SWIGTYPE_p_printOption swig_types[11]
669	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[12]
670	>	#define  SWIGTYPE_p_BossJob swig_types[13]
671	>	#define  SWIGTYPE_p_BossDatabase swig_types[14]
672	>	#define  SWIGTYPE_p_BossSession swig_types[15]
673	>	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[16]
674	>	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[17]
675	>	#define  SWIGTYPE_p_BossAdministratorSession swig_types[18]
676	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[19]
677	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[20]
678	>	#define  SWIGTYPE_p_jobStates swig_types[21]
679	>	static swig_type_info *swig_types[23];
680
681		/* -------- TYPES TABLE (END) -------- */
682
#	Line 917 | Line 920 | void std_vectorlstd_string_g___delslice_
920		self->erase(self->begin()+i,self->begin()+j);
921		}
922
923	+	static PyObject * BossError;
924	+	static PyObject * SchedulerError;
925		#include "BossSession.h"
926		#include "BossAdministratorSession.h"
927		#include "BossTask.h"
928		#include "BossJob.h"
929	+	#include "BossChain.h"
930		#include "BossTaskCore.h"
931		#include "BossAttributeContainer.h"
932		#include "BossDBObject.h"
#	Line 928 | Line 934 | void std_vectorlstd_string_g___delslice_
934		#include "BossProgramExec.h"
935		#include "BossDatabase.h"
936		#include "BossScheduler.h"
937	+	#include "BossDeclaration.h"
938
939		PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
940		PyObject *  my_list = PyList_New( my_vec.size());
#	Line 954 | Line 961 | PyObject *BossSession_schedulers(BossSes
961		std::vector<std::string> my_vec = self->showSchedulers();
962		return BossSession_show( self, my_vec );
963		}
964	<	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
964	>	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout){
965		std::vector<std::string> my_vec = self->listMatch( scheduler,
966		schclassad,
960	–	keepfile,
967		taskid,
968	<	jobid);
968	>	jobid,
969	>	timeout);
970		return BossSession_show( self, my_vec );
971		}
972	<	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,bool avoidCheck){
973	<	if ( !avoidCheck ) {
974	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
975	<	type, user, after, before);
976	<	}
977	<	PyObject * job_dict = PyList_New(0);
978	<	std::vector <std::string>
972	<	taskList = self->selectTasks( taskRange, before, after, user);
973	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
974	<	it!= taskList.end(); ++it ) {
975	<	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
972	>	PyObject *BossSession_queryTasks(BossSession *self,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
973	>	PyObject * task_list = PyList_New(0);
974	>	std::vector <std::string> taskList;
975	>	if ( taskName.empty() ) {
976	>	taskList = self->selectTasks( taskRange, before, after, user);
977	>	} else {
978	>	taskList = self->selectTasksByName( taskName );
979		}
980	<	return  job_dict;
981	<	}
982	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
980	<	std::string tmp;
981	<	BossAttributeContainer::const_iterator it_end = obj.end ();
982	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
983	<	it != it_end; ++it) {
984	<	tmp = (*it).first.name ();
985	<	char * key = new char[ tmp.size() ];
986	<	key = strdup(tmp.c_str());
987	<	tmp = (*it).second.value ();
988	<	PyObject * val = PyString_FromString( tmp.c_str() );
989	<	PyDict_SetItemString( dict, key, val );
990	<	delete [] key;
980	>	for ( std::vector <std::string>::const_iterator it= taskList.begin();
981	>	it!= taskList.end(); ++it ) {
982	>	PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
983		}
984	<	return dict;
984	>	return  task_list;
985	>	}
986	>	void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
987	>	std::string tmp;
988	>	BossAttributeContainer::const_iterator it_end = obj.end ();
989	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
990	>	it != it_end; ++it) {
991	>
992	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
993	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
994	>	PyDict_SetItem( dict, key, val);
995	>	Py_DECREF(key);
996	>	Py_DECREF(val);
997		}
998	<	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
998	>	return;
999	>	}
1000	>	void BossTask_jobDict(BossTask const *self,BossJob const *jobH,PyObject *job_dict){
1001
1002	<	PyObject * job_dict = PyDict_New();
1002	>	//    PyObject * job_dict = PyDict_New();
1003		std::string tmp;
1004
1005	<	BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1006	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1005	>	BossAttributeContainer obj = jobH->getTableEntries("JOB");
1006	>	BossTask_appendToPyDict ( self, job_dict, obj );
1007
1008	<	std::set<std::string> sch = (*jit)->getSchedulerElements();
1008	>	std::set<std::string> sch = jobH->getSchedulerElements();
1009		std::set<std::string>::const_iterator sch_end =  sch.end();
1010		for (std::set<std::string>::const_iterator it =sch.begin();
1011		it != sch_end; ++ it ) {
1012	<	tmp = (*it);
1013	<	char * key = new char[ tmp.size() ];
1014	<	key = strdup(tmp.c_str());
1009	<	tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1012	>
1013	>	tmp = (*jobH)["JOB_SCHED_INFO."+(*it)];
1014	>	PyObject * key = PyString_FromString( it->c_str() );
1015		PyObject * val = PyString_FromString( tmp.c_str() );
1016	<	PyDict_SetItemString( job_dict, key, val );
1017	<	delete [] key;
1016	>	PyDict_SetItem( job_dict, key, val);
1017	>	Py_DECREF(key);
1018	>	Py_DECREF(val);
1019		}
1020	<	return job_dict;
1020	>	return;
1021		}
1022		PyObject *BossTask_jobsDict(BossTask *self){
1023
#	Line 1019 | Line 1025 | PyObject *BossTask_jobsDict(BossTask *se
1025		if ( self->job_begin () == self->job_end ()) self->load(ALL);
1026		for (BossTask::job_iterator jit = self->job_begin ();
1027		jit != self->job_end (); ++jit) {
1028	<	std::string id = (*jit)->chainId();
1029	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1030	<	PyObject * myid =  PyString_FromString(id.c_str() );
1031	<	PyDict_SetItem( job_dict, myid,tmp );
1028	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1029	>	PyObject * tmp_dict = PyDict_New();
1030	>	BossTask_jobDict( self, *jit, tmp_dict );
1031	>	PyDict_SetItem( job_dict, id, tmp_dict );
1032	>	Py_DECREF(id);
1033	>	Py_DECREF(tmp_dict);
1034	>	}
1035	>	return job_dict;
1036	>	}
1037	>	PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1038	>
1039	>	PyObject * job_dict = PyDict_New();
1040	>	self->load( ALL, jobid );
1041	>	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1042	>	return job_dict;
1043	>	}
1044	>	PyObject *BossTask_Chain(BossTask *self,std::string const &jobid){
1045	>
1046	>	PyObject * chain_dict = PyDict_New();
1047	>	BossAttributeContainer obj =
1048	>	self->chain( jobid ).getTableEntries("CHAIN");
1049	>	BossTask_appendToPyDict ( self, chain_dict, obj );
1050	>	return chain_dict;
1051	>	}
1052	>	PyObject *BossTask_jobStates(BossTask *self){
1053	>
1054	>	PyObject * job_dict = PyDict_New();
1055	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1056	>	for (BossTask::job_iterator jit = self->job_begin ();
1057	>	jit != self->job_end (); ++jit) {
1058	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1059	>	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1060	>	PyDict_SetItem( job_dict, id, status );
1061	>	Py_DECREF(id);
1062	>	Py_DECREF(status);
1063	>	}
1064	>	return job_dict;
1065	>	}
1066	>	PyObject *BossTask_jobStatistic(BossTask *self){
1067	>
1068	>	PyObject * job_dict = PyDict_New();
1069	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1070	>	std::map< std::string, int > states;
1071	>	for (BossTask::job_iterator jit = self->job_begin ();
1072	>	jit != self->job_end (); ++jit) {
1073	>	++states[(**jit)["JOB.STATUS"]];
1074	>	}
1075	>
1076	>	std::map< std::string, int >::const_iterator end = states.end ();
1077	>	for (std::map< std::string, int >::const_iterator it = states.begin ();
1078	>	it != end; ++it) {
1079	>	PyObject * status = PyString_FromString( (it->first).c_str() );
1080	>	PyObject * jobs = PyString_FromFormat( "%d", it->second );
1081	>	PyDict_SetItem( job_dict, status, jobs );
1082	>	Py_DECREF(jobs);
1083	>	Py_DECREF(status);
1084		}
1085		return job_dict;
1086		}
#	Line 1067 | Line 1125 | PyObject *BossTask_jobPrograms(BossTask
1125		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1126		++programs_it  ) {
1127		std::string id = (programs_it->first)["PROGRAM.ID"];
1128	<	PyObject * tmp =  BossTask_progDict( self, programs_it );
1128	>	PyObject * tmp_dict =  BossTask_progDict( self, programs_it );
1129		PyObject * myid =  PyString_FromString(id.c_str() );
1130	<	PyDict_SetItem( job_dict, myid,tmp );
1130	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1131	>	Py_DECREF(myid);
1132	>	Py_DECREF(tmp_dict);
1133	>	}
1134	>	return job_dict;
1135	>	}
1136	>	PyObject *BossTask_program(BossTask *self,std::string const &jobid,std::string const &programId){
1137	>
1138	>	PyObject * job_dict = PyDict_New();
1139	>
1140	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1141	>	BossAttributeContainer obj =
1142	>	self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1143	>	BossTask_appendToPyDict ( self, job_dict, obj );
1144	>	return job_dict;
1145	>	}
1146	>	PyObject *BossTask_programExec(BossTask *self,std::string const &jobid,std::string const &programId){
1147	>
1148	>	PyObject * job_dict = PyDict_New();
1149	>
1150	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1151	>
1152	>	// PROGRAM_EXEC
1153	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1154	>	BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1155	>	BossTask_appendToPyDict ( self, job_dict, obj );
1156	>
1157	>	// SPECIFICS
1158	>	std::vector < BossAttributeContainer >::const_iterator it;
1159	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1160	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1161	>	BossTask_appendToPyDict ( self, job_dict, *it );
1162	>	}
1163	>	return job_dict;
1164	>	}
1165	>	PyObject *BossTask_specific(BossTask *self,std::string const &jobid,std::string const &programId){
1166	>
1167	>	PyObject * job_dict = PyDict_New();
1168	>
1169	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1170	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1171	>	BossAttributeContainer obj = programExec.getKeys ();
1172	>	BossTask_appendToPyDict ( self, job_dict, obj );
1173	>
1174	>	std::vector < BossAttributeContainer >::const_iterator it;
1175	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1176	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1177	>	BossTask_appendToPyDict ( self, job_dict, *it );
1178		}
1179		return job_dict;
1180		}
#	Line 1086 | Line 1191 | static PyObject *_wrap_new_objectMap__SW
1191		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1192
1193		}catch (const BossSchedFailure & e) {
1194	<	SWIG_exception(SWIG_ValueError, e.what());
1194	>	PyErr_SetString ( SchedulerError, e.what() );
1195	>	return NULL;
1196		}catch (const std::exception& e) {
1197	<	SWIG_exception(SWIG_RuntimeError, e.what());
1197	>	PyErr_SetString ( BossError, e.what() );
1198	>	return NULL;
1199		}
1200		}
1201		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1147 | Line 1254 | static PyObject *_wrap_new_objectMap__SW
1254		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1255
1256		}catch (const BossSchedFailure & e) {
1257	<	SWIG_exception(SWIG_ValueError, e.what());
1257	>	PyErr_SetString ( SchedulerError, e.what() );
1258	>	return NULL;
1259		}catch (const std::exception& e) {
1260	<	SWIG_exception(SWIG_RuntimeError, e.what());
1260	>	PyErr_SetString ( BossError, e.what() );
1261	>	return NULL;
1262		}
1263		}
1264		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1264 | Line 1373 | static PyObject *_wrap_objectMap___len__
1373		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1374
1375		}catch (const BossSchedFailure & e) {
1376	<	SWIG_exception(SWIG_ValueError, e.what());
1376	>	PyErr_SetString ( SchedulerError, e.what() );
1377	>	return NULL;
1378		}catch (const std::exception& e) {
1379	<	SWIG_exception(SWIG_RuntimeError, e.what());
1379	>	PyErr_SetString ( BossError, e.what() );
1380	>	return NULL;
1381		}
1382		}
1383		resultobj = PyInt_FromLong((long)result);
#	Line 1288 | Line 1399 | static PyObject *_wrap_objectMap_clear(P
1399		(arg1)->clear();
1400
1401		}catch (const BossSchedFailure & e) {
1402	<	SWIG_exception(SWIG_ValueError, e.what());
1402	>	PyErr_SetString ( SchedulerError, e.what() );
1403	>	return NULL;
1404		}catch (const std::exception& e) {
1405	<	SWIG_exception(SWIG_RuntimeError, e.what());
1405	>	PyErr_SetString ( BossError, e.what() );
1406	>	return NULL;
1407		}
1408		}
1409		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1313 | Line 1426 | static PyObject *_wrap_objectMap___nonze
1426		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1427
1428		}catch (const BossSchedFailure & e) {
1429	<	SWIG_exception(SWIG_ValueError, e.what());
1429	>	PyErr_SetString ( SchedulerError, e.what() );
1430	>	return NULL;
1431		}catch (const std::exception& e) {
1432	<	SWIG_exception(SWIG_RuntimeError, e.what());
1432	>	PyErr_SetString ( BossError, e.what() );
1433	>	return NULL;
1434		}
1435		}
1436		resultobj = PyInt_FromLong((long)result);
#	Line 1387 | Line 1502 | static PyObject *_wrap_objectMap___setit
1502		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1503
1504		}catch (const BossSchedFailure & e) {
1505	<	SWIG_exception(SWIG_ValueError, e.what());
1505	>	PyErr_SetString ( SchedulerError, e.what() );
1506	>	return NULL;
1507		}catch (const std::exception& e) {
1508	<	SWIG_exception(SWIG_RuntimeError, e.what());
1508	>	PyErr_SetString ( BossError, e.what() );
1509	>	return NULL;
1510		}
1511		}
1512		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1451 | Line 1568 | static PyObject *_wrap_objectMap_has_key
1568		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1569
1570		}catch (const BossSchedFailure & e) {
1571	<	SWIG_exception(SWIG_ValueError, e.what());
1571	>	PyErr_SetString ( SchedulerError, e.what() );
1572	>	return NULL;
1573		}catch (const std::exception& e) {
1574	<	SWIG_exception(SWIG_RuntimeError, e.what());
1574	>	PyErr_SetString ( BossError, e.what() );
1575	>	return NULL;
1576		}
1577		}
1578		resultobj = PyInt_FromLong((long)result);
#	Line 1476 | Line 1595 | static PyObject *_wrap_objectMap_keys(Py
1595		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1596
1597		}catch (const BossSchedFailure & e) {
1598	<	SWIG_exception(SWIG_ValueError, e.what());
1598	>	PyErr_SetString ( SchedulerError, e.what() );
1599	>	return NULL;
1600		}catch (const std::exception& e) {
1601	<	SWIG_exception(SWIG_RuntimeError, e.what());
1601	>	PyErr_SetString ( BossError, e.what() );
1602	>	return NULL;
1603		}
1604		}
1605		resultobj = result;
#	Line 1501 | Line 1622 | static PyObject *_wrap_objectMap_values(
1622		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1623
1624		}catch (const BossSchedFailure & e) {
1625	<	SWIG_exception(SWIG_ValueError, e.what());
1625	>	PyErr_SetString ( SchedulerError, e.what() );
1626	>	return NULL;
1627		}catch (const std::exception& e) {
1628	<	SWIG_exception(SWIG_RuntimeError, e.what());
1628	>	PyErr_SetString ( BossError, e.what() );
1629	>	return NULL;
1630		}
1631		}
1632		resultobj = result;
#	Line 1526 | Line 1649 | static PyObject *_wrap_objectMap_items(P
1649		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1650
1651		}catch (const BossSchedFailure & e) {
1652	<	SWIG_exception(SWIG_ValueError, e.what());
1652	>	PyErr_SetString ( SchedulerError, e.what() );
1653	>	return NULL;
1654		}catch (const std::exception& e) {
1655	<	SWIG_exception(SWIG_RuntimeError, e.what());
1655	>	PyErr_SetString ( BossError, e.what() );
1656	>	return NULL;
1657		}
1658		}
1659		resultobj = result;
#	Line 1559 | Line 1684 | static PyObject *_wrap_objectMap___conta
1684		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1685
1686		}catch (const BossSchedFailure & e) {
1687	<	SWIG_exception(SWIG_ValueError, e.what());
1687	>	PyErr_SetString ( SchedulerError, e.what() );
1688	>	return NULL;
1689		}catch (const std::exception& e) {
1690	<	SWIG_exception(SWIG_RuntimeError, e.what());
1690	>	PyErr_SetString ( BossError, e.what() );
1691	>	return NULL;
1692		}
1693		}
1694		resultobj = PyInt_FromLong((long)result);
#	Line 1607 | Line 1734 | static PyObject *_wrap_delete_objectMap(
1734		delete arg1;
1735
1736		}catch (const BossSchedFailure & e) {
1737	<	SWIG_exception(SWIG_ValueError, e.what());
1737	>	PyErr_SetString ( SchedulerError, e.what() );
1738	>	return NULL;
1739		}catch (const std::exception& e) {
1740	<	SWIG_exception(SWIG_RuntimeError, e.what());
1740	>	PyErr_SetString ( BossError, e.what() );
1741	>	return NULL;
1742		}
1743		}
1744		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1642 | Line 1771 | static PyObject *_wrap_new_vector_string
1771		result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1772
1773		}catch (const BossSchedFailure & e) {
1774	<	SWIG_exception(SWIG_ValueError, e.what());
1774	>	PyErr_SetString ( SchedulerError, e.what() );
1775	>	return NULL;
1776		}catch (const std::exception& e) {
1777	<	SWIG_exception(SWIG_RuntimeError, e.what());
1777	>	PyErr_SetString ( BossError, e.what() );
1778	>	return NULL;
1779		}
1780		}
1781		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1679 | Line 1810 | static PyObject *_wrap_new_vector_string
1810		result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1811
1812		}catch (const BossSchedFailure & e) {
1813	<	SWIG_exception(SWIG_ValueError, e.what());
1813	>	PyErr_SetString ( SchedulerError, e.what() );
1814	>	return NULL;
1815		}catch (const std::exception& e) {
1816	<	SWIG_exception(SWIG_RuntimeError, e.what());
1816	>	PyErr_SetString ( BossError, e.what() );
1817	>	return NULL;
1818		}
1819		}
1820		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1733 | Line 1866 | static PyObject *_wrap_new_vector_string
1866		result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1867
1868		}catch (const BossSchedFailure & e) {
1869	<	SWIG_exception(SWIG_ValueError, e.what());
1869	>	PyErr_SetString ( SchedulerError, e.what() );
1870	>	return NULL;
1871		}catch (const std::exception& e) {
1872	<	SWIG_exception(SWIG_RuntimeError, e.what());
1872	>	PyErr_SetString ( BossError, e.what() );
1873	>	return NULL;
1874		}
1875		}
1876		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1862 | Line 1997 | static PyObject *_wrap_vector_string___l
1997		result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1998
1999		}catch (const BossSchedFailure & e) {
2000	<	SWIG_exception(SWIG_ValueError, e.what());
2000	>	PyErr_SetString ( SchedulerError, e.what() );
2001	>	return NULL;
2002		}catch (const std::exception& e) {
2003	<	SWIG_exception(SWIG_RuntimeError, e.what());
2003	>	PyErr_SetString ( BossError, e.what() );
2004	>	return NULL;
2005		}
2006		}
2007		resultobj = PyInt_FromLong((long)result);
#	Line 1916 | Line 2053 | static PyObject *_wrap_vector_string___n
2053		result = (bool)((std::vector<std::string > const *)arg1)->empty();
2054
2055		}catch (const BossSchedFailure & e) {
2056	<	SWIG_exception(SWIG_ValueError, e.what());
2056	>	PyErr_SetString ( SchedulerError, e.what() );
2057	>	return NULL;
2058		}catch (const std::exception& e) {
2059	<	SWIG_exception(SWIG_RuntimeError, e.what());
2059	>	PyErr_SetString ( BossError, e.what() );
2060	>	return NULL;
2061		}
2062		}
2063		resultobj = PyInt_FromLong((long)result);
#	Line 1940 | Line 2079 | static PyObject *_wrap_vector_string_cle
2079		(arg1)->clear();
2080
2081		}catch (const BossSchedFailure & e) {
2082	<	SWIG_exception(SWIG_ValueError, e.what());
2082	>	PyErr_SetString ( SchedulerError, e.what() );
2083	>	return NULL;
2084		}catch (const std::exception& e) {
2085	<	SWIG_exception(SWIG_RuntimeError, e.what());
2085	>	PyErr_SetString ( BossError, e.what() );
2086	>	return NULL;
2087		}
2088		}
2089		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1972 | Line 2113 | static PyObject *_wrap_vector_string_app
2113		(arg1)->push_back(arg2);
2114
2115		}catch (const BossSchedFailure & e) {
2116	<	SWIG_exception(SWIG_ValueError, e.what());
2116	>	PyErr_SetString ( SchedulerError, e.what() );
2117	>	return NULL;
2118		}catch (const std::exception& e) {
2119	<	SWIG_exception(SWIG_RuntimeError, e.what());
2119	>	PyErr_SetString ( BossError, e.what() );
2120	>	return NULL;
2121		}
2122		}
2123		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2050 | Line 2193 | static PyObject *_wrap_vector_string___g
2193		result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2194
2195		}catch (const BossSchedFailure & e) {
2196	<	SWIG_exception(SWIG_ValueError, e.what());
2196	>	PyErr_SetString ( SchedulerError, e.what() );
2197	>	return NULL;
2198		}catch (const std::exception& e) {
2199	<	SWIG_exception(SWIG_RuntimeError, e.what());
2199	>	PyErr_SetString ( BossError, e.what() );
2200	>	return NULL;
2201		}
2202		}
2203		{
#	Line 2144 | Line 2289 | static PyObject *_wrap_vector_string___s
2289		std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2290
2291		}catch (const BossSchedFailure & e) {
2292	<	SWIG_exception(SWIG_ValueError, e.what());
2292	>	PyErr_SetString ( SchedulerError, e.what() );
2293	>	return NULL;
2294		}catch (const std::exception& e) {
2295	<	SWIG_exception(SWIG_RuntimeError, e.what());
2295	>	PyErr_SetString ( BossError, e.what() );
2296	>	return NULL;
2297		}
2298		}
2299		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2193 | Line 2340 | static PyObject *_wrap_vector_string___d
2340		std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2341
2342		}catch (const BossSchedFailure & e) {
2343	<	SWIG_exception(SWIG_ValueError, e.what());
2343	>	PyErr_SetString ( SchedulerError, e.what() );
2344	>	return NULL;
2345		}catch (const std::exception& e) {
2346	<	SWIG_exception(SWIG_RuntimeError, e.what());
2346	>	PyErr_SetString ( BossError, e.what() );
2347	>	return NULL;
2348		}
2349		}
2350		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2217 | Line 2366 | static PyObject *_wrap_delete_vector_str
2366		delete arg1;
2367
2368		}catch (const BossSchedFailure & e) {
2369	<	SWIG_exception(SWIG_ValueError, e.what());
2369	>	PyErr_SetString ( SchedulerError, e.what() );
2370	>	return NULL;
2371		}catch (const std::exception& e) {
2372	<	SWIG_exception(SWIG_RuntimeError, e.what());
2372	>	PyErr_SetString ( BossError, e.what() );
2373	>	return NULL;
2374		}
2375		}
2376		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2236 | Line 2387 | static PyObject * vector_string_swigregi
2387		Py_INCREF(obj);
2388		return Py_BuildValue((char *)"");
2389		}
2390	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
2390	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2391		PyObject *resultobj;
2392	<	BossSession *arg1 = (BossSession *) 0 ;
2393	<	std::vector<std::string > *arg2 = 0 ;
2394	<	PyObject *result;
2392	>	std::string arg1 = (std::string) "" ;
2393	>	std::string arg2 = (std::string) "2" ;
2394	>	std::string arg3 = (std::string) "" ;
2395	>	std::string arg4 = (std::string) "" ;
2396	>	BossSession *result;
2397		PyObject * obj0 = 0 ;
2398		PyObject * obj1 = 0 ;
2399	+	PyObject * obj2 = 0 ;
2400	+	PyObject * obj3 = 0 ;
2401
2402	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2403	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2404	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2405	<	if (arg2 == NULL) {
2406	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2402	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2403	>	if (obj0) {
2404	>	{
2405	>	if (PyString_Check(obj0))
2406	>	arg1 = std::string(PyString_AsString(obj0));
2407	>	else
2408	>	SWIG_exception(SWIG_TypeError, "string expected");
2409	>	}
2410		}
2411	<	{
2412	<	try {
2413	<	result = (PyObject *)BossSession_show(arg1,*arg2);
2414	<
2415	<	}catch (const BossSchedFailure & e) {
2416	<	SWIG_exception(SWIG_ValueError, e.what());
2417	<	}catch (const std::exception& e) {
2418	<	SWIG_exception(SWIG_RuntimeError, e.what());
2411	>	if (obj1) {
2412	>	{
2413	>	if (PyString_Check(obj1))
2414	>	arg2 = std::string(PyString_AsString(obj1));
2415	>	else
2416	>	SWIG_exception(SWIG_TypeError, "string expected");
2417	>	}
2418	>	}
2419	>	if (obj2) {
2420	>	{
2421	>	if (PyString_Check(obj2))
2422	>	arg3 = std::string(PyString_AsString(obj2));
2423	>	else
2424	>	SWIG_exception(SWIG_TypeError, "string expected");
2425	>	}
2426	>	}
2427	>	if (obj3) {
2428	>	{
2429	>	if (PyString_Check(obj3))
2430	>	arg4 = std::string(PyString_AsString(obj3));
2431	>	else
2432	>	SWIG_exception(SWIG_TypeError, "string expected");
2433		}
2434		}
2263	–	resultobj = result;
2264	–	return resultobj;
2265	–	fail:
2266	–	return NULL;
2267	–	}
2268	–
2269	–
2270	–	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
2271	–	PyObject *resultobj;
2272	–	BossSession *arg1 = (BossSession *) 0 ;
2273	–	PyObject *result;
2274	–	PyObject * obj0 = 0 ;
2275	–
2276	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2277	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2435		{
2436		try {
2437	<	result = (PyObject *)BossSession_CHTools(arg1);
2437	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2438
2439		}catch (const BossSchedFailure & e) {
2440	<	SWIG_exception(SWIG_ValueError, e.what());
2440	>	PyErr_SetString ( SchedulerError, e.what() );
2441	>	return NULL;
2442		}catch (const std::exception& e) {
2443	<	SWIG_exception(SWIG_RuntimeError, e.what());
2443	>	PyErr_SetString ( BossError, e.what() );
2444	>	return NULL;
2445		}
2446		}
2447	<	resultobj = result;
2447	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2448		return resultobj;
2449		fail:
2450		return NULL;
2451		}
2452
2453
2454	<	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
2454	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2455		PyObject *resultobj;
2456		BossSession *arg1 = (BossSession *) 0 ;
2298	–	PyObject *result;
2457		PyObject * obj0 = 0 ;
2458
2459	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2459	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2460		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2461		{
2462		try {
2463	<	result = (PyObject *)BossSession_ProgramTypes(arg1);
2463	>	delete arg1;
2464
2465		}catch (const BossSchedFailure & e) {
2466	<	SWIG_exception(SWIG_ValueError, e.what());
2466	>	PyErr_SetString ( SchedulerError, e.what() );
2467	>	return NULL;
2468		}catch (const std::exception& e) {
2469	<	SWIG_exception(SWIG_RuntimeError, e.what());
2469	>	PyErr_SetString ( BossError, e.what() );
2470	>	return NULL;
2471		}
2472		}
2473	<	resultobj = result;
2473	>	Py_INCREF(Py_None); resultobj = Py_None;
2474		return resultobj;
2475		fail:
2476		return NULL;
2477		}
2478
2479
2480	<	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
2480	>	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2481		PyObject *resultobj;
2482		BossSession *arg1 = (BossSession *) 0 ;
2323	–	PyObject *result;
2483		PyObject * obj0 = 0 ;
2484
2485	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2485	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2486		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2487		{
2488		try {
2489	<	result = (PyObject *)BossSession_RTMons(arg1);
2489	>	(arg1)->resetDB();
2490
2491		}catch (const BossSchedFailure & e) {
2492	<	SWIG_exception(SWIG_ValueError, e.what());
2492	>	PyErr_SetString ( SchedulerError, e.what() );
2493	>	return NULL;
2494		}catch (const std::exception& e) {
2495	<	SWIG_exception(SWIG_RuntimeError, e.what());
2495	>	PyErr_SetString ( BossError, e.what() );
2496	>	return NULL;
2497		}
2498		}
2499	<	resultobj = result;
2499	>	Py_INCREF(Py_None); resultobj = Py_None;
2500		return resultobj;
2501		fail:
2502		return NULL;
2503		}
2504
2505
2506	<	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
2506	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2507		PyObject *resultobj;
2508		BossSession *arg1 = (BossSession *) 0 ;
2348	–	PyObject *result;
2509		PyObject * obj0 = 0 ;
2510
2511	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2511	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2512		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2513		{
2514		try {
2515	<	result = (PyObject *)BossSession_schedulers(arg1);
2515	>	(arg1)->clear();
2516
2517		}catch (const BossSchedFailure & e) {
2518	<	SWIG_exception(SWIG_ValueError, e.what());
2518	>	PyErr_SetString ( SchedulerError, e.what() );
2519	>	return NULL;
2520		}catch (const std::exception& e) {
2521	<	SWIG_exception(SWIG_RuntimeError, e.what());
2521	>	PyErr_SetString ( BossError, e.what() );
2522	>	return NULL;
2523		}
2524		}
2525	<	resultobj = result;
2525	>	Py_INCREF(Py_None); resultobj = Py_None;
2526		return resultobj;
2527		fail:
2528		return NULL;
2529		}
2530
2531
2532	<	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
2532	>	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2533		PyObject *resultobj;
2534		BossSession *arg1 = (BossSession *) 0 ;
2535	<	std::string *arg2 = 0 ;
2536	<	std::string *arg3 = 0 ;
2537	<	std::string const &arg4_defvalue = "" ;
2376	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
2377	<	std::string const &arg5_defvalue = "" ;
2378	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2379	<	bool arg6 = (bool) false ;
2380	<	PyObject *result;
2535	>	std::string const &arg2_defvalue = "" ;
2536	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
2537	>	BossTask *result;
2538		std::string temp2 ;
2382	–	std::string temp3 ;
2383	–	std::string temp4 ;
2384	–	std::string temp5 ;
2539		PyObject * obj0 = 0 ;
2540		PyObject * obj1 = 0 ;
2387	–	PyObject * obj2 = 0 ;
2388	–	PyObject * obj3 = 0 ;
2389	–	PyObject * obj4 = 0 ;
2390	–	PyObject * obj5 = 0 ;
2541
2542	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2542	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2543		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2544	<	{
2395	<	if (PyString_Check(obj1)) {
2396	<	temp2 = std::string(PyString_AsString(obj1));
2397	<	arg2 = &temp2;
2398	<	}else {
2399	<	SWIG_exception(SWIG_TypeError, "string expected");
2400	<	}
2401	<	}
2402	<	{
2403	<	if (PyString_Check(obj2)) {
2404	<	temp3 = std::string(PyString_AsString(obj2));
2405	<	arg3 = &temp3;
2406	<	}else {
2407	<	SWIG_exception(SWIG_TypeError, "string expected");
2408	<	}
2409	<	}
2410	<	if (obj3) {
2411	<	{
2412	<	if (PyString_Check(obj3)) {
2413	<	temp4 = std::string(PyString_AsString(obj3));
2414	<	arg4 = &temp4;
2415	<	}else {
2416	<	SWIG_exception(SWIG_TypeError, "string expected");
2417	<	}
2418	<	}
2419	<	}
2420	<	if (obj4) {
2544	>	if (obj1) {
2545		{
2546	<	if (PyString_Check(obj4)) {
2547	<	temp5 = std::string(PyString_AsString(obj4));
2548	<	arg5 = &temp5;
2546	>	if (PyString_Check(obj1)) {
2547	>	temp2 = std::string(PyString_AsString(obj1));
2548	>	arg2 = &temp2;
2549		}else {
2550		SWIG_exception(SWIG_TypeError, "string expected");
2551		}
2552		}
2553		}
2430	–	if (obj5) {
2431	–	arg6 = PyInt_AsLong(obj5) ? true : false;
2432	–	if (PyErr_Occurred()) SWIG_fail;
2433	–	}
2554		{
2555		try {
2556	<	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
2556	>	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2557
2558		}catch (const BossSchedFailure & e) {
2559	<	SWIG_exception(SWIG_ValueError, e.what());
2559	>	PyErr_SetString ( SchedulerError, e.what() );
2560	>	return NULL;
2561		}catch (const std::exception& e) {
2562	<	SWIG_exception(SWIG_RuntimeError, e.what());
2562	>	PyErr_SetString ( BossError, e.what() );
2563	>	return NULL;
2564		}
2565		}
2566	<	resultobj = result;
2566	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2567		return resultobj;
2568		fail:
2569		return NULL;
2570		}
2571
2572
2573	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2573	>	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2574		PyObject *resultobj;
2575		BossSession *arg1 = (BossSession *) 0 ;
2576	<	int arg2 = (int) SCHEDULED ;
2455	<	std::string const &arg3_defvalue = "all" ;
2456	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
2457	<	std::string const &arg4_defvalue = "all" ;
2458	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
2459	<	std::string const &arg5_defvalue = "" ;
2460	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2461	<	std::string arg6 = (std::string) "" ;
2462	<	std::string arg7 = (std::string) "" ;
2463	<	std::string arg8 = (std::string) "" ;
2464	<	std::string arg9 = (std::string) "" ;
2465	<	bool arg10 = (bool) false ;
2466	<	PyObject *result;
2467	<	std::string temp3 ;
2468	<	std::string temp4 ;
2469	<	std::string temp5 ;
2470	<	PyObject * obj0 = 0 ;
2471	<	PyObject * obj2 = 0 ;
2472	<	PyObject * obj3 = 0 ;
2473	<	PyObject * obj4 = 0 ;
2474	<	PyObject * obj5 = 0 ;
2475	<	PyObject * obj6 = 0 ;
2476	<	PyObject * obj7 = 0 ;
2477	<	PyObject * obj8 = 0 ;
2478	<	PyObject * obj9 = 0 ;
2479	<
2480	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2481	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2482	<	if (obj2) {
2483	<	{
2484	<	if (PyString_Check(obj2)) {
2485	<	temp3 = std::string(PyString_AsString(obj2));
2486	<	arg3 = &temp3;
2487	<	}else {
2488	<	SWIG_exception(SWIG_TypeError, "string expected");
2489	<	}
2490	<	}
2491	<	}
2492	<	if (obj3) {
2493	<	{
2494	<	if (PyString_Check(obj3)) {
2495	<	temp4 = std::string(PyString_AsString(obj3));
2496	<	arg4 = &temp4;
2497	<	}else {
2498	<	SWIG_exception(SWIG_TypeError, "string expected");
2499	<	}
2500	<	}
2501	<	}
2502	<	if (obj4) {
2503	<	{
2504	<	if (PyString_Check(obj4)) {
2505	<	temp5 = std::string(PyString_AsString(obj4));
2506	<	arg5 = &temp5;
2507	<	}else {
2508	<	SWIG_exception(SWIG_TypeError, "string expected");
2509	<	}
2510	<	}
2511	<	}
2512	<	if (obj5) {
2513	<	{
2514	<	if (PyString_Check(obj5))
2515	<	arg6 = std::string(PyString_AsString(obj5));
2516	<	else
2517	<	SWIG_exception(SWIG_TypeError, "string expected");
2518	<	}
2519	<	}
2520	<	if (obj6) {
2521	<	{
2522	<	if (PyString_Check(obj6))
2523	<	arg7 = std::string(PyString_AsString(obj6));
2524	<	else
2525	<	SWIG_exception(SWIG_TypeError, "string expected");
2526	<	}
2527	<	}
2528	<	if (obj7) {
2529	<	{
2530	<	if (PyString_Check(obj7))
2531	<	arg8 = std::string(PyString_AsString(obj7));
2532	<	else
2533	<	SWIG_exception(SWIG_TypeError, "string expected");
2534	<	}
2535	<	}
2536	<	if (obj8) {
2537	<	{
2538	<	if (PyString_Check(obj8))
2539	<	arg9 = std::string(PyString_AsString(obj8));
2540	<	else
2541	<	SWIG_exception(SWIG_TypeError, "string expected");
2542	<	}
2543	<	}
2544	<	if (obj9) {
2545	<	arg10 = PyInt_AsLong(obj9) ? true : false;
2546	<	if (PyErr_Occurred()) SWIG_fail;
2547	<	}
2548	<	{
2549	<	try {
2550	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2551	<
2552	<	}catch (const BossSchedFailure & e) {
2553	<	SWIG_exception(SWIG_ValueError, e.what());
2554	<	}catch (const std::exception& e) {
2555	<	SWIG_exception(SWIG_RuntimeError, e.what());
2556	<	}
2557	<	}
2558	<	resultobj = result;
2559	<	return resultobj;
2560	<	fail:
2561	<	return NULL;
2562	<	}
2563	<
2564	<
2565	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2566	<	PyObject *resultobj;
2567	<	std::string arg1 = (std::string) "" ;
2568	<	std::string arg2 = (std::string) "2" ;
2569	<	std::string arg3 = (std::string) "" ;
2570	<	std::string arg4 = (std::string) "" ;
2571	<	BossSession *result;
2576	>	BossTask *arg2 = (BossTask *) 0 ;
2577		PyObject * obj0 = 0 ;
2578		PyObject * obj1 = 0 ;
2574	–	PyObject * obj2 = 0 ;
2575	–	PyObject * obj3 = 0 ;
2576	–
2577	–	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2578	–	if (obj0) {
2579	–	{
2580	–	if (PyString_Check(obj0))
2581	–	arg1 = std::string(PyString_AsString(obj0));
2582	–	else
2583	–	SWIG_exception(SWIG_TypeError, "string expected");
2584	–	}
2585	–	}
2586	–	if (obj1) {
2587	–	{
2588	–	if (PyString_Check(obj1))
2589	–	arg2 = std::string(PyString_AsString(obj1));
2590	–	else
2591	–	SWIG_exception(SWIG_TypeError, "string expected");
2592	–	}
2593	–	}
2594	–	if (obj2) {
2595	–	{
2596	–	if (PyString_Check(obj2))
2597	–	arg3 = std::string(PyString_AsString(obj2));
2598	–	else
2599	–	SWIG_exception(SWIG_TypeError, "string expected");
2600	–	}
2601	–	}
2602	–	if (obj3) {
2603	–	{
2604	–	if (PyString_Check(obj3))
2605	–	arg4 = std::string(PyString_AsString(obj3));
2606	–	else
2607	–	SWIG_exception(SWIG_TypeError, "string expected");
2608	–	}
2609	–	}
2610	–	{
2611	–	try {
2612	–	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2613	–
2614	–	}catch (const BossSchedFailure & e) {
2615	–	SWIG_exception(SWIG_ValueError, e.what());
2616	–	}catch (const std::exception& e) {
2617	–	SWIG_exception(SWIG_RuntimeError, e.what());
2618	–	}
2619	–	}
2620	–	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2621	–	return resultobj;
2622	–	fail:
2623	–	return NULL;
2624	–	}
2625	–
2626	–
2627	–	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2628	–	PyObject *resultobj;
2629	–	BossSession *arg1 = (BossSession *) 0 ;
2630	–	PyObject * obj0 = 0 ;
2579
2580	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2580	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2581		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2582	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2583		{
2584		try {
2585	<	delete arg1;
2585	>	(arg1)->destroyBossTask(arg2);
2586
2587		}catch (const BossSchedFailure & e) {
2588	<	SWIG_exception(SWIG_ValueError, e.what());
2588	>	PyErr_SetString ( SchedulerError, e.what() );
2589	>	return NULL;
2590		}catch (const std::exception& e) {
2591	<	SWIG_exception(SWIG_RuntimeError, e.what());
2591	>	PyErr_SetString ( BossError, e.what() );
2592	>	return NULL;
2593		}
2594		}
2595		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2648 | Line 2599 | static PyObject *_wrap_delete_BossSessio
2599		}
2600
2601
2602	<	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2602	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2603		PyObject *resultobj;
2604		BossSession *arg1 = (BossSession *) 0 ;
2605	+	std::vector<std::string > result;
2606		PyObject * obj0 = 0 ;
2607
2608	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2608	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2609		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2610		{
2611		try {
2612	<	(arg1)->resetDB();
2612	>	result = (arg1)->showCHTools();
2613
2614		}catch (const BossSchedFailure & e) {
2615	<	SWIG_exception(SWIG_ValueError, e.what());
2615	>	PyErr_SetString ( SchedulerError, e.what() );
2616	>	return NULL;
2617		}catch (const std::exception& e) {
2618	<	SWIG_exception(SWIG_RuntimeError, e.what());
2618	>	PyErr_SetString ( BossError, e.what() );
2619	>	return NULL;
2620		}
2621		}
2622	<	Py_INCREF(Py_None); resultobj = Py_None;
2622	>	{
2623	>	resultobj = PyTuple_New((&result)->size());
2624	>	for (unsigned int i=0; i<(&result)->size(); i++)
2625	>	PyTuple_SetItem(resultobj,i,
2626	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2627	>	}
2628		return resultobj;
2629		fail:
2630		return NULL;
2631		}
2632
2633
2634	<	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2634	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2635		PyObject *resultobj;
2636		BossSession *arg1 = (BossSession *) 0 ;
2637	+	std::vector<std::string > result;
2638		PyObject * obj0 = 0 ;
2639
2640	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2640	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2641		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2642		{
2643		try {
2644	<	(arg1)->clear();
2644	>	result = (arg1)->showProgramTypes();
2645
2646		}catch (const BossSchedFailure & e) {
2647	<	SWIG_exception(SWIG_ValueError, e.what());
2647	>	PyErr_SetString ( SchedulerError, e.what() );
2648	>	return NULL;
2649		}catch (const std::exception& e) {
2650	<	SWIG_exception(SWIG_RuntimeError, e.what());
2650	>	PyErr_SetString ( BossError, e.what() );
2651	>	return NULL;
2652		}
2653		}
2654	<	Py_INCREF(Py_None); resultobj = Py_None;
2654	>	{
2655	>	resultobj = PyTuple_New((&result)->size());
2656	>	for (unsigned int i=0; i<(&result)->size(); i++)
2657	>	PyTuple_SetItem(resultobj,i,
2658	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2659	>	}
2660		return resultobj;
2661		fail:
2662		return NULL;
2663		}
2664
2665
2666	<	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2666	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2667		PyObject *resultobj;
2668		BossSession *arg1 = (BossSession *) 0 ;
2669	<	std::string const &arg2_defvalue = "" ;
2703	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2704	<	BossTask *result;
2705	<	std::string temp2 ;
2669	>	std::vector<std::string > result;
2670		PyObject * obj0 = 0 ;
2707	–	PyObject * obj1 = 0 ;
2671
2672	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2672	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2673		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2711	–	if (obj1) {
2712	–	{
2713	–	if (PyString_Check(obj1)) {
2714	–	temp2 = std::string(PyString_AsString(obj1));
2715	–	arg2 = &temp2;
2716	–	}else {
2717	–	SWIG_exception(SWIG_TypeError, "string expected");
2718	–	}
2719	–	}
2720	–	}
2674		{
2675		try {
2676	<	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2676	>	result = (arg1)->showRTMon();
2677
2678		}catch (const BossSchedFailure & e) {
2679	<	SWIG_exception(SWIG_ValueError, e.what());
2679	>	PyErr_SetString ( SchedulerError, e.what() );
2680	>	return NULL;
2681		}catch (const std::exception& e) {
2682	<	SWIG_exception(SWIG_RuntimeError, e.what());
2682	>	PyErr_SetString ( BossError, e.what() );
2683	>	return NULL;
2684		}
2685		}
2686	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2686	>	{
2687	>	resultobj = PyTuple_New((&result)->size());
2688	>	for (unsigned int i=0; i<(&result)->size(); i++)
2689	>	PyTuple_SetItem(resultobj,i,
2690	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2691	>	}
2692		return resultobj;
2693		fail:
2694		return NULL;
2695		}
2696
2697
2698	<	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2698	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2699		PyObject *resultobj;
2700		BossSession *arg1 = (BossSession *) 0 ;
2701	<	BossTask *arg2 = (BossTask *) 0 ;
2701	>	std::vector<std::string > result;
2702		PyObject * obj0 = 0 ;
2743	–	PyObject * obj1 = 0 ;
2703
2704	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2704	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2705		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2747	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2706		{
2707		try {
2708	<	(arg1)->destroyBossTask(arg2);
2708	>	result = (arg1)->showSchedulers();
2709
2710		}catch (const BossSchedFailure & e) {
2711	<	SWIG_exception(SWIG_ValueError, e.what());
2711	>	PyErr_SetString ( SchedulerError, e.what() );
2712	>	return NULL;
2713		}catch (const std::exception& e) {
2714	<	SWIG_exception(SWIG_RuntimeError, e.what());
2714	>	PyErr_SetString ( BossError, e.what() );
2715	>	return NULL;
2716		}
2717		}
2718	<	Py_INCREF(Py_None); resultobj = Py_None;
2718	>	{
2719	>	resultobj = PyTuple_New((&result)->size());
2720	>	for (unsigned int i=0; i<(&result)->size(); i++)
2721	>	PyTuple_SetItem(resultobj,i,
2722	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2723	>	}
2724		return resultobj;
2725		fail:
2726		return NULL;
#	Line 2775 | Line 2740 | static PyObject *_wrap_BossSession_defau
2740		result = (arg1)->defaultCHTool();
2741
2742		}catch (const BossSchedFailure & e) {
2743	<	SWIG_exception(SWIG_ValueError, e.what());
2743	>	PyErr_SetString ( SchedulerError, e.what() );
2744	>	return NULL;
2745		}catch (const std::exception& e) {
2746	<	SWIG_exception(SWIG_RuntimeError, e.what());
2746	>	PyErr_SetString ( BossError, e.what() );
2747	>	return NULL;
2748		}
2749		}
2750		{
#	Line 2802 | Line 2769 | static PyObject *_wrap_BossSession_defau
2769		result = (arg1)->defaultProgramType();
2770
2771		}catch (const BossSchedFailure & e) {
2772	<	SWIG_exception(SWIG_ValueError, e.what());
2772	>	PyErr_SetString ( SchedulerError, e.what() );
2773	>	return NULL;
2774		}catch (const std::exception& e) {
2775	<	SWIG_exception(SWIG_RuntimeError, e.what());
2775	>	PyErr_SetString ( BossError, e.what() );
2776	>	return NULL;
2777		}
2778		}
2779		{
#	Line 2829 | Line 2798 | static PyObject *_wrap_BossSession_defau
2798		result = (arg1)->defaultRTMon();
2799
2800		}catch (const BossSchedFailure & e) {
2801	<	SWIG_exception(SWIG_ValueError, e.what());
2801	>	PyErr_SetString ( SchedulerError, e.what() );
2802	>	return NULL;
2803		}catch (const std::exception& e) {
2804	<	SWIG_exception(SWIG_RuntimeError, e.what());
2804	>	PyErr_SetString ( BossError, e.what() );
2805	>	return NULL;
2806		}
2807		}
2808		{
#	Line 2856 | Line 2827 | static PyObject *_wrap_BossSession_defau
2827		result = (arg1)->defaultScheduler();
2828
2829		}catch (const BossSchedFailure & e) {
2830	<	SWIG_exception(SWIG_ValueError, e.what());
2830	>	PyErr_SetString ( SchedulerError, e.what() );
2831	>	return NULL;
2832		}catch (const std::exception& e) {
2833	<	SWIG_exception(SWIG_RuntimeError, e.what());
2833	>	PyErr_SetString ( BossError, e.what() );
2834	>	return NULL;
2835		}
2836		}
2837		{
#	Line 2883 | Line 2856 | static PyObject *_wrap_BossSession_versi
2856		result = (arg1)->version();
2857
2858		}catch (const BossSchedFailure & e) {
2859	<	SWIG_exception(SWIG_ValueError, e.what());
2859	>	PyErr_SetString ( SchedulerError, e.what() );
2860	>	return NULL;
2861		}catch (const std::exception& e) {
2862	<	SWIG_exception(SWIG_RuntimeError, e.what());
2862	>	PyErr_SetString ( BossError, e.what() );
2863	>	return NULL;
2864		}
2865		}
2866		{
#	Line 2910 | Line 2885 | static PyObject *_wrap_BossSession_clien
2885		result = (arg1)->clientID();
2886
2887		}catch (const BossSchedFailure & e) {
2888	<	SWIG_exception(SWIG_ValueError, e.what());
2888	>	PyErr_SetString ( SchedulerError, e.what() );
2889	>	return NULL;
2890		}catch (const std::exception& e) {
2891	<	SWIG_exception(SWIG_RuntimeError, e.what());
2891	>	PyErr_SetString ( BossError, e.what() );
2892	>	return NULL;
2893		}
2894		}
2895		{
#	Line 2943 | Line 2920 | static PyObject *_wrap_BossSession_showC
2920		result = (int)(arg1)->showConfigs(arg2);
2921
2922		}catch (const BossSchedFailure & e) {
2923	<	SWIG_exception(SWIG_ValueError, e.what());
2923	>	PyErr_SetString ( SchedulerError, e.what() );
2924	>	return NULL;
2925		}catch (const std::exception& e) {
2926	<	SWIG_exception(SWIG_RuntimeError, e.what());
2926	>	PyErr_SetString ( BossError, e.what() );
2927	>	return NULL;
2928		}
2929		}
2930		resultobj = PyInt_FromLong((long)result);
#	Line 2998 | Line 2977 | static PyObject *_wrap_BossSession_RTupd
2977		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2978
2979		}catch (const BossSchedFailure & e) {
2980	<	SWIG_exception(SWIG_ValueError, e.what());
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		resultobj = PyInt_FromLong((long)result);
#	Line 3015 | Line 2996 | static PyObject *_wrap_BossSession_listM
2996		BossSession *arg1 = (BossSession *) 0 ;
2997		std::string *arg2 = 0 ;
2998		std::string *arg3 = 0 ;
2999	<	bool arg4 = (bool) false ;
2999	>	std::string const &arg4_defvalue = "" ;
3000	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3001		std::string const &arg5_defvalue = "" ;
3002		std::string *arg5 = (std::string *) &arg5_defvalue ;
3003	<	std::string const &arg6_defvalue = "" ;
3022	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
3003	>	unsigned int arg6 = (unsigned int) 0 ;
3004		std::vector<std::string > result;
3005		std::string temp2 ;
3006		std::string temp3 ;
3007	+	std::string temp4 ;
3008		std::string temp5 ;
3027	–	std::string temp6 ;
3009		PyObject * obj0 = 0 ;
3010		PyObject * obj1 = 0 ;
3011		PyObject * obj2 = 0 ;
#	Line 3051 | Line 3032 | static PyObject *_wrap_BossSession_listM
3032		}
3033		}
3034		if (obj3) {
3035	<	arg4 = PyInt_AsLong(obj3) ? true : false;
3036	<	if (PyErr_Occurred()) SWIG_fail;
3035	>	{
3036	>	if (PyString_Check(obj3)) {
3037	>	temp4 = std::string(PyString_AsString(obj3));
3038	>	arg4 = &temp4;
3039	>	}else {
3040	>	SWIG_exception(SWIG_TypeError, "string expected");
3041	>	}
3042	>	}
3043		}
3044		if (obj4) {
3045		{
#	Line 3065 | Line 3052 | static PyObject *_wrap_BossSession_listM
3052		}
3053		}
3054		if (obj5) {
3055	<	{
3056	<	if (PyString_Check(obj5)) {
3070	<	temp6 = std::string(PyString_AsString(obj5));
3071	<	arg6 = &temp6;
3072	<	}else {
3073	<	SWIG_exception(SWIG_TypeError, "string expected");
3074	<	}
3075	<	}
3055	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3056	>	if (PyErr_Occurred()) SWIG_fail;
3057		}
3058		{
3059		try {
3060	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
3060	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3061
3062		}catch (const BossSchedFailure & e) {
3063	<	SWIG_exception(SWIG_ValueError, e.what());
3063	>	PyErr_SetString ( SchedulerError, e.what() );
3064	>	return NULL;
3065		}catch (const std::exception& e) {
3066	<	SWIG_exception(SWIG_RuntimeError, e.what());
3066	>	PyErr_SetString ( BossError, e.what() );
3067	>	return NULL;
3068		}
3069		}
3070		{
#	Line 3110 | Line 3093 | static PyObject *_wrap_BossSession_sched
3093		std::string arg7 = (std::string) "" ;
3094		std::string arg8 = (std::string) "" ;
3095		std::string arg9 = (std::string) "" ;
3096	+	unsigned int arg10 = (unsigned int) 0 ;
3097		std::string temp3 ;
3098		std::string temp4 ;
3099		std::string temp5 ;
#	Line 3121 | Line 3105 | static PyObject *_wrap_BossSession_sched
3105		PyObject * obj6 = 0 ;
3106		PyObject * obj7 = 0 ;
3107		PyObject * obj8 = 0 ;
3108	+	PyObject * obj9 = 0 ;
3109
3110	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3110	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3111		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3112		if (obj2) {
3113		{
#	Line 3186 | Line 3171 | static PyObject *_wrap_BossSession_sched
3171		SWIG_exception(SWIG_TypeError, "string expected");
3172		}
3173		}
3174	+	if (obj9) {
3175	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3176	+	if (PyErr_Occurred()) SWIG_fail;
3177	+	}
3178		{
3179		try {
3180	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3180	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3181
3182		}catch (const BossSchedFailure & e) {
3183	<	SWIG_exception(SWIG_ValueError, e.what());
3183	>	PyErr_SetString ( SchedulerError, e.what() );
3184	>	return NULL;
3185		}catch (const std::exception& e) {
3186	<	SWIG_exception(SWIG_RuntimeError, e.what());
3186	>	PyErr_SetString ( BossError, e.what() );
3187	>	return NULL;
3188		}
3189		}
3190		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3272 | Line 3263 | static PyObject *_wrap_BossSession_selec
3263		result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3264
3265		}catch (const BossSchedFailure & e) {
3266	<	SWIG_exception(SWIG_ValueError, e.what());
3266	>	PyErr_SetString ( SchedulerError, e.what() );
3267	>	return NULL;
3268		}catch (const std::exception& e) {
3269	<	SWIG_exception(SWIG_RuntimeError, e.what());
3269	>	PyErr_SetString ( BossError, e.what() );
3270	>	return NULL;
3271	>	}
3272	>	}
3273	>	{
3274	>	resultobj = PyTuple_New((&result)->size());
3275	>	for (unsigned int i=0; i<(&result)->size(); i++)
3276	>	PyTuple_SetItem(resultobj,i,
3277	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3278	>	}
3279	>	return resultobj;
3280	>	fail:
3281	>	return NULL;
3282	>	}
3283	>
3284	>
3285	>	static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
3286	>	PyObject *resultobj;
3287	>	BossSession *arg1 = (BossSession *) 0 ;
3288	>	std::string *arg2 = 0 ;
3289	>	std::vector<std::string > result;
3290	>	std::string temp2 ;
3291	>	PyObject * obj0 = 0 ;
3292	>	PyObject * obj1 = 0 ;
3293	>
3294	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3295	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3296	>	{
3297	>	if (PyString_Check(obj1)) {
3298	>	temp2 = std::string(PyString_AsString(obj1));
3299	>	arg2 = &temp2;
3300	>	}else {
3301	>	SWIG_exception(SWIG_TypeError, "string expected");
3302	>	}
3303	>	}
3304	>	{
3305	>	try {
3306	>	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3307	>
3308	>	}catch (const BossSchedFailure & e) {
3309	>	PyErr_SetString ( SchedulerError, e.what() );
3310	>	return NULL;
3311	>	}catch (const std::exception& e) {
3312	>	PyErr_SetString ( BossError, e.what() );
3313	>	return NULL;
3314		}
3315		}
3316		{
#	Line 3303 | Line 3339 | static PyObject *_wrap_BossSession_query
3339		std::string arg7 = (std::string) "" ;
3340		std::string arg8 = (std::string) "" ;
3341		std::string arg9 = (std::string) "" ;
3342	<	bool arg10 = (bool) false ;
3342	>	unsigned int arg10 = (unsigned int) 0 ;
3343	>	bool arg11 = (bool) false ;
3344		SwigValueWrapper< std::vector<BossTask * > > result;
3345		std::string temp3 ;
3346		std::string temp4 ;
#	Line 3317 | Line 3354 | static PyObject *_wrap_BossSession_query
3354		PyObject * obj7 = 0 ;
3355		PyObject * obj8 = 0 ;
3356		PyObject * obj9 = 0 ;
3357	+	PyObject * obj10 = 0 ;
3358
3359	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3359	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3360		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3361		if (obj2) {
3362		{
#	Line 3383 | Line 3421 | static PyObject *_wrap_BossSession_query
3421		}
3422		}
3423		if (obj9) {
3424	<	arg10 = PyInt_AsLong(obj9) ? true : false;
3424	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3425	>	if (PyErr_Occurred()) SWIG_fail;
3426	>	}
3427	>	if (obj10) {
3428	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3429		if (PyErr_Occurred()) SWIG_fail;
3430		}
3431		{
3432		try {
3433	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3433	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3434
3435		}catch (const BossSchedFailure & e) {
3436	<	SWIG_exception(SWIG_ValueError, e.what());
3436	>	PyErr_SetString ( SchedulerError, e.what() );
3437	>	return NULL;
3438		}catch (const std::exception& e) {
3439	<	SWIG_exception(SWIG_RuntimeError, e.what());
3439	>	PyErr_SetString ( BossError, e.what() );
3440	>	return NULL;
3441		}
3442		}
3443		{
#	Line 3407 | Line 3451 | static PyObject *_wrap_BossSession_query
3451		}
3452
3453
3454	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3455	<	PyObject *obj;
3456	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3457	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3458	<	Py_INCREF(obj);
3459	<	return Py_BuildValue((char *)"");
3454	>	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3455	>	PyObject *resultobj;
3456	>	BossSession *arg1 = (BossSession *) 0 ;
3457	>	std::string *arg2 = 0 ;
3458	>	SwigValueWrapper< std::vector<BossTask * > > result;
3459	>	std::string temp2 ;
3460	>	PyObject * obj0 = 0 ;
3461	>	PyObject * obj1 = 0 ;
3462	>
3463	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3464	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3465	>	{
3466	>	if (PyString_Check(obj1)) {
3467	>	temp2 = std::string(PyString_AsString(obj1));
3468	>	arg2 = &temp2;
3469	>	}else {
3470	>	SWIG_exception(SWIG_TypeError, "string expected");
3471	>	}
3472	>	}
3473	>	{
3474	>	try {
3475	>	result = (arg1)->getTasksByName((std::string const &)*arg2);
3476	>
3477	>	}catch (const BossSchedFailure & e) {
3478	>	PyErr_SetString ( SchedulerError, e.what() );
3479	>	return NULL;
3480	>	}catch (const std::exception& e) {
3481	>	PyErr_SetString ( BossError, e.what() );
3482	>	return NULL;
3483	>	}
3484	>	}
3485	>	{
3486	>	std::vector<BossTask * > * resultptr;
3487	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3488	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3489	>	}
3490	>	return resultobj;
3491	>	fail:
3492	>	return NULL;
3493		}
3494	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3494	>
3495	>
3496	>	static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3497		PyObject *resultobj;
3498	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3499	<	char *arg2 ;
3498	>	BossSession *arg1 = (BossSession *) 0 ;
3499	>	std::string *arg2 = 0 ;
3500	>	SwigValueWrapper< std::vector<BossTask * > > result;
3501	>	std::string temp2 ;
3502		PyObject * obj0 = 0 ;
3503	+	PyObject * obj1 = 0 ;
3504
3505	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3506	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3505	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3506	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3507		{
3508	<	if (arg2) {
3509	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3510	<	strcpy((char *) arg1->key,arg2);
3508	>	if (PyString_Check(obj1)) {
3509	>	temp2 = std::string(PyString_AsString(obj1));
3510	>	arg2 = &temp2;
3511		}else {
3512	<	arg1->key = 0;
3512	>	SWIG_exception(SWIG_TypeError, "string expected");
3513		}
3514		}
3515	<	Py_INCREF(Py_None); resultobj = Py_None;
3515	>	{
3516	>	try {
3517	>	result = (arg1)->getTasksByJobName((std::string const &)*arg2);
3518	>
3519	>	}catch (const BossSchedFailure & e) {
3520	>	PyErr_SetString ( SchedulerError, e.what() );
3521	>	return NULL;
3522	>	}catch (const std::exception& e) {
3523	>	PyErr_SetString ( BossError, e.what() );
3524	>	return NULL;
3525	>	}
3526	>	}
3527	>	{
3528	>	std::vector<BossTask * > * resultptr;
3529	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3530	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3531	>	}
3532		return resultobj;
3533		fail:
3534		return NULL;
3535		}
3536
3537
3538	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3538	>	static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
3539		PyObject *resultobj;
3540	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3541	<	char *result;
3540	>	BossSession *arg1 = (BossSession *) 0 ;
3541	>	unsigned int result;
3542		PyObject * obj0 = 0 ;
3543
3544	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3545	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3546	<	result = (char *) ((arg1)->key);
3544	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
3545	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3546	>	{
3547	>	try {
3548	>	result = (unsigned int)(arg1)->tasksInMemory();
3549	>
3550	>	}catch (const BossSchedFailure & e) {
3551	>	PyErr_SetString ( SchedulerError, e.what() );
3552	>	return NULL;
3553	>	}catch (const std::exception& e) {
3554	>	PyErr_SetString ( BossError, e.what() );
3555	>	return NULL;
3556	>	}
3557	>	}
3558	>	resultobj = PyInt_FromLong((long)result);
3559	>	return resultobj;
3560	>	fail:
3561	>	return NULL;
3562	>	}
3563	>
3564	>
3565	>	static PyObject *_wrap_BossSession_locate(PyObject *self, PyObject *args) {
3566	>	PyObject *resultobj;
3567	>	BossSession *arg1 = (BossSession *) 0 ;
3568	>	unsigned int arg2 ;
3569	>	BossTask *result;
3570	>	PyObject * obj0 = 0 ;
3571	>	PyObject * obj1 = 0 ;
3572
3573	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3573	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
3574	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3575	>	arg2 = (unsigned int) PyInt_AsLong(obj1);
3576	>	if (PyErr_Occurred()) SWIG_fail;
3577	>	{
3578	>	try {
3579	>	result = (BossTask *)(arg1)->locate(arg2);
3580	>
3581	>	}catch (const BossSchedFailure & e) {
3582	>	PyErr_SetString ( SchedulerError, e.what() );
3583	>	return NULL;
3584	>	}catch (const std::exception& e) {
3585	>	PyErr_SetString ( BossError, e.what() );
3586	>	return NULL;
3587	>	}
3588	>	}
3589	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
3590		return resultobj;
3591		fail:
3592		return NULL;
3593		}
3594
3595
3596	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3596	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3597		PyObject *resultobj;
3598	<	char *arg1 ;
3599	<	BossTaskException *result;
3598	>	BossSession *arg1 = (BossSession *) 0 ;
3599	>	std::vector<std::string > *arg2 = 0 ;
3600	>	PyObject *result;
3601	>	PyObject * obj0 = 0 ;
3602	>	PyObject * obj1 = 0 ;
3603
3604	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3604	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3605	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3606	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3607	>	if (arg2 == NULL) {
3608	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3609	>	}
3610		{
3611		try {
3612	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3612	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3613
3614		}catch (const BossSchedFailure & e) {
3615	<	SWIG_exception(SWIG_ValueError, e.what());
3615	>	PyErr_SetString ( SchedulerError, e.what() );
3616	>	return NULL;
3617		}catch (const std::exception& e) {
3618	<	SWIG_exception(SWIG_RuntimeError, e.what());
3618	>	PyErr_SetString ( BossError, e.what() );
3619	>	return NULL;
3620		}
3621		}
3622	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3622	>	resultobj = result;
3623		return resultobj;
3624		fail:
3625		return NULL;
3626		}
3627
3628
3629	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3629	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3630		PyObject *resultobj;
3631	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3632	<	char *result;
3631	>	BossSession *arg1 = (BossSession *) 0 ;
3632	>	PyObject *result;
3633		PyObject * obj0 = 0 ;
3634
3635	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3636	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3635	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3636	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3637	>	{
3638	>	try {
3639	>	result = (PyObject *)BossSession_CHTools(arg1);
3640	>
3641	>	}catch (const BossSchedFailure & e) {
3642	>	PyErr_SetString ( SchedulerError, e.what() );
3643	>	return NULL;
3644	>	}catch (const std::exception& e) {
3645	>	PyErr_SetString ( BossError, e.what() );
3646	>	return NULL;
3647	>	}
3648	>	}
3649	>	resultobj = result;
3650	>	return resultobj;
3651	>	fail:
3652	>	return NULL;
3653	>	}
3654	>
3655	>
3656	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3657	>	PyObject *resultobj;
3658	>	BossSession *arg1 = (BossSession *) 0 ;
3659	>	PyObject *result;
3660	>	PyObject * obj0 = 0 ;
3661	>
3662	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3663	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3664	>	{
3665	>	try {
3666	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3667	>
3668	>	}catch (const BossSchedFailure & e) {
3669	>	PyErr_SetString ( SchedulerError, e.what() );
3670	>	return NULL;
3671	>	}catch (const std::exception& e) {
3672	>	PyErr_SetString ( BossError, e.what() );
3673	>	return NULL;
3674	>	}
3675	>	}
3676	>	resultobj = result;
3677	>	return resultobj;
3678	>	fail:
3679	>	return NULL;
3680	>	}
3681	>
3682	>
3683	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3684	>	PyObject *resultobj;
3685	>	BossSession *arg1 = (BossSession *) 0 ;
3686	>	PyObject *result;
3687	>	PyObject * obj0 = 0 ;
3688	>
3689	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3690	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3691	>	{
3692	>	try {
3693	>	result = (PyObject *)BossSession_RTMons(arg1);
3694	>
3695	>	}catch (const BossSchedFailure & e) {
3696	>	PyErr_SetString ( SchedulerError, e.what() );
3697	>	return NULL;
3698	>	}catch (const std::exception& e) {
3699	>	PyErr_SetString ( BossError, e.what() );
3700	>	return NULL;
3701	>	}
3702	>	}
3703	>	resultobj = result;
3704	>	return resultobj;
3705	>	fail:
3706	>	return NULL;
3707	>	}
3708	>
3709	>
3710	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3711	>	PyObject *resultobj;
3712	>	BossSession *arg1 = (BossSession *) 0 ;
3713	>	PyObject *result;
3714	>	PyObject * obj0 = 0 ;
3715	>
3716	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3717	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3718	>	{
3719	>	try {
3720	>	result = (PyObject *)BossSession_schedulers(arg1);
3721	>
3722	>	}catch (const BossSchedFailure & e) {
3723	>	PyErr_SetString ( SchedulerError, e.what() );
3724	>	return NULL;
3725	>	}catch (const std::exception& e) {
3726	>	PyErr_SetString ( BossError, e.what() );
3727	>	return NULL;
3728	>	}
3729	>	}
3730	>	resultobj = result;
3731	>	return resultobj;
3732	>	fail:
3733	>	return NULL;
3734	>	}
3735	>
3736	>
3737	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3738	>	PyObject *resultobj;
3739	>	BossSession *arg1 = (BossSession *) 0 ;
3740	>	std::string *arg2 = 0 ;
3741	>	std::string *arg3 = 0 ;
3742	>	std::string const &arg4_defvalue = "" ;
3743	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3744	>	std::string const &arg5_defvalue = "" ;
3745	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3746	>	unsigned int arg6 = (unsigned int) 0 ;
3747	>	PyObject *result;
3748	>	std::string temp2 ;
3749	>	std::string temp3 ;
3750	>	std::string temp4 ;
3751	>	std::string temp5 ;
3752	>	PyObject * obj0 = 0 ;
3753	>	PyObject * obj1 = 0 ;
3754	>	PyObject * obj2 = 0 ;
3755	>	PyObject * obj3 = 0 ;
3756	>	PyObject * obj4 = 0 ;
3757	>	PyObject * obj5 = 0 ;
3758	>
3759	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3760	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3761	>	{
3762	>	if (PyString_Check(obj1)) {
3763	>	temp2 = std::string(PyString_AsString(obj1));
3764	>	arg2 = &temp2;
3765	>	}else {
3766	>	SWIG_exception(SWIG_TypeError, "string expected");
3767	>	}
3768	>	}
3769	>	{
3770	>	if (PyString_Check(obj2)) {
3771	>	temp3 = std::string(PyString_AsString(obj2));
3772	>	arg3 = &temp3;
3773	>	}else {
3774	>	SWIG_exception(SWIG_TypeError, "string expected");
3775	>	}
3776	>	}
3777	>	if (obj3) {
3778	>	{
3779	>	if (PyString_Check(obj3)) {
3780	>	temp4 = std::string(PyString_AsString(obj3));
3781	>	arg4 = &temp4;
3782	>	}else {
3783	>	SWIG_exception(SWIG_TypeError, "string expected");
3784	>	}
3785	>	}
3786	>	}
3787	>	if (obj4) {
3788	>	{
3789	>	if (PyString_Check(obj4)) {
3790	>	temp5 = std::string(PyString_AsString(obj4));
3791	>	arg5 = &temp5;
3792	>	}else {
3793	>	SWIG_exception(SWIG_TypeError, "string expected");
3794	>	}
3795	>	}
3796	>	}
3797	>	if (obj5) {
3798	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3799	>	if (PyErr_Occurred()) SWIG_fail;
3800	>	}
3801	>	{
3802	>	try {
3803	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3804	>
3805	>	}catch (const BossSchedFailure & e) {
3806	>	PyErr_SetString ( SchedulerError, e.what() );
3807	>	return NULL;
3808	>	}catch (const std::exception& e) {
3809	>	PyErr_SetString ( BossError, e.what() );
3810	>	return NULL;
3811	>	}
3812	>	}
3813	>	resultobj = result;
3814	>	return resultobj;
3815	>	fail:
3816	>	return NULL;
3817	>	}
3818	>
3819	>
3820	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3821	>	PyObject *resultobj;
3822	>	BossSession *arg1 = (BossSession *) 0 ;
3823	>	std::string const &arg2_defvalue = "" ;
3824	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3825	>	std::string const &arg3_defvalue = "all" ;
3826	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3827	>	std::string arg4 = (std::string) "" ;
3828	>	std::string arg5 = (std::string) "" ;
3829	>	std::string arg6 = (std::string) "" ;
3830	>	PyObject *result;
3831	>	std::string temp2 ;
3832	>	std::string temp3 ;
3833	>	PyObject * obj0 = 0 ;
3834	>	PyObject * obj1 = 0 ;
3835	>	PyObject * obj2 = 0 ;
3836	>	PyObject * obj3 = 0 ;
3837	>	PyObject * obj4 = 0 ;
3838	>	PyObject * obj5 = 0 ;
3839	>
3840	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3841	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3842	>	if (obj1) {
3843	>	{
3844	>	if (PyString_Check(obj1)) {
3845	>	temp2 = std::string(PyString_AsString(obj1));
3846	>	arg2 = &temp2;
3847	>	}else {
3848	>	SWIG_exception(SWIG_TypeError, "string expected");
3849	>	}
3850	>	}
3851	>	}
3852	>	if (obj2) {
3853	>	{
3854	>	if (PyString_Check(obj2)) {
3855	>	temp3 = std::string(PyString_AsString(obj2));
3856	>	arg3 = &temp3;
3857	>	}else {
3858	>	SWIG_exception(SWIG_TypeError, "string expected");
3859	>	}
3860	>	}
3861	>	}
3862	>	if (obj3) {
3863	>	{
3864	>	if (PyString_Check(obj3))
3865	>	arg4 = std::string(PyString_AsString(obj3));
3866	>	else
3867	>	SWIG_exception(SWIG_TypeError, "string expected");
3868	>	}
3869	>	}
3870	>	if (obj4) {
3871	>	{
3872	>	if (PyString_Check(obj4))
3873	>	arg5 = std::string(PyString_AsString(obj4));
3874	>	else
3875	>	SWIG_exception(SWIG_TypeError, "string expected");
3876	>	}
3877	>	}
3878	>	if (obj5) {
3879	>	{
3880	>	if (PyString_Check(obj5))
3881	>	arg6 = std::string(PyString_AsString(obj5));
3882	>	else
3883	>	SWIG_exception(SWIG_TypeError, "string expected");
3884	>	}
3885	>	}
3886	>	{
3887	>	try {
3888	>	result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3889	>
3890	>	}catch (const BossSchedFailure & e) {
3891	>	PyErr_SetString ( SchedulerError, e.what() );
3892	>	return NULL;
3893	>	}catch (const std::exception& e) {
3894	>	PyErr_SetString ( BossError, e.what() );
3895	>	return NULL;
3896	>	}
3897	>	}
3898	>	resultobj = result;
3899	>	return resultobj;
3900	>	fail:
3901	>	return NULL;
3902	>	}
3903	>
3904	>
3905	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3906	>	PyObject *obj;
3907	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3908	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3909	>	Py_INCREF(obj);
3910	>	return Py_BuildValue((char *)"");
3911	>	}
3912	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3913	>	PyObject *resultobj;
3914	>	char *arg1 ;
3915	>	BossTaskException *result;
3916	>
3917	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3918		{
3919		try {
3920	<	result = (char *)((BossTaskException const *)arg1)->what();
3920	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3921
3922		}catch (const BossSchedFailure & e) {
3923	<	SWIG_exception(SWIG_ValueError, e.what());
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 ? PyString_FromString(result) : Py_BuildValue((char*)"");
3930	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3931		return resultobj;
3932		fail:
3933		return NULL;
#	Line 3514 | Line 3946 | static PyObject *_wrap_delete_BossTaskEx
3946		delete arg1;
3947
3948		}catch (const BossSchedFailure & e) {
3949	<	SWIG_exception(SWIG_ValueError, e.what());
3949	>	PyErr_SetString ( SchedulerError, e.what() );
3950	>	return NULL;
3951		}catch (const std::exception& e) {
3952	<	SWIG_exception(SWIG_RuntimeError, e.what());
3952	>	PyErr_SetString ( BossError, e.what() );
3953	>	return NULL;
3954		}
3955		}
3956		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3533 | Line 3967 | static PyObject * BossTaskException_swig
3967		Py_INCREF(obj);
3968		return Py_BuildValue((char *)"");
3969		}
3970	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3970	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3971		PyObject *resultobj;
3972		BossTask *arg1 = (BossTask *) 0 ;
3973	<	PyObject *arg2 = (PyObject *) 0 ;
3540	<	BossAttributeContainer *arg3 = 0 ;
3541	<	PyObject *result;
3973	>	BossTask::job_iterator result;
3974		PyObject * obj0 = 0 ;
3543	–	PyObject * obj1 = 0 ;
3544	–	PyObject * obj2 = 0 ;
3975
3976	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3976	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3977		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3548	–	arg2 = obj1;
3549	–	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3550	–	if (arg3 == NULL) {
3551	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3552	–	}
3978		{
3979		try {
3980	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3980	>	result = ((BossTask const *)arg1)->job_begin();
3981
3982		}catch (const BossSchedFailure & e) {
3983	<	SWIG_exception(SWIG_ValueError, e.what());
3983	>	PyErr_SetString ( SchedulerError, e.what() );
3984	>	return NULL;
3985		}catch (const std::exception& e) {
3986	<	SWIG_exception(SWIG_RuntimeError, e.what());
3986	>	PyErr_SetString ( BossError, e.what() );
3987	>	return NULL;
3988		}
3989		}
3990	<	resultobj = result;
3990	>	{
3991	>	BossTask::job_iterator * resultptr;
3992	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3993	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3994	>	}
3995		return resultobj;
3996		fail:
3997		return NULL;
3998		}
3999
4000
4001	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
4001	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4002		PyObject *resultobj;
4003		BossTask *arg1 = (BossTask *) 0 ;
4004	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3574	<	PyObject *result;
4004	>	BossTask::job_iterator result;
4005		PyObject * obj0 = 0 ;
3576	–	PyObject * obj1 = 0 ;
4006
4007	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
4007	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4008		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3580	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3581	–	if (arg2 == NULL) {
3582	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3583	–	}
4009		{
4010		try {
4011	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
4011	>	result = ((BossTask const *)arg1)->job_end();
4012
4013		}catch (const BossSchedFailure & e) {
4014	<	SWIG_exception(SWIG_ValueError, e.what());
4014	>	PyErr_SetString ( SchedulerError, e.what() );
4015	>	return NULL;
4016		}catch (const std::exception& e) {
4017	<	SWIG_exception(SWIG_RuntimeError, e.what());
4017	>	PyErr_SetString ( BossError, e.what() );
4018	>	return NULL;
4019		}
4020		}
4021	<	resultobj = result;
4021	>	{
4022	>	BossTask::job_iterator * resultptr;
4023	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4024	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4025	>	}
4026		return resultobj;
4027		fail:
4028		return NULL;
4029		}
4030
4031
4032	<	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
4032	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4033		PyObject *resultobj;
4034		BossTask *arg1 = (BossTask *) 0 ;
4035	<	PyObject *result;
4035	>	BossJob *arg2 = (BossJob *) 0 ;
4036	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4037		PyObject * obj0 = 0 ;
4038	+	PyObject * obj1 = 0 ;
4039
4040	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
4040	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4041		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4042	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4043		{
4044		try {
4045	<	result = (PyObject *)BossTask_jobsDict(arg1);
4045	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4046
4047		}catch (const BossSchedFailure & e) {
4048	<	SWIG_exception(SWIG_ValueError, e.what());
4048	>	PyErr_SetString ( SchedulerError, e.what() );
4049	>	return NULL;
4050		}catch (const std::exception& e) {
4051	<	SWIG_exception(SWIG_RuntimeError, e.what());
4051	>	PyErr_SetString ( BossError, e.what() );
4052	>	return NULL;
4053		}
4054		}
4055	<	resultobj = result;
4055	>	{
4056	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4057	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4058	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4059	>	}
4060		return resultobj;
4061		fail:
4062		return NULL;
4063		}
4064
4065
4066	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
4066	>	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
4067		PyObject *resultobj;
4068		BossTask *arg1 = (BossTask *) 0 ;
4069	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
4070	<	PyObject *result;
4069	>	BossJob *arg2 = (BossJob *) 0 ;
4070	>	std::string *arg3 = 0 ;
4071	>	BossProgram result;
4072	>	std::string temp3 ;
4073		PyObject * obj0 = 0 ;
4074		PyObject * obj1 = 0 ;
4075	+	PyObject * obj2 = 0 ;
4076
4077	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
4077	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
4078		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4079	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4080	<	if (arg2 == NULL) {
4081	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
4079	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4080	>	{
4081	>	if (PyString_Check(obj2)) {
4082	>	temp3 = std::string(PyString_AsString(obj2));
4083	>	arg3 = &temp3;
4084	>	}else {
4085	>	SWIG_exception(SWIG_TypeError, "string expected");
4086	>	}
4087		}
4088		{
4089		try {
4090	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
4090	>	result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
4091
4092		}catch (const BossSchedFailure & e) {
4093	<	SWIG_exception(SWIG_ValueError, e.what());
4093	>	PyErr_SetString ( SchedulerError, e.what() );
4094	>	return NULL;
4095		}catch (const std::exception& e) {
4096	<	SWIG_exception(SWIG_RuntimeError, e.what());
4096	>	PyErr_SetString ( BossError, e.what() );
4097	>	return NULL;
4098		}
4099		}
4100	<	resultobj = result;
4100	>	{
4101	>	BossProgram * resultptr;
4102	>	resultptr = new BossProgram((BossProgram &) result);
4103	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4104	>	}
4105		return resultobj;
4106		fail:
4107		return NULL;
4108		}
4109
4110
4111	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
4111	>	static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4112		PyObject *resultobj;
4113		BossTask *arg1 = (BossTask *) 0 ;
4114	<	std::string *arg2 = 0 ;
4115	<	PyObject *result;
4116	<	std::string temp2 ;
4114	>	BossJob *arg2 = (BossJob *) 0 ;
4115	>	std::string *arg3 = 0 ;
4116	>	BossProgramExec result;
4117	>	std::string temp3 ;
4118		PyObject * obj0 = 0 ;
4119		PyObject * obj1 = 0 ;
4120	+	PyObject * obj2 = 0 ;
4121
4122	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
4122	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4123		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4124	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4125		{
4126	<	if (PyString_Check(obj1)) {
4127	<	temp2 = std::string(PyString_AsString(obj1));
4128	<	arg2 = &temp2;
4126	>	if (PyString_Check(obj2)) {
4127	>	temp3 = std::string(PyString_AsString(obj2));
4128	>	arg3 = &temp3;
4129		}else {
4130		SWIG_exception(SWIG_TypeError, "string expected");
4131		}
4132		}
4133		{
4134		try {
4135	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
4135	>	result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4136
4137		}catch (const BossSchedFailure & e) {
4138	<	SWIG_exception(SWIG_ValueError, e.what());
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	<	resultobj = result;
4145	>	{
4146	>	BossProgramExec * resultptr;
4147	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4148	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4149	>	}
4150		return resultobj;
4151		fail:
4152		return NULL;
#	Line 3703 | Line 4166 | static PyObject *_wrap_new_BossTask__SWI
4166		result = (BossTask *)new BossTask(arg1);
4167
4168		}catch (const BossSchedFailure & e) {
4169	<	SWIG_exception(SWIG_ValueError, e.what());
4169	>	PyErr_SetString ( SchedulerError, e.what() );
4170	>	return NULL;
4171		}catch (const std::exception& e) {
4172	<	SWIG_exception(SWIG_RuntimeError, e.what());
4172	>	PyErr_SetString ( BossError, e.what() );
4173	>	return NULL;
4174		}
4175		}
4176		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3739 | Line 4204 | static PyObject *_wrap_new_BossTask__SWI
4204		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
4205
4206		}catch (const BossSchedFailure & e) {
4207	<	SWIG_exception(SWIG_ValueError, e.what());
4207	>	PyErr_SetString ( SchedulerError, e.what() );
4208	>	return NULL;
4209		}catch (const std::exception& e) {
4210	<	SWIG_exception(SWIG_RuntimeError, e.what());
4210	>	PyErr_SetString ( BossError, e.what() );
4211	>	return NULL;
4212		}
4213		}
4214		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3763 | Line 4230 | static PyObject *_wrap_delete_BossTask(P
4230		delete arg1;
4231
4232		}catch (const BossSchedFailure & e) {
4233	<	SWIG_exception(SWIG_ValueError, e.what());
4233	>	PyErr_SetString ( SchedulerError, e.what() );
4234	>	return NULL;
4235		}catch (const std::exception& e) {
4236	<	SWIG_exception(SWIG_RuntimeError, e.what());
4236	>	PyErr_SetString ( BossError, e.what() );
4237	>	return NULL;
4238		}
4239		}
4240		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3791 | Line 4260 | static PyObject *_wrap_new_BossTask__SWI
4260		result = (BossTask *)new BossTask((BossTask const &)*arg1);
4261
4262		}catch (const BossSchedFailure & e) {
4263	<	SWIG_exception(SWIG_ValueError, e.what());
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		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3884 | Line 4355 | static PyObject *_wrap_BossTask_id(PyObj
4355		}
4356
4357		}catch (const BossSchedFailure & e) {
4358	<	SWIG_exception(SWIG_ValueError, e.what());
4358	>	PyErr_SetString ( SchedulerError, e.what() );
4359	>	return NULL;
4360		}catch (const std::exception& e) {
4361	<	SWIG_exception(SWIG_RuntimeError, e.what());
4361	>	PyErr_SetString ( BossError, e.what() );
4362	>	return NULL;
4363		}
4364		}
4365		{
#	Line 3914 | Line 4387 | static PyObject *_wrap_BossTask_name(PyO
4387		}
4388
4389		}catch (const BossSchedFailure & e) {
4390	<	SWIG_exception(SWIG_ValueError, e.what());
4390	>	PyErr_SetString ( SchedulerError, e.what() );
4391	>	return NULL;
4392		}catch (const std::exception& e) {
4393	<	SWIG_exception(SWIG_RuntimeError, e.what());
4393	>	PyErr_SetString ( BossError, e.what() );
4394	>	return NULL;
4395		}
4396		}
4397		{
#	Line 3928 | Line 4403 | static PyObject *_wrap_BossTask_name(PyO
4403		}
4404
4405
4406	<	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4406	>	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4407		PyObject *resultobj;
4408		BossTask *arg1 = (BossTask *) 0 ;
4409	<	std::map<std::string,std::string > result;
4409	>	std::string *arg2 = 0 ;
4410	>	BossChain result;
4411	>	std::string temp2 ;
4412		PyObject * obj0 = 0 ;
4413	+	PyObject * obj1 = 0 ;
4414
4415	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4415	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4416		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4417		{
4418	<	try {
4419	<	result = ((BossTask const *)arg1)->taskMap();
4420	<
4421	<	}catch (const BossSchedFailure & e) {
4422	<	SWIG_exception(SWIG_ValueError, e.what());
3945	<	}catch (const std::exception& e) {
3946	<	SWIG_exception(SWIG_RuntimeError, e.what());
4418	>	if (PyString_Check(obj1)) {
4419	>	temp2 = std::string(PyString_AsString(obj1));
4420	>	arg2 = &temp2;
4421	>	}else {
4422	>	SWIG_exception(SWIG_TypeError, "string expected");
4423		}
4424		}
4425		{
3950	–	resultobj = PyDict_New();
3951	–	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3952	–	PyDict_SetItem(resultobj,
3953	–	SwigString_FromString(i->first),
3954	–	SwigString_FromString(i->second));
3955	–	}
3956	–	}
3957	–	return resultobj;
3958	–	fail:
3959	–	return NULL;
3960	–	}
3961	–
3962	–
3963	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3964	–	PyObject *resultobj;
3965	–	BossTask *arg1 = (BossTask *) 0 ;
3966	–	BossTask::job_iterator result;
3967	–	PyObject * obj0 = 0 ;
3968	–
3969	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3970	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3971	–	{
4426		try {
4427	<	result = ((BossTask const *)arg1)->job_begin();
4427	>	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4428
4429		}catch (const BossSchedFailure & e) {
4430	<	SWIG_exception(SWIG_ValueError, e.what());
4430	>	PyErr_SetString ( SchedulerError, e.what() );
4431	>	return NULL;
4432		}catch (const std::exception& e) {
4433	<	SWIG_exception(SWIG_RuntimeError, e.what());
4433	>	PyErr_SetString ( BossError, e.what() );
4434	>	return NULL;
4435		}
4436		}
4437		{
4438	<	BossTask::job_iterator * resultptr;
4439	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4440	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4438	>	BossChain * resultptr;
4439	>	resultptr = new BossChain((BossChain &) result);
4440	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4441		}
4442		return resultobj;
4443		fail:
#	Line 3989 | Line 4445 | static PyObject *_wrap_BossTask_job_begi
4445		}
4446
4447
4448	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4448	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4449		PyObject *resultobj;
4450		BossTask *arg1 = (BossTask *) 0 ;
4451	<	BossTask::job_iterator result;
4451	>	std::map<std::string,std::string > result;
4452		PyObject * obj0 = 0 ;
4453
4454	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4454	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4455		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4456		{
4457		try {
4458	<	result = ((BossTask const *)arg1)->job_end();
4458	>	result = ((BossTask const *)arg1)->taskMap();
4459
4460		}catch (const BossSchedFailure & e) {
4461	<	SWIG_exception(SWIG_ValueError, e.what());
4461	>	PyErr_SetString ( SchedulerError, e.what() );
4462	>	return NULL;
4463		}catch (const std::exception& e) {
4464	<	SWIG_exception(SWIG_RuntimeError, e.what());
4464	>	PyErr_SetString ( BossError, e.what() );
4465	>	return NULL;
4466		}
4467		}
4468		{
4469	<	BossTask::job_iterator * resultptr;
4470	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4471	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4469	>	resultobj = PyDict_New();
4470	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4471	>	PyDict_SetItem(resultobj,
4472	>	SwigString_FromString(i->first),
4473	>	SwigString_FromString(i->second));
4474	>	}
4475		}
4476		return resultobj;
4477		fail:
#	Line 4031 | Line 4492 | static PyObject *_wrap_BossTask_jobsMap(
4492		result = ((BossTask const *)arg1)->jobsMap();
4493
4494		}catch (const BossSchedFailure & e) {
4495	<	SWIG_exception(SWIG_ValueError, e.what());
4495	>	PyErr_SetString ( SchedulerError, e.what() );
4496	>	return NULL;
4497		}catch (const std::exception& e) {
4498	<	SWIG_exception(SWIG_RuntimeError, e.what());
4498	>	PyErr_SetString ( BossError, e.what() );
4499	>	return NULL;
4500		}
4501		}
4502		{
#	Line 4071 | Line 4534 | static PyObject *_wrap_BossTask_jobMap__
4534		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4535
4536		}catch (const BossSchedFailure & e) {
4537	<	SWIG_exception(SWIG_ValueError, e.what());
4537	>	PyErr_SetString ( SchedulerError, e.what() );
4538	>	return NULL;
4539		}catch (const std::exception& e) {
4540	<	SWIG_exception(SWIG_RuntimeError, e.what());
4540	>	PyErr_SetString ( BossError, e.what() );
4541	>	return NULL;
4542		}
4543		}
4544		{
#	Line 4102 | Line 4567 | static PyObject *_wrap_BossTask_jobMap__
4567		result = ((BossTask const *)arg1)->jobMap(arg2);
4568
4569		}catch (const BossSchedFailure & e) {
4570	<	SWIG_exception(SWIG_ValueError, e.what());
4570	>	PyErr_SetString ( SchedulerError, e.what() );
4571	>	return NULL;
4572		}catch (const std::exception& e) {
4573	<	SWIG_exception(SWIG_RuntimeError, e.what());
4573	>	PyErr_SetString ( BossError, e.what() );
4574	>	return NULL;
4575		}
4576		}
4577		{
#	Line 4209 | Line 4676 | static PyObject *_wrap_BossTask_programs
4676		result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4677
4678		}catch (const BossSchedFailure & e) {
4679	<	SWIG_exception(SWIG_ValueError, e.what());
4679	>	PyErr_SetString ( SchedulerError, e.what() );
4680	>	return NULL;
4681		}catch (const std::exception& e) {
4682	<	SWIG_exception(SWIG_RuntimeError, e.what());
4682	>	PyErr_SetString ( BossError, e.what() );
4683	>	return NULL;
4684		}
4685		}
4686		{
#	Line 4225 | Line 4694 | static PyObject *_wrap_BossTask_programs
4694		}
4695
4696
4228	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4229	–	PyObject *resultobj;
4230	–	BossTask *arg1 = (BossTask *) 0 ;
4231	–	BossJob *arg2 = (BossJob *) 0 ;
4232	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4233	–	PyObject * obj0 = 0 ;
4234	–	PyObject * obj1 = 0 ;
4235	–
4236	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4237	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4238	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4239	–	{
4240	–	try {
4241	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4242	–
4243	–	}catch (const BossSchedFailure & e) {
4244	–	SWIG_exception(SWIG_ValueError, e.what());
4245	–	}catch (const std::exception& e) {
4246	–	SWIG_exception(SWIG_RuntimeError, e.what());
4247	–	}
4248	–	}
4249	–	{
4250	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4251	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4252	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4253	–	}
4254	–	return resultobj;
4255	–	fail:
4256	–	return NULL;
4257	–	}
4258	–
4259	–
4697		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4698		PyObject *resultobj;
4699		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4294 | Line 4731 | static PyObject *_wrap_BossTask_declare_
4731		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4732
4733		}catch (const BossSchedFailure & e) {
4734	<	SWIG_exception(SWIG_ValueError, e.what());
4734	>	PyErr_SetString ( SchedulerError, e.what() );
4735	>	return NULL;
4736		}catch (const std::exception& e) {
4737	<	SWIG_exception(SWIG_RuntimeError, e.what());
4737	>	PyErr_SetString ( BossError, e.what() );
4738	>	return NULL;
4739		}
4740		}
4741		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4335 | Line 4774 | static PyObject *_wrap_BossTask_declare_
4774		(arg1)->declare(arg2,(std::string const &)*arg3);
4775
4776		}catch (const BossSchedFailure & e) {
4777	<	SWIG_exception(SWIG_ValueError, e.what());
4777	>	PyErr_SetString ( SchedulerError, e.what() );
4778	>	return NULL;
4779		}catch (const std::exception& e) {
4780	<	SWIG_exception(SWIG_RuntimeError, e.what());
4780	>	PyErr_SetString ( BossError, e.what() );
4781	>	return NULL;
4782		}
4783		}
4784		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4436 | Line 4877 | static PyObject *_wrap_BossTask_remove(P
4877		(arg1)->remove();
4878
4879		}catch (const BossSchedFailure & e) {
4880	<	SWIG_exception(SWIG_ValueError, e.what());
4880	>	PyErr_SetString ( SchedulerError, e.what() );
4881	>	return NULL;
4882		}catch (const std::exception& e) {
4883	<	SWIG_exception(SWIG_RuntimeError, e.what());
4883	>	PyErr_SetString ( BossError, e.what() );
4884	>	return NULL;
4885		}
4886		}
4887		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4474 | Line 4917 | static PyObject *_wrap_BossTask_archive(
4917		(arg1)->archive((std::string const &)*arg2);
4918
4919		}catch (const BossSchedFailure & e) {
4920	<	SWIG_exception(SWIG_ValueError, e.what());
4920	>	PyErr_SetString ( SchedulerError, e.what() );
4921	>	return NULL;
4922		}catch (const std::exception& e) {
4923	<	SWIG_exception(SWIG_RuntimeError, e.what());
4923	>	PyErr_SetString ( BossError, e.what() );
4924	>	return NULL;
4925		}
4926		}
4927		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4499 | Line 4944 | static PyObject *_wrap_BossTask_submit(P
4944		std::string *arg5 = (std::string *) &arg5_defvalue ;
4945		std::string const &arg6_defvalue = "" ;
4946		std::string *arg6 = (std::string *) &arg6_defvalue ;
4947	<	bool arg7 = (bool) false ;
4947	>	unsigned int arg7 = (unsigned int) 0 ;
4948	>	bool arg8 = (bool) false ;
4949		int result;
4950		std::string temp2 ;
4951		std::string temp3 ;
#	Line 4513 | Line 4959 | static PyObject *_wrap_BossTask_submit(P
4959		PyObject * obj4 = 0 ;
4960		PyObject * obj5 = 0 ;
4961		PyObject * obj6 = 0 ;
4962	+	PyObject * obj7 = 0 ;
4963
4964	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4964	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4965		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4966		if (obj1) {
4967		{
#	Line 4567 | Line 5014 | static PyObject *_wrap_BossTask_submit(P
5014		}
5015		}
5016		if (obj6) {
5017	<	arg7 = PyInt_AsLong(obj6) ? true : false;
5017	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
5018	>	if (PyErr_Occurred()) SWIG_fail;
5019	>	}
5020	>	if (obj7) {
5021	>	arg8 = PyInt_AsLong(obj7) ? true : false;
5022		if (PyErr_Occurred()) SWIG_fail;
5023		}
5024		{
5025		try {
5026	<	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);
5026	>	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);
5027
5028		}catch (const BossSchedFailure & e) {
5029	<	SWIG_exception(SWIG_ValueError, e.what());
5029	>	PyErr_SetString ( SchedulerError, e.what() );
5030	>	return NULL;
5031		}catch (const std::exception& e) {
5032	<	SWIG_exception(SWIG_RuntimeError, e.what());
5032	>	PyErr_SetString ( BossError, e.what() );
5033	>	return NULL;
5034		}
5035		}
5036		resultobj = PyInt_FromLong((long)result);
#	Line 4617 | Line 5070 | static PyObject *_wrap_BossTask_reSubmit
5070		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
5071
5072		}catch (const BossSchedFailure & e) {
5073	<	SWIG_exception(SWIG_ValueError, e.what());
5073	>	PyErr_SetString ( SchedulerError, e.what() );
5074	>	return NULL;
5075		}catch (const std::exception& e) {
5076	<	SWIG_exception(SWIG_RuntimeError, e.what());
5076	>	PyErr_SetString ( BossError, e.what() );
5077	>	return NULL;
5078		}
5079		}
5080		resultobj = PyInt_FromLong((long)result);
#	Line 4633 | Line 5088 | static PyObject *_wrap_BossTask_kill(PyO
5088		PyObject *resultobj;
5089		BossTask *arg1 = (BossTask *) 0 ;
5090		std::string *arg2 = 0 ;
5091	<	bool arg3 = (bool) false ;
5091	>	unsigned int arg3 = (unsigned int) 0 ;
5092	>	bool arg4 = (bool) false ;
5093		int result;
5094		std::string temp2 ;
5095		PyObject * obj0 = 0 ;
5096		PyObject * obj1 = 0 ;
5097		PyObject * obj2 = 0 ;
5098	+	PyObject * obj3 = 0 ;
5099
5100	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
5100	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
5101		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5102		{
5103		if (PyString_Check(obj1)) {
#	Line 4651 | Line 5108 | static PyObject *_wrap_BossTask_kill(PyO
5108		}
5109		}
5110		if (obj2) {
5111	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5111	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
5112	>	if (PyErr_Occurred()) SWIG_fail;
5113	>	}
5114	>	if (obj3) {
5115	>	arg4 = PyInt_AsLong(obj3) ? true : false;
5116		if (PyErr_Occurred()) SWIG_fail;
5117		}
5118		{
5119		try {
5120	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
5120	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
5121
5122		}catch (const BossSchedFailure & e) {
5123	<	SWIG_exception(SWIG_ValueError, e.what());
5123	>	PyErr_SetString ( SchedulerError, e.what() );
5124	>	return NULL;
5125		}catch (const std::exception& e) {
5126	<	SWIG_exception(SWIG_RuntimeError, e.what());
5126	>	PyErr_SetString ( BossError, e.what() );
5127	>	return NULL;
5128		}
5129		}
5130		resultobj = PyInt_FromLong((long)result);
#	Line 4678 | Line 5141 | static PyObject *_wrap_BossTask_getOutpu
5141		std::string *arg2 = (std::string *) &arg2_defvalue ;
5142		std::string const &arg3_defvalue = "" ;
5143		std::string *arg3 = (std::string *) &arg3_defvalue ;
5144	<	bool arg4 = (bool) false ;
5144	>	unsigned int arg4 = (unsigned int) 0 ;
5145		bool arg5 = (bool) false ;
5146	+	bool arg6 = (bool) false ;
5147		int result;
5148		std::string temp2 ;
5149		std::string temp3 ;
#	Line 4688 | Line 5152 | static PyObject *_wrap_BossTask_getOutpu
5152		PyObject * obj2 = 0 ;
5153		PyObject * obj3 = 0 ;
5154		PyObject * obj4 = 0 ;
5155	+	PyObject * obj5 = 0 ;
5156
5157	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5157	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5158		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5159		if (obj1) {
5160		{
#	Line 4712 | Line 5177 | static PyObject *_wrap_BossTask_getOutpu
5177		}
5178		}
5179		if (obj3) {
5180	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5180	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
5181		if (PyErr_Occurred()) SWIG_fail;
5182		}
5183		if (obj4) {
5184		arg5 = PyInt_AsLong(obj4) ? true : false;
5185		if (PyErr_Occurred()) SWIG_fail;
5186		}
5187	+	if (obj5) {
5188	+	arg6 = PyInt_AsLong(obj5) ? true : false;
5189	+	if (PyErr_Occurred()) SWIG_fail;
5190	+	}
5191		{
5192		try {
5193	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
5193	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
5194
5195		}catch (const BossSchedFailure & e) {
5196	<	SWIG_exception(SWIG_ValueError, e.what());
5196	>	PyErr_SetString ( SchedulerError, e.what() );
5197	>	return NULL;
5198		}catch (const std::exception& e) {
5199	<	SWIG_exception(SWIG_RuntimeError, e.what());
5199	>	PyErr_SetString ( BossError, e.what() );
5200	>	return NULL;
5201	>	}
5202	>	}
5203	>	resultobj = PyInt_FromLong((long)result);
5204	>	return resultobj;
5205	>	fail:
5206	>	return NULL;
5207	>	}
5208	>
5209	>
5210	>	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
5211	>	PyObject *resultobj;
5212	>	BossTask *arg1 = (BossTask *) 0 ;
5213	>	std::string *arg2 = 0 ;
5214	>	int result;
5215	>	std::string temp2 ;
5216	>	PyObject * obj0 = 0 ;
5217	>	PyObject * obj1 = 0 ;
5218	>
5219	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5220	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5221	>	{
5222	>	if (PyString_Check(obj1)) {
5223	>	temp2 = std::string(PyString_AsString(obj1));
5224	>	arg2 = &temp2;
5225	>	}else {
5226	>	SWIG_exception(SWIG_TypeError, "string expected");
5227	>	}
5228	>	}
5229	>	{
5230	>	try {
5231	>	result = (int)(arg1)->loadByName((std::string const &)*arg2);
5232	>
5233	>	}catch (const BossSchedFailure & e) {
5234	>	PyErr_SetString ( SchedulerError, e.what() );
5235	>	return NULL;
5236	>	}catch (const std::exception& e) {
5237	>	PyErr_SetString ( BossError, e.what() );
5238	>	return NULL;
5239		}
5240		}
5241		resultobj = PyInt_FromLong((long)result);
#	Line 4818 | Line 5327 | static PyObject *_wrap_BossTask_load(PyO
5327		result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
5328
5329		}catch (const BossSchedFailure & e) {
5330	<	SWIG_exception(SWIG_ValueError, e.what());
5330	>	PyErr_SetString ( SchedulerError, e.what() );
5331	>	return NULL;
5332		}catch (const std::exception& e) {
5333	<	SWIG_exception(SWIG_RuntimeError, e.what());
5333	>	PyErr_SetString ( BossError, e.what() );
5334	>	return NULL;
5335	>	}
5336	>	}
5337	>	resultobj = PyInt_FromLong((long)result);
5338	>	return resultobj;
5339	>	fail:
5340	>	return NULL;
5341	>	}
5342	>
5343	>
5344	>	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5345	>	PyObject *resultobj;
5346	>	BossTask *arg1 = (BossTask *) 0 ;
5347	>	int arg2 = (int) SCHEDULED ;
5348	>	std::string const &arg3_defvalue = "all" ;
5349	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
5350	>	std::string const &arg4_defvalue = "" ;
5351	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
5352	>	std::string arg5 = (std::string) "" ;
5353	>	std::string arg6 = (std::string) "" ;
5354	>	std::string arg7 = (std::string) "" ;
5355	>	std::string arg8 = (std::string) "" ;
5356	>	unsigned int arg9 = (unsigned int) 0 ;
5357	>	int result;
5358	>	std::string temp3 ;
5359	>	std::string temp4 ;
5360	>	PyObject * obj0 = 0 ;
5361	>	PyObject * obj2 = 0 ;
5362	>	PyObject * obj3 = 0 ;
5363	>	PyObject * obj4 = 0 ;
5364	>	PyObject * obj5 = 0 ;
5365	>	PyObject * obj6 = 0 ;
5366	>	PyObject * obj7 = 0 ;
5367	>	PyObject * obj8 = 0 ;
5368	>
5369	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5370	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5371	>	if (obj2) {
5372	>	{
5373	>	if (PyString_Check(obj2)) {
5374	>	temp3 = std::string(PyString_AsString(obj2));
5375	>	arg3 = &temp3;
5376	>	}else {
5377	>	SWIG_exception(SWIG_TypeError, "string expected");
5378	>	}
5379	>	}
5380	>	}
5381	>	if (obj3) {
5382	>	{
5383	>	if (PyString_Check(obj3)) {
5384	>	temp4 = std::string(PyString_AsString(obj3));
5385	>	arg4 = &temp4;
5386	>	}else {
5387	>	SWIG_exception(SWIG_TypeError, "string expected");
5388	>	}
5389	>	}
5390	>	}
5391	>	if (obj4) {
5392	>	{
5393	>	if (PyString_Check(obj4))
5394	>	arg5 = std::string(PyString_AsString(obj4));
5395	>	else
5396	>	SWIG_exception(SWIG_TypeError, "string expected");
5397	>	}
5398	>	}
5399	>	if (obj5) {
5400	>	{
5401	>	if (PyString_Check(obj5))
5402	>	arg6 = std::string(PyString_AsString(obj5));
5403	>	else
5404	>	SWIG_exception(SWIG_TypeError, "string expected");
5405	>	}
5406	>	}
5407	>	if (obj6) {
5408	>	{
5409	>	if (PyString_Check(obj6))
5410	>	arg7 = std::string(PyString_AsString(obj6));
5411	>	else
5412	>	SWIG_exception(SWIG_TypeError, "string expected");
5413	>	}
5414	>	}
5415	>	if (obj7) {
5416	>	{
5417	>	if (PyString_Check(obj7))
5418	>	arg8 = std::string(PyString_AsString(obj7));
5419	>	else
5420	>	SWIG_exception(SWIG_TypeError, "string expected");
5421	>	}
5422	>	}
5423	>	if (obj8) {
5424	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5425	>	if (PyErr_Occurred()) SWIG_fail;
5426	>	}
5427	>	{
5428	>	try {
5429	>	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5430	>
5431	>	}catch (const BossSchedFailure & e) {
5432	>	PyErr_SetString ( SchedulerError, e.what() );
5433	>	return NULL;
5434	>	}catch (const std::exception& e) {
5435	>	PyErr_SetString ( BossError, e.what() );
5436	>	return NULL;
5437		}
5438		}
5439		resultobj = PyInt_FromLong((long)result);
#	Line 4842 | Line 5455 | static PyObject *_wrap_BossTask_query(Py
5455		std::string arg6 = (std::string) "" ;
5456		std::string arg7 = (std::string) "" ;
5457		std::string arg8 = (std::string) "" ;
5458	<	bool arg9 = (bool) false ;
5458	>	unsigned int arg9 = (unsigned int) 0 ;
5459	>	bool arg10 = (bool) false ;
5460		int result;
5461		std::string temp3 ;
5462		std::string temp4 ;
#	Line 4854 | Line 5468 | static PyObject *_wrap_BossTask_query(Py
5468		PyObject * obj6 = 0 ;
5469		PyObject * obj7 = 0 ;
5470		PyObject * obj8 = 0 ;
5471	+	PyObject * obj9 = 0 ;
5472
5473	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5473	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5474		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5475		if (obj2) {
5476		{
#	Line 4910 | Line 5525 | static PyObject *_wrap_BossTask_query(Py
5525		}
5526		}
5527		if (obj8) {
5528	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5528	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5529	>	if (PyErr_Occurred()) SWIG_fail;
5530	>	}
5531	>	if (obj9) {
5532	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5533		if (PyErr_Occurred()) SWIG_fail;
5534		}
5535		{
5536		try {
5537	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5537	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5538
5539		}catch (const BossSchedFailure & e) {
5540	<	SWIG_exception(SWIG_ValueError, e.what());
5540	>	PyErr_SetString ( SchedulerError, e.what() );
5541	>	return NULL;
5542		}catch (const std::exception& e) {
5543	<	SWIG_exception(SWIG_RuntimeError, e.what());
5543	>	PyErr_SetString ( BossError, e.what() );
5544	>	return NULL;
5545		}
5546		}
5547		resultobj = PyInt_FromLong((long)result);
#	Line 4979 | Line 5600 | static PyObject *_wrap_BossTask_query_ou
5600		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5601
5602		}catch (const BossSchedFailure & e) {
5603	<	SWIG_exception(SWIG_ValueError, e.what());
5603	>	PyErr_SetString ( SchedulerError, e.what() );
5604	>	return NULL;
5605		}catch (const std::exception& e) {
5606	<	SWIG_exception(SWIG_RuntimeError, e.what());
5606	>	PyErr_SetString ( BossError, e.what() );
5607	>	return NULL;
5608		}
5609		}
5610		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5003 | Line 5626 | static PyObject *_wrap_BossTask_clear(Py
5626		(arg1)->clear();
5627
5628		}catch (const BossSchedFailure & e) {
5629	<	SWIG_exception(SWIG_ValueError, e.what());
5629	>	PyErr_SetString ( SchedulerError, e.what() );
5630	>	return NULL;
5631		}catch (const std::exception& e) {
5632	<	SWIG_exception(SWIG_RuntimeError, e.what());
5632	>	PyErr_SetString ( BossError, e.what() );
5633	>	return NULL;
5634		}
5635		}
5636		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5015 | Line 5640 | static PyObject *_wrap_BossTask_clear(Py
5640		}
5641
5642
5643	+	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5644	+	PyObject *resultobj;
5645	+	BossTask *arg1 = (BossTask *) 0 ;
5646	+	PyObject *arg2 = (PyObject *) 0 ;
5647	+	BossAttributeContainer *arg3 = 0 ;
5648	+	PyObject * obj0 = 0 ;
5649	+	PyObject * obj1 = 0 ;
5650	+	PyObject * obj2 = 0 ;
5651	+
5652	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5653	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5654	+	arg2 = obj1;
5655	+	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5656	+	if (arg3 == NULL) {
5657	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5658	+	}
5659	+	{
5660	+	try {
5661	+	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5662	+
5663	+	}catch (const BossSchedFailure & e) {
5664	+	PyErr_SetString ( SchedulerError, e.what() );
5665	+	return NULL;
5666	+	}catch (const std::exception& e) {
5667	+	PyErr_SetString ( BossError, e.what() );
5668	+	return NULL;
5669	+	}
5670	+	}
5671	+	Py_INCREF(Py_None); resultobj = Py_None;
5672	+	return resultobj;
5673	+	fail:
5674	+	return NULL;
5675	+	}
5676	+
5677	+
5678	+	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5679	+	PyObject *resultobj;
5680	+	BossTask *arg1 = (BossTask *) 0 ;
5681	+	BossJob *arg2 = (BossJob *) 0 ;
5682	+	PyObject *arg3 = (PyObject *) 0 ;
5683	+	PyObject * obj0 = 0 ;
5684	+	PyObject * obj1 = 0 ;
5685	+	PyObject * obj2 = 0 ;
5686	+
5687	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5688	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5689	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5690	+	arg3 = obj2;
5691	+	{
5692	+	try {
5693	+	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5694	+
5695	+	}catch (const BossSchedFailure & e) {
5696	+	PyErr_SetString ( SchedulerError, e.what() );
5697	+	return NULL;
5698	+	}catch (const std::exception& e) {
5699	+	PyErr_SetString ( BossError, e.what() );
5700	+	return NULL;
5701	+	}
5702	+	}
5703	+	Py_INCREF(Py_None); resultobj = Py_None;
5704	+	return resultobj;
5705	+	fail:
5706	+	return NULL;
5707	+	}
5708	+
5709	+
5710	+	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5711	+	PyObject *resultobj;
5712	+	BossTask *arg1 = (BossTask *) 0 ;
5713	+	PyObject *result;
5714	+	PyObject * obj0 = 0 ;
5715	+
5716	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5717	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5718	+	{
5719	+	try {
5720	+	result = (PyObject *)BossTask_jobsDict(arg1);
5721	+
5722	+	}catch (const BossSchedFailure & e) {
5723	+	PyErr_SetString ( SchedulerError, e.what() );
5724	+	return NULL;
5725	+	}catch (const std::exception& e) {
5726	+	PyErr_SetString ( BossError, e.what() );
5727	+	return NULL;
5728	+	}
5729	+	}
5730	+	resultobj = result;
5731	+	return resultobj;
5732	+	fail:
5733	+	return NULL;
5734	+	}
5735	+
5736	+
5737	+	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5738	+	PyObject *resultobj;
5739	+	BossTask *arg1 = (BossTask *) 0 ;
5740	+	std::string *arg2 = 0 ;
5741	+	PyObject *result;
5742	+	std::string temp2 ;
5743	+	PyObject * obj0 = 0 ;
5744	+	PyObject * obj1 = 0 ;
5745	+
5746	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5747	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5748	+	{
5749	+	if (PyString_Check(obj1)) {
5750	+	temp2 = std::string(PyString_AsString(obj1));
5751	+	arg2 = &temp2;
5752	+	}else {
5753	+	SWIG_exception(SWIG_TypeError, "string expected");
5754	+	}
5755	+	}
5756	+	{
5757	+	try {
5758	+	result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5759	+
5760	+	}catch (const BossSchedFailure & e) {
5761	+	PyErr_SetString ( SchedulerError, e.what() );
5762	+	return NULL;
5763	+	}catch (const std::exception& e) {
5764	+	PyErr_SetString ( BossError, e.what() );
5765	+	return NULL;
5766	+	}
5767	+	}
5768	+	resultobj = result;
5769	+	return resultobj;
5770	+	fail:
5771	+	return NULL;
5772	+	}
5773	+
5774	+
5775	+	static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
5776	+	PyObject *resultobj;
5777	+	BossTask *arg1 = (BossTask *) 0 ;
5778	+	std::string *arg2 = 0 ;
5779	+	PyObject *result;
5780	+	std::string temp2 ;
5781	+	PyObject * obj0 = 0 ;
5782	+	PyObject * obj1 = 0 ;
5783	+
5784	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5785	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5786	+	{
5787	+	if (PyString_Check(obj1)) {
5788	+	temp2 = std::string(PyString_AsString(obj1));
5789	+	arg2 = &temp2;
5790	+	}else {
5791	+	SWIG_exception(SWIG_TypeError, "string expected");
5792	+	}
5793	+	}
5794	+	{
5795	+	try {
5796	+	result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
5797	+
5798	+	}catch (const BossSchedFailure & e) {
5799	+	PyErr_SetString ( SchedulerError, e.what() );
5800	+	return NULL;
5801	+	}catch (const std::exception& e) {
5802	+	PyErr_SetString ( BossError, e.what() );
5803	+	return NULL;
5804	+	}
5805	+	}
5806	+	resultobj = result;
5807	+	return resultobj;
5808	+	fail:
5809	+	return NULL;
5810	+	}
5811	+
5812	+
5813	+	static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5814	+	PyObject *resultobj;
5815	+	BossTask *arg1 = (BossTask *) 0 ;
5816	+	PyObject *result;
5817	+	PyObject * obj0 = 0 ;
5818	+
5819	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5820	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5821	+	{
5822	+	try {
5823	+	result = (PyObject *)BossTask_jobStates(arg1);
5824	+
5825	+	}catch (const BossSchedFailure & e) {
5826	+	PyErr_SetString ( SchedulerError, e.what() );
5827	+	return NULL;
5828	+	}catch (const std::exception& e) {
5829	+	PyErr_SetString ( BossError, e.what() );
5830	+	return NULL;
5831	+	}
5832	+	}
5833	+	resultobj = result;
5834	+	return resultobj;
5835	+	fail:
5836	+	return NULL;
5837	+	}
5838	+
5839	+
5840	+	static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5841	+	PyObject *resultobj;
5842	+	BossTask *arg1 = (BossTask *) 0 ;
5843	+	PyObject *result;
5844	+	PyObject * obj0 = 0 ;
5845	+
5846	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5847	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5848	+	{
5849	+	try {
5850	+	result = (PyObject *)BossTask_jobStatistic(arg1);
5851	+
5852	+	}catch (const BossSchedFailure & e) {
5853	+	PyErr_SetString ( SchedulerError, e.what() );
5854	+	return NULL;
5855	+	}catch (const std::exception& e) {
5856	+	PyErr_SetString ( BossError, e.what() );
5857	+	return NULL;
5858	+	}
5859	+	}
5860	+	resultobj = result;
5861	+	return resultobj;
5862	+	fail:
5863	+	return NULL;
5864	+	}
5865	+
5866	+
5867	+	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5868	+	PyObject *resultobj;
5869	+	BossTask *arg1 = (BossTask *) 0 ;
5870	+	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5871	+	PyObject *result;
5872	+	PyObject * obj0 = 0 ;
5873	+	PyObject * obj1 = 0 ;
5874	+
5875	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5876	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5877	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5878	+	if (arg2 == NULL) {
5879	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5880	+	}
5881	+	{
5882	+	try {
5883	+	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5884	+
5885	+	}catch (const BossSchedFailure & e) {
5886	+	PyErr_SetString ( SchedulerError, e.what() );
5887	+	return NULL;
5888	+	}catch (const std::exception& e) {
5889	+	PyErr_SetString ( BossError, e.what() );
5890	+	return NULL;
5891	+	}
5892	+	}
5893	+	resultobj = result;
5894	+	return resultobj;
5895	+	fail:
5896	+	return NULL;
5897	+	}
5898	+
5899	+
5900	+	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5901	+	PyObject *resultobj;
5902	+	BossTask *arg1 = (BossTask *) 0 ;
5903	+	std::string *arg2 = 0 ;
5904	+	PyObject *result;
5905	+	std::string temp2 ;
5906	+	PyObject * obj0 = 0 ;
5907	+	PyObject * obj1 = 0 ;
5908	+
5909	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5910	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5911	+	{
5912	+	if (PyString_Check(obj1)) {
5913	+	temp2 = std::string(PyString_AsString(obj1));
5914	+	arg2 = &temp2;
5915	+	}else {
5916	+	SWIG_exception(SWIG_TypeError, "string expected");
5917	+	}
5918	+	}
5919	+	{
5920	+	try {
5921	+	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5922	+
5923	+	}catch (const BossSchedFailure & e) {
5924	+	PyErr_SetString ( SchedulerError, e.what() );
5925	+	return NULL;
5926	+	}catch (const std::exception& e) {
5927	+	PyErr_SetString ( BossError, e.what() );
5928	+	return NULL;
5929	+	}
5930	+	}
5931	+	resultobj = result;
5932	+	return resultobj;
5933	+	fail:
5934	+	return NULL;
5935	+	}
5936	+
5937	+
5938	+	static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5939	+	PyObject *resultobj;
5940	+	BossTask *arg1 = (BossTask *) 0 ;
5941	+	std::string *arg2 = 0 ;
5942	+	std::string *arg3 = 0 ;
5943	+	PyObject *result;
5944	+	std::string temp2 ;
5945	+	std::string temp3 ;
5946	+	PyObject * obj0 = 0 ;
5947	+	PyObject * obj1 = 0 ;
5948	+	PyObject * obj2 = 0 ;
5949	+
5950	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5951	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5952	+	{
5953	+	if (PyString_Check(obj1)) {
5954	+	temp2 = std::string(PyString_AsString(obj1));
5955	+	arg2 = &temp2;
5956	+	}else {
5957	+	SWIG_exception(SWIG_TypeError, "string expected");
5958	+	}
5959	+	}
5960	+	{
5961	+	if (PyString_Check(obj2)) {
5962	+	temp3 = std::string(PyString_AsString(obj2));
5963	+	arg3 = &temp3;
5964	+	}else {
5965	+	SWIG_exception(SWIG_TypeError, "string expected");
5966	+	}
5967	+	}
5968	+	{
5969	+	try {
5970	+	result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5971	+
5972	+	}catch (const BossSchedFailure & e) {
5973	+	PyErr_SetString ( SchedulerError, e.what() );
5974	+	return NULL;
5975	+	}catch (const std::exception& e) {
5976	+	PyErr_SetString ( BossError, e.what() );
5977	+	return NULL;
5978	+	}
5979	+	}
5980	+	resultobj = result;
5981	+	return resultobj;
5982	+	fail:
5983	+	return NULL;
5984	+	}
5985	+
5986	+
5987	+	static PyObject *_wrap_BossTask_programExec(PyObject *self, PyObject *args) {
5988	+	PyObject *resultobj;
5989	+	BossTask *arg1 = (BossTask *) 0 ;
5990	+	std::string *arg2 = 0 ;
5991	+	std::string *arg3 = 0 ;
5992	+	PyObject *result;
5993	+	std::string temp2 ;
5994	+	std::string temp3 ;
5995	+	PyObject * obj0 = 0 ;
5996	+	PyObject * obj1 = 0 ;
5997	+	PyObject * obj2 = 0 ;
5998	+
5999	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
6000	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6001	+	{
6002	+	if (PyString_Check(obj1)) {
6003	+	temp2 = std::string(PyString_AsString(obj1));
6004	+	arg2 = &temp2;
6005	+	}else {
6006	+	SWIG_exception(SWIG_TypeError, "string expected");
6007	+	}
6008	+	}
6009	+	{
6010	+	if (PyString_Check(obj2)) {
6011	+	temp3 = std::string(PyString_AsString(obj2));
6012	+	arg3 = &temp3;
6013	+	}else {
6014	+	SWIG_exception(SWIG_TypeError, "string expected");
6015	+	}
6016	+	}
6017	+	{
6018	+	try {
6019	+	result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
6020	+
6021	+	}catch (const BossSchedFailure & e) {
6022	+	PyErr_SetString ( SchedulerError, e.what() );
6023	+	return NULL;
6024	+	}catch (const std::exception& e) {
6025	+	PyErr_SetString ( BossError, e.what() );
6026	+	return NULL;
6027	+	}
6028	+	}
6029	+	resultobj = result;
6030	+	return resultobj;
6031	+	fail:
6032	+	return NULL;
6033	+	}
6034	+
6035	+
6036	+	static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
6037	+	PyObject *resultobj;
6038	+	BossTask *arg1 = (BossTask *) 0 ;
6039	+	std::string *arg2 = 0 ;
6040	+	std::string *arg3 = 0 ;
6041	+	PyObject *result;
6042	+	std::string temp2 ;
6043	+	std::string temp3 ;
6044	+	PyObject * obj0 = 0 ;
6045	+	PyObject * obj1 = 0 ;
6046	+	PyObject * obj2 = 0 ;
6047	+
6048	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
6049	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6050	+	{
6051	+	if (PyString_Check(obj1)) {
6052	+	temp2 = std::string(PyString_AsString(obj1));
6053	+	arg2 = &temp2;
6054	+	}else {
6055	+	SWIG_exception(SWIG_TypeError, "string expected");
6056	+	}
6057	+	}
6058	+	{
6059	+	if (PyString_Check(obj2)) {
6060	+	temp3 = std::string(PyString_AsString(obj2));
6061	+	arg3 = &temp3;
6062	+	}else {
6063	+	SWIG_exception(SWIG_TypeError, "string expected");
6064	+	}
6065	+	}
6066	+	{
6067	+	try {
6068	+	result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
6069	+
6070	+	}catch (const BossSchedFailure & e) {
6071	+	PyErr_SetString ( SchedulerError, e.what() );
6072	+	return NULL;
6073	+	}catch (const std::exception& e) {
6074	+	PyErr_SetString ( BossError, e.what() );
6075	+	return NULL;
6076	+	}
6077	+	}
6078	+	resultobj = result;
6079	+	return resultobj;
6080	+	fail:
6081	+	return NULL;
6082	+	}
6083	+
6084	+
6085		static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
6086		PyObject *obj;
6087		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 5078 | Line 6145 | static PyObject *_wrap_new_BossAdministr
6145		result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
6146
6147		}catch (const BossSchedFailure & e) {
6148	<	SWIG_exception(SWIG_ValueError, e.what());
6148	>	PyErr_SetString ( SchedulerError, e.what() );
6149	>	return NULL;
6150		}catch (const std::exception& e) {
6151	<	SWIG_exception(SWIG_RuntimeError, e.what());
6151	>	PyErr_SetString ( BossError, e.what() );
6152	>	return NULL;
6153		}
6154		}
6155		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 5102 | Line 6171 | static PyObject *_wrap_delete_BossAdmini
6171		delete arg1;
6172
6173		}catch (const BossSchedFailure & e) {
6174	<	SWIG_exception(SWIG_ValueError, e.what());
6174	>	PyErr_SetString ( SchedulerError, e.what() );
6175	>	return NULL;
6176		}catch (const std::exception& e) {
6177	<	SWIG_exception(SWIG_RuntimeError, e.what());
6177	>	PyErr_SetString ( BossError, e.what() );
6178	>	return NULL;
6179		}
6180		}
6181		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5127 | Line 6198 | static PyObject *_wrap_BossAdministrator
6198		result = (int)(arg1)->configureDB();
6199
6200		}catch (const BossSchedFailure & e) {
6201	<	SWIG_exception(SWIG_ValueError, e.what());
6201	>	PyErr_SetString ( SchedulerError, e.what() );
6202	>	return NULL;
6203		}catch (const std::exception& e) {
6204	<	SWIG_exception(SWIG_RuntimeError, e.what());
6204	>	PyErr_SetString ( BossError, e.what() );
6205	>	return NULL;
6206		}
6207		}
6208		resultobj = PyInt_FromLong((long)result);
#	Line 5163 | Line 6236 | static PyObject *_wrap_BossAdministrator
6236		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
6237
6238		}catch (const BossSchedFailure & e) {
6239	<	SWIG_exception(SWIG_ValueError, e.what());
6239	>	PyErr_SetString ( SchedulerError, e.what() );
6240	>	return NULL;
6241		}catch (const std::exception& e) {
6242	<	SWIG_exception(SWIG_RuntimeError, e.what());
6242	>	PyErr_SetString ( BossError, e.what() );
6243	>	return NULL;
6244		}
6245		}
6246		resultobj = PyInt_FromLong((long)result);
#	Line 5199 | Line 6274 | static PyObject *_wrap_BossAdministrator
6274		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
6275
6276		}catch (const BossSchedFailure & e) {
6277	<	SWIG_exception(SWIG_ValueError, e.what());
6277	>	PyErr_SetString ( SchedulerError, e.what() );
6278	>	return NULL;
6279		}catch (const std::exception& e) {
6280	<	SWIG_exception(SWIG_RuntimeError, e.what());
6280	>	PyErr_SetString ( BossError, e.what() );
6281	>	return NULL;
6282		}
6283		}
6284		resultobj = PyInt_FromLong((long)result);
#	Line 5235 | Line 6312 | static PyObject *_wrap_BossAdministrator
6312		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
6313
6314		}catch (const BossSchedFailure & e) {
6315	<	SWIG_exception(SWIG_ValueError, e.what());
6315	>	PyErr_SetString ( SchedulerError, e.what() );
6316	>	return NULL;
6317		}catch (const std::exception& e) {
6318	<	SWIG_exception(SWIG_RuntimeError, e.what());
6318	>	PyErr_SetString ( BossError, e.what() );
6319	>	return NULL;
6320		}
6321		}
6322		resultobj = PyInt_FromLong((long)result);
#	Line 5271 | Line 6350 | static PyObject *_wrap_BossAdministrator
6350		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
6351
6352		}catch (const BossSchedFailure & e) {
6353	<	SWIG_exception(SWIG_ValueError, e.what());
6353	>	PyErr_SetString ( SchedulerError, e.what() );
6354	>	return NULL;
6355		}catch (const std::exception& e) {
6356	<	SWIG_exception(SWIG_RuntimeError, e.what());
6356	>	PyErr_SetString ( BossError, e.what() );
6357	>	return NULL;
6358		}
6359		}
6360		resultobj = PyInt_FromLong((long)result);
#	Line 5307 | Line 6388 | static PyObject *_wrap_BossAdministrator
6388		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
6389
6390		}catch (const BossSchedFailure & e) {
6391	<	SWIG_exception(SWIG_ValueError, e.what());
6391	>	PyErr_SetString ( SchedulerError, e.what() );
6392	>	return NULL;
6393		}catch (const std::exception& e) {
6394	<	SWIG_exception(SWIG_RuntimeError, e.what());
6394	>	PyErr_SetString ( BossError, e.what() );
6395	>	return NULL;
6396		}
6397		}
6398		resultobj = PyInt_FromLong((long)result);
#	Line 5375 | Line 6458 | static PyObject *_wrap_BossAdministrator
6458		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
6459
6460		}catch (const BossSchedFailure & e) {
6461	<	SWIG_exception(SWIG_ValueError, e.what());
6461	>	PyErr_SetString ( SchedulerError, e.what() );
6462	>	return NULL;
6463		}catch (const std::exception& e) {
6464	<	SWIG_exception(SWIG_RuntimeError, e.what());
6464	>	PyErr_SetString ( BossError, e.what() );
6465	>	return NULL;
6466		}
6467		}
6468		resultobj = PyInt_FromLong((long)result);
#	Line 5467 | Line 6552 | static PyObject *_wrap_BossAdministrator
6552		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
6553
6554		}catch (const BossSchedFailure & e) {
6555	<	SWIG_exception(SWIG_ValueError, e.what());
6555	>	PyErr_SetString ( SchedulerError, e.what() );
6556	>	return NULL;
6557		}catch (const std::exception& e) {
6558	<	SWIG_exception(SWIG_RuntimeError, e.what());
6558	>	PyErr_SetString ( BossError, e.what() );
6559	>	return NULL;
6560		}
6561		}
6562		resultobj = PyInt_FromLong((long)result);
#	Line 5545 | Line 6632 | static PyObject *_wrap_BossAdministrator
6632		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6633
6634		}catch (const BossSchedFailure & e) {
6635	<	SWIG_exception(SWIG_ValueError, e.what());
6635	>	PyErr_SetString ( SchedulerError, e.what() );
6636	>	return NULL;
6637		}catch (const std::exception& e) {
6638	<	SWIG_exception(SWIG_RuntimeError, e.what());
6638	>	PyErr_SetString ( BossError, e.what() );
6639	>	return NULL;
6640		}
6641		}
6642		resultobj = PyInt_FromLong((long)result);
#	Line 5719 | Line 6808 | static PyObject *_wrap_BossAdministrator
6808		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);
6809
6810		}catch (const BossSchedFailure & e) {
6811	<	SWIG_exception(SWIG_ValueError, e.what());
6811	>	PyErr_SetString ( SchedulerError, e.what() );
6812	>	return NULL;
6813		}catch (const std::exception& e) {
6814	<	SWIG_exception(SWIG_RuntimeError, e.what());
6814	>	PyErr_SetString ( BossError, e.what() );
6815	>	return NULL;
6816		}
6817		}
6818		resultobj = PyInt_FromLong((long)result);
#	Line 5744 | Line 6835 | static PyObject *_wrap_BossAdministrator
6835		result = (arg1)->help();
6836
6837		}catch (const BossSchedFailure & e) {
6838	<	SWIG_exception(SWIG_ValueError, e.what());
6838	>	PyErr_SetString ( SchedulerError, e.what() );
6839	>	return NULL;
6840		}catch (const std::exception& e) {
6841	<	SWIG_exception(SWIG_RuntimeError, e.what());
6841	>	PyErr_SetString ( BossError, e.what() );
6842	>	return NULL;
6843		}
6844		}
6845		{
#	Line 5785 | Line 6878 | static PyObject *_wrap_BossAdministrator
6878		result = (arg1)->SQL(arg2,arg3);
6879
6880		}catch (const BossSchedFailure & e) {
6881	<	SWIG_exception(SWIG_ValueError, e.what());
6881	>	PyErr_SetString ( SchedulerError, e.what() );
6882	>	return NULL;
6883		}catch (const std::exception& e) {
6884	<	SWIG_exception(SWIG_RuntimeError, e.what());
6884	>	PyErr_SetString ( BossError, e.what() );
6885	>	return NULL;
6886		}
6887		}
6888		{
#	Line 5859 | Line 6954 | static PyObject *_wrap_BossAdministrator
6954		result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6955
6956		}catch (const BossSchedFailure & e) {
6957	<	SWIG_exception(SWIG_ValueError, e.what());
6957	>	PyErr_SetString ( SchedulerError, e.what() );
6958	>	return NULL;
6959		}catch (const std::exception& e) {
6960	<	SWIG_exception(SWIG_RuntimeError, e.what());
6960	>	PyErr_SetString ( BossError, e.what() );
6961	>	return NULL;
6962		}
6963		}
6964		resultobj = PyInt_FromLong((long)result);
#	Line 5892 | Line 6989 | static PyObject *_wrap_BossAdministrator
6989		result = (int)(arg1)->registerPlugins(arg2);
6990
6991		}catch (const BossSchedFailure & e) {
6992	<	SWIG_exception(SWIG_ValueError, e.what());
6992	>	PyErr_SetString ( SchedulerError, e.what() );
6993	>	return NULL;
6994		}catch (const std::exception& e) {
6995	<	SWIG_exception(SWIG_RuntimeError, e.what());
6995	>	PyErr_SetString ( BossError, e.what() );
6996	>	return NULL;
6997		}
6998		}
6999		resultobj = PyInt_FromLong((long)result);
#	Line 5941 | Line 7040 | static PyMethodDef SwigMethods[] = {
7040		{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
7041		{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
7042		{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5944	–	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5945	–	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5946	–	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5947	–	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5948	–	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5949	–	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5950	–	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7043		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
7044		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
7045		{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
7046		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
7047		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
7048		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
7049	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
7050	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
7051	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
7052	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
7053		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
7054		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
7055		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5965 | Line 7061 | static PyMethodDef SwigMethods[] = {
7061		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
7062		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7063		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
7064	+	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
7065		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
7066	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
7067	+	{ (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
7068	+	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
7069	+	{ (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
7070	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7071	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7072	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
7073	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
7074	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
7075	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7076	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7077		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5970	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5971	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7078		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
5973	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7079		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7080		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7081	<	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7082	<	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7083	<	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7084	<	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7085	<	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7081	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7082	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7083	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7084	>	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7085	>	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
7086		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
7087		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7088		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7089		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7090	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7091		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5986	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5987	–	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7092		{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7093		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
7094		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
5991	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7095		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7096		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7097		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
#	Line 5996 | Line 7099 | static PyMethodDef SwigMethods[] = {
7099		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
7100		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
7101		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7102	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7103		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7104	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7105		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7106		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7107		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7108	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7109	+	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7110	+	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7111	+	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7112	+	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7113	+	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7114	+	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7115	+	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7116	+	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7117	+	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7118	+	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7119	+	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7120		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
7121		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7122		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 6025 | Line 7142 | static PyMethodDef SwigMethods[] = {
7142		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7143
7144		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}};
6028	–	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}};
7145		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7146	+	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}};
7147	+	static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7148		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}};
7149	+	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7150		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}};
7151		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7152		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7153		static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7154	<	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7154	>	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7155		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7156	+	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7157		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
7158		static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
7159		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
#	Line 6046 | Line 7166 | static swig_type_info _swigt__p_jobState
7166
7167		static swig_type_info *swig_types_initial[] = {
7168		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6049	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7169		_swigt__p_XMLDoc,
7170	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7171	+	_swigt__p_BossProgramExec,
7172		_swigt__p_std__vectorTBossTask_p_t,
7173	+	_swigt__p_BossChain,
7174		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
7175		_swigt__p_BossTask,
7176		_swigt__p_BossTaskException,
7177		_swigt__p_std__ostream,
7178	<	_swigt__p_BossAttributeContainer,
7178	>	_swigt__p_BossProgram,
7179		_swigt__p_printOption,
7180	+	_swigt__p_BossAttributeContainer,
7181		_swigt__p_BossJob,
7182		_swigt__p_BossDatabase,
7183		_swigt__p_BossSession,
#	Line 6106 | Line 7229 | SWIGEXPORT(void) SWIG_init(void) {
7229		}
7230		SWIG_InstallConstants(d,swig_const_table);
7231
7232	+
7233	+	// define custom exceptions
7234	+	PyObject *e;
7235	+	PyMethodDef tp_methods = {
7236	+	NULL, NULL, 0, NULL
7237	+	};
7238	+	e = Py_InitModule("BossSession", &tp_methods);
7239	+	// generic BOSS exception
7240	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
7241	+	Py_INCREF(BossError);
7242	+	PyModule_AddObject(e, "BossError", BossError);
7243	+	// scheduler interaction BOSS exception
7244	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
7245	+	Py_INCREF(SchedulerError);
7246	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
7247	+
7248		}
7249

Diff Legend

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