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.11 by gcodispo, Mon Oct 30 14:00:27 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"
933		#include "BossProgram.h"
934		#include "BossProgramExec.h"
935		#include "BossDatabase.h"
936	+	#include "BossScheduler.h"
937	+	#include "BossDeclaration.h"
938
939		PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
940		PyObject *  my_list = PyList_New( my_vec.size());
#	Line 953 | Line 961 | PyObject *BossSession_schedulers(BossSes
961		std::vector<std::string> my_vec = self->showSchedulers();
962		return BossSession_show( self, my_vec );
963		}
964	<	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
964	>	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout){
965		std::vector<std::string> my_vec = self->listMatch( scheduler,
966		schclassad,
959	–	keepfile,
967		taskid,
968	<	jobid);
968	>	jobid,
969	>	timeout);
970		return BossSession_show( self, my_vec );
971		}
972	<	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,bool avoidCheck){
973	<	if ( !avoidCheck ) {
974	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
975	<	type, user, after, before);
976	<	}
977	<	PyObject * job_dict = PyList_New(0);
978	<	std::vector <std::string>
971	<	taskList = self->selectTasks( taskRange, before, after, user);
972	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
973	<	it!= taskList.end(); ++it ) {
974	<	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
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	<
981	<	//       int size = taskList.size();
982	<	//       PyObject * job_dict = PyList_New(0);
979	<	//       for ( unsigned int i = 0; i < size; ++i ) {
980	<	//      PyList_SetItem(job_dict,i, );
981	<	//      self->makeBossTask( *it );
982	<	//       }
983	<	return  job_dict;
984	<	}
985	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
986	<	std::string tmp;
987	<	BossAttributeContainer::const_iterator it_end = obj.end ();
988	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
989	<	it != it_end; ++it) {
990	<	tmp = (*it).first.name ();
991	<	char * key = new char[ tmp.size() ];
992	<	key = strdup(tmp.c_str());
993	<	tmp = (*it).second.value ();
994	<	PyObject * val = PyString_FromString( tmp.c_str() );
995	<	PyDict_SetItemString( dict, key, val );
996	<	delete [] key;
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());
1015	<	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;
1021	>	}
1022	>	PyObject *BossTask_jobsDict(BossTask *self){
1023	>
1024	>	PyObject * job_dict = PyDict_New();
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	>	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_jobsDict(BossTask const *self){
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	<	std::string id = (*jit)->chainId();
1059	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1060	<	PyObject * myid =  PyString_FromString(id.c_str() );
1061	<	PyDict_SetItem( job_dict, myid,tmp );
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 1072 | 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 1090 | Line 1190 | static PyObject *_wrap_new_objectMap__SW
1190		try {
1191		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1192
1193	+	}catch (const BossSchedFailure & e) {
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 1149 | Line 1253 | static PyObject *_wrap_new_objectMap__SW
1253		try {
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	+	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 1372 | static PyObject *_wrap_objectMap___len__
1372		try {
1373		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1374
1375	+	}catch (const BossSchedFailure & e) {
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 1286 | Line 1398 | static PyObject *_wrap_objectMap_clear(P
1398		try {
1399		(arg1)->clear();
1400
1401	+	}catch (const BossSchedFailure & e) {
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 1309 | Line 1425 | static PyObject *_wrap_objectMap___nonze
1425		try {
1426		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1427
1428	+	}catch (const BossSchedFailure & e) {
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 1381 | Line 1501 | static PyObject *_wrap_objectMap___setit
1501		try {
1502		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1503
1504	+	}catch (const BossSchedFailure & e) {
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 1443 | Line 1567 | static PyObject *_wrap_objectMap_has_key
1567		try {
1568		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1569
1570	+	}catch (const BossSchedFailure & e) {
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 1466 | Line 1594 | static PyObject *_wrap_objectMap_keys(Py
1594		try {
1595		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1596
1597	+	}catch (const BossSchedFailure & e) {
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 1489 | Line 1621 | static PyObject *_wrap_objectMap_values(
1621		try {
1622		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1623
1624	+	}catch (const BossSchedFailure & e) {
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 1512 | Line 1648 | static PyObject *_wrap_objectMap_items(P
1648		try {
1649		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1650
1651	+	}catch (const BossSchedFailure & e) {
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 1543 | Line 1683 | static PyObject *_wrap_objectMap___conta
1683		try {
1684		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1685
1686	+	}catch (const BossSchedFailure & e) {
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 1589 | Line 1733 | static PyObject *_wrap_delete_objectMap(
1733		try {
1734		delete arg1;
1735
1736	+	}catch (const BossSchedFailure & e) {
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 1622 | Line 1770 | static PyObject *_wrap_new_vector_string
1770		try {
1771		result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1772
1773	+	}catch (const BossSchedFailure & e) {
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 1657 | Line 1809 | static PyObject *_wrap_new_vector_string
1809		try {
1810		result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1811
1812	+	}catch (const BossSchedFailure & e) {
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 1709 | Line 1865 | static PyObject *_wrap_new_vector_string
1865		try {
1866		result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1867
1868	+	}catch (const BossSchedFailure & e) {
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 1836 | Line 1996 | static PyObject *_wrap_vector_string___l
1996		try {
1997		result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1998
1999	+	}catch (const BossSchedFailure & e) {
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 1888 | Line 2052 | static PyObject *_wrap_vector_string___n
2052		try {
2053		result = (bool)((std::vector<std::string > const *)arg1)->empty();
2054
2055	+	}catch (const BossSchedFailure & e) {
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 1910 | Line 2078 | static PyObject *_wrap_vector_string_cle
2078		try {
2079		(arg1)->clear();
2080
2081	+	}catch (const BossSchedFailure & e) {
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 1940 | Line 2112 | static PyObject *_wrap_vector_string_app
2112		try {
2113		(arg1)->push_back(arg2);
2114
2115	+	}catch (const BossSchedFailure & e) {
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 2016 | Line 2192 | static PyObject *_wrap_vector_string___g
2192		try {
2193		result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2194
2195	+	}catch (const BossSchedFailure & e) {
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 2108 | Line 2288 | static PyObject *_wrap_vector_string___s
2288		try {
2289		std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2290
2291	+	}catch (const BossSchedFailure & e) {
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 2155 | Line 2339 | static PyObject *_wrap_vector_string___d
2339		try {
2340		std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2341
2342	+	}catch (const BossSchedFailure & e) {
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 2177 | Line 2365 | static PyObject *_wrap_delete_vector_str
2365		try {
2366		delete arg1;
2367
2368	+	}catch (const BossSchedFailure & e) {
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 2195 | 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 std::exception& e) {
2416	<	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		}
2220	–	resultobj = result;
2221	–	return resultobj;
2222	–	fail:
2223	–	return NULL;
2224	–	}
2225	–
2226	–
2227	–	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
2228	–	PyObject *resultobj;
2229	–	BossSession *arg1 = (BossSession *) 0 ;
2230	–	PyObject *result;
2231	–	PyObject * obj0 = 0 ;
2232	–
2233	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2234	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
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	+	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 ;
2253	–	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	+	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 ;
2276	–	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	+	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 ;
2299	–	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	+	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 = "" ;
2325	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
2326	<	std::string const &arg5_defvalue = "" ;
2327	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2328	<	bool arg6 = (bool) false ;
2329	<	PyObject *result;
2535	>	std::string const &arg2_defvalue = "" ;
2536	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
2537	>	BossTask *result;
2538		std::string temp2 ;
2331	–	std::string temp3 ;
2332	–	std::string temp4 ;
2333	–	std::string temp5 ;
2539		PyObject * obj0 = 0 ;
2540		PyObject * obj1 = 0 ;
2336	–	PyObject * obj2 = 0 ;
2337	–	PyObject * obj3 = 0 ;
2338	–	PyObject * obj4 = 0 ;
2339	–	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	<	{
2344	<	if (PyString_Check(obj1)) {
2345	<	temp2 = std::string(PyString_AsString(obj1));
2346	<	arg2 = &temp2;
2347	<	}else {
2348	<	SWIG_exception(SWIG_TypeError, "string expected");
2349	<	}
2350	<	}
2351	<	{
2352	<	if (PyString_Check(obj2)) {
2353	<	temp3 = std::string(PyString_AsString(obj2));
2354	<	arg3 = &temp3;
2355	<	}else {
2356	<	SWIG_exception(SWIG_TypeError, "string expected");
2357	<	}
2358	<	}
2359	<	if (obj3) {
2360	<	{
2361	<	if (PyString_Check(obj3)) {
2362	<	temp4 = std::string(PyString_AsString(obj3));
2363	<	arg4 = &temp4;
2364	<	}else {
2365	<	SWIG_exception(SWIG_TypeError, "string expected");
2366	<	}
2367	<	}
2368	<	}
2369	<	if (obj4) {
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		}
2379	–	if (obj5) {
2380	–	arg6 = PyInt_AsLong(obj5) ? true : false;
2381	–	if (PyErr_Occurred()) SWIG_fail;
2382	–	}
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	+	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 ;
2402	<	std::string const &arg3_defvalue = "all" ;
2403	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
2404	<	std::string const &arg4_defvalue = "all" ;
2405	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
2406	<	std::string const &arg5_defvalue = "" ;
2407	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2408	<	std::string arg6 = (std::string) "" ;
2409	<	std::string arg7 = (std::string) "" ;
2410	<	std::string arg8 = (std::string) "" ;
2411	<	std::string arg9 = (std::string) "" ;
2412	<	bool arg10 = (bool) false ;
2413	<	PyObject *result;
2414	<	std::string temp3 ;
2415	<	std::string temp4 ;
2416	<	std::string temp5 ;
2576	>	BossTask *arg2 = (BossTask *) 0 ;
2577		PyObject * obj0 = 0 ;
2578	<	PyObject * obj2 = 0 ;
2419	<	PyObject * obj3 = 0 ;
2420	<	PyObject * obj4 = 0 ;
2421	<	PyObject * obj5 = 0 ;
2422	<	PyObject * obj6 = 0 ;
2423	<	PyObject * obj7 = 0 ;
2424	<	PyObject * obj8 = 0 ;
2425	<	PyObject * obj9 = 0 ;
2578	>	PyObject * obj1 = 0 ;
2579
2580	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) 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 (obj2) {
2430	<	{
2431	<	if (PyString_Check(obj2)) {
2432	<	temp3 = std::string(PyString_AsString(obj2));
2433	<	arg3 = &temp3;
2434	<	}else {
2435	<	SWIG_exception(SWIG_TypeError, "string expected");
2436	<	}
2437	<	}
2438	<	}
2439	<	if (obj3) {
2440	<	{
2441	<	if (PyString_Check(obj3)) {
2442	<	temp4 = std::string(PyString_AsString(obj3));
2443	<	arg4 = &temp4;
2444	<	}else {
2445	<	SWIG_exception(SWIG_TypeError, "string expected");
2446	<	}
2447	<	}
2448	<	}
2449	<	if (obj4) {
2450	<	{
2451	<	if (PyString_Check(obj4)) {
2452	<	temp5 = std::string(PyString_AsString(obj4));
2453	<	arg5 = &temp5;
2454	<	}else {
2455	<	SWIG_exception(SWIG_TypeError, "string expected");
2456	<	}
2457	<	}
2458	<	}
2459	<	if (obj5) {
2460	<	{
2461	<	if (PyString_Check(obj5))
2462	<	arg6 = std::string(PyString_AsString(obj5));
2463	<	else
2464	<	SWIG_exception(SWIG_TypeError, "string expected");
2465	<	}
2466	<	}
2467	<	if (obj6) {
2468	<	{
2469	<	if (PyString_Check(obj6))
2470	<	arg7 = std::string(PyString_AsString(obj6));
2471	<	else
2472	<	SWIG_exception(SWIG_TypeError, "string expected");
2473	<	}
2474	<	}
2475	<	if (obj7) {
2476	<	{
2477	<	if (PyString_Check(obj7))
2478	<	arg8 = std::string(PyString_AsString(obj7));
2479	<	else
2480	<	SWIG_exception(SWIG_TypeError, "string expected");
2481	<	}
2482	<	}
2483	<	if (obj8) {
2484	<	{
2485	<	if (PyString_Check(obj8))
2486	<	arg9 = std::string(PyString_AsString(obj8));
2487	<	else
2488	<	SWIG_exception(SWIG_TypeError, "string expected");
2489	<	}
2490	<	}
2491	<	if (obj9) {
2492	<	arg10 = PyInt_AsLong(obj9) ? true : false;
2493	<	if (PyErr_Occurred()) SWIG_fail;
2494	<	}
2495	<	{
2496	<	try {
2497	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2498	<
2499	<	}catch (const std::exception& e) {
2500	<	SWIG_exception(SWIG_RuntimeError, e.what());
2501	<	}
2502	<	}
2503	<	resultobj = result;
2504	<	return resultobj;
2505	<	fail:
2506	<	return NULL;
2507	<	}
2508	<
2509	<
2510	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2511	<	PyObject *resultobj;
2512	<	std::string arg1 = (std::string) "" ;
2513	<	BossSession *result;
2514	<	PyObject * obj0 = 0 ;
2515	<
2516	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2517	<	if (obj0) {
2518	<	{
2519	<	if (PyString_Check(obj0))
2520	<	arg1 = std::string(PyString_AsString(obj0));
2521	<	else
2522	<	SWIG_exception(SWIG_TypeError, "string expected");
2523	<	}
2524	<	}
2582	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2583		{
2584		try {
2585	<	result = (BossSession *)new BossSession(arg1);
2585	>	(arg1)->destroyBossTask(arg2);
2586
2587	+	}catch (const BossSchedFailure & e) {
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	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2595	>	Py_INCREF(Py_None); resultobj = Py_None;
2596		return resultobj;
2597		fail:
2598		return NULL;
2599		}
2600
2601
2602	<	static PyObject *_wrap_delete_BossSession(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:delete_BossSession",&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	<	delete arg1;
2612	>	result = (arg1)->showCHTools();
2613
2614	+	}catch (const BossSchedFailure & e) {
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	+	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 = "" ;
2588	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2589	<	BossTask *result;
2590	<	std::string temp2 ;
2669	>	std::vector<std::string > result;
2670		PyObject * obj0 = 0 ;
2592	–	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;
2596	–	if (obj1) {
2597	–	{
2598	–	if (PyString_Check(obj1)) {
2599	–	temp2 = std::string(PyString_AsString(obj1));
2600	–	arg2 = &temp2;
2601	–	}else {
2602	–	SWIG_exception(SWIG_TypeError, "string expected");
2603	–	}
2604	–	}
2605	–	}
2674		{
2675		try {
2676	<	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2676	>	result = (arg1)->showRTMon();
2677
2678	+	}catch (const BossSchedFailure & e) {
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 ;
2626	–	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;
2630	–	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	+	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 2655 | Line 2739 | static PyObject *_wrap_BossSession_defau
2739		try {
2740		result = (arg1)->defaultCHTool();
2741
2742	+	}catch (const BossSchedFailure & e) {
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 2680 | Line 2768 | static PyObject *_wrap_BossSession_defau
2768		try {
2769		result = (arg1)->defaultProgramType();
2770
2771	+	}catch (const BossSchedFailure & e) {
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 2705 | Line 2797 | static PyObject *_wrap_BossSession_defau
2797		try {
2798		result = (arg1)->defaultRTMon();
2799
2800	+	}catch (const BossSchedFailure & e) {
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 2730 | Line 2826 | static PyObject *_wrap_BossSession_defau
2826		try {
2827		result = (arg1)->defaultScheduler();
2828
2829	+	}catch (const BossSchedFailure & e) {
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 2755 | Line 2855 | static PyObject *_wrap_BossSession_versi
2855		try {
2856		result = (arg1)->version();
2857
2858	+	}catch (const BossSchedFailure & e) {
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 2780 | Line 2884 | static PyObject *_wrap_BossSession_clien
2884		try {
2885		result = (arg1)->clientID();
2886
2887	+	}catch (const BossSchedFailure & e) {
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 2811 | Line 2919 | static PyObject *_wrap_BossSession_showC
2919		try {
2920		result = (int)(arg1)->showConfigs(arg2);
2921
2922	+	}catch (const BossSchedFailure & e) {
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 2864 | Line 2976 | static PyObject *_wrap_BossSession_RTupd
2976		try {
2977		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2978
2979	+	}catch (const BossSchedFailure & e) {
2980	+	PyErr_SetString ( SchedulerError, e.what() );
2981	+	return NULL;
2982		}catch (const std::exception& e) {
2983	<	SWIG_exception(SWIG_RuntimeError, e.what());
2983	>	PyErr_SetString ( BossError, e.what() );
2984	>	return NULL;
2985		}
2986		}
2987		resultobj = PyInt_FromLong((long)result);
#	Line 2880 | 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 = "" ;
2887	<	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 ;
2892	–	std::string temp6 ;
3009		PyObject * obj0 = 0 ;
3010		PyObject * obj1 = 0 ;
3011		PyObject * obj2 = 0 ;
#	Line 2916 | 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 2930 | Line 3052 | static PyObject *_wrap_BossSession_listM
3052		}
3053		}
3054		if (obj5) {
3055	<	{
3056	<	if (PyString_Check(obj5)) {
2935	<	temp6 = std::string(PyString_AsString(obj5));
2936	<	arg6 = &temp6;
2937	<	}else {
2938	<	SWIG_exception(SWIG_TypeError, "string expected");
2939	<	}
2940	<	}
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	+	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 2973 | 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 2984 | 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 3049 | 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	+	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 3132 | Line 3262 | static PyObject *_wrap_BossSession_selec
3262		try {
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	+	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 3162 | 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 3176 | 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 3242 | 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	+	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 3264 | 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	+	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	+	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 3366 | Line 3945 | static PyObject *_wrap_delete_BossTaskEx
3945		try {
3946		delete arg1;
3947
3948	+	}catch (const BossSchedFailure & e) {
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 3384 | 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 ;
3391	<	BossAttributeContainer *arg3 = 0 ;
3392	<	PyObject *result;
3973	>	BossTask::job_iterator result;
3974		PyObject * obj0 = 0 ;
3394	–	PyObject * obj1 = 0 ;
3395	–	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;
3399	–	arg2 = obj1;
3400	–	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3401	–	if (arg3 == NULL) {
3402	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3403	–	}
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	+	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 ;
3423	<	PyObject *result;
4004	>	BossTask::job_iterator result;
4005		PyObject * obj0 = 0 ;
3425	–	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;
3429	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3430	–	if (arg2 == NULL) {
3431	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3432	–	}
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	+	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((BossTask const *)arg1);
4045	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4046
4047	+	}catch (const BossSchedFailure & e) {
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	+	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	+	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 3543 | Line 4165 | static PyObject *_wrap_new_BossTask__SWI
4165		try {
4166		result = (BossTask *)new BossTask(arg1);
4167
4168	+	}catch (const BossSchedFailure & e) {
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 3577 | Line 4203 | static PyObject *_wrap_new_BossTask__SWI
4203		try {
4204		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
4205
4206	+	}catch (const BossSchedFailure & e) {
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 3599 | Line 4229 | static PyObject *_wrap_delete_BossTask(P
4229		try {
4230		delete arg1;
4231
4232	+	}catch (const BossSchedFailure & e) {
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 3625 | Line 4259 | static PyObject *_wrap_new_BossTask__SWI
4259		try {
4260		result = (BossTask *)new BossTask((BossTask const &)*arg1);
4261
4262	+	}catch (const BossSchedFailure & e) {
4263	+	PyErr_SetString ( SchedulerError, e.what() );
4264	+	return NULL;
4265		}catch (const std::exception& e) {
4266	<	SWIG_exception(SWIG_RuntimeError, e.what());
4266	>	PyErr_SetString ( BossError, e.what() );
4267	>	return NULL;
4268		}
4269		}
4270		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3716 | Line 4354 | static PyObject *_wrap_BossTask_id(PyObj
4354		result = (std::string *) &_result_ref;
4355		}
4356
4357	+	}catch (const BossSchedFailure & e) {
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 3744 | Line 4386 | static PyObject *_wrap_BossTask_name(PyO
4386		result = (std::string *) &_result_ref;
4387		}
4388
4389	+	}catch (const BossSchedFailure & e) {
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 3757 | 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 std::exception& e) {
4422	<	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		{
3777	–	resultobj = PyDict_New();
3778	–	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3779	–	PyDict_SetItem(resultobj,
3780	–	SwigString_FromString(i->first),
3781	–	SwigString_FromString(i->second));
3782	–	}
3783	–	}
3784	–	return resultobj;
3785	–	fail:
3786	–	return NULL;
3787	–	}
3788	–
3789	–
3790	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3791	–	PyObject *resultobj;
3792	–	BossTask *arg1 = (BossTask *) 0 ;
3793	–	BossTask::job_iterator result;
3794	–	PyObject * obj0 = 0 ;
3795	–
3796	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3797	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3798	–	{
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	+	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 3814 | 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	+	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 3853 | Line 4491 | static PyObject *_wrap_BossTask_jobsMap(
4491		try {
4492		result = ((BossTask const *)arg1)->jobsMap();
4493
4494	+	}catch (const BossSchedFailure & e) {
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 3891 | Line 4533 | static PyObject *_wrap_BossTask_jobMap__
4533		try {
4534		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4535
4536	+	}catch (const BossSchedFailure & e) {
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 3920 | Line 4566 | static PyObject *_wrap_BossTask_jobMap__
4566		try {
4567		result = ((BossTask const *)arg1)->jobMap(arg2);
4568
4569	+	}catch (const BossSchedFailure & e) {
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 4025 | Line 4675 | static PyObject *_wrap_BossTask_programs
4675		try {
4676		result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4677
4678	+	}catch (const BossSchedFailure & e) {
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 4040 | Line 4694 | static PyObject *_wrap_BossTask_programs
4694		}
4695
4696
4043	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4044	–	PyObject *resultobj;
4045	–	BossTask *arg1 = (BossTask *) 0 ;
4046	–	BossJob *arg2 = (BossJob *) 0 ;
4047	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4048	–	PyObject * obj0 = 0 ;
4049	–	PyObject * obj1 = 0 ;
4050	–
4051	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4052	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4053	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4054	–	{
4055	–	try {
4056	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4057	–
4058	–	}catch (const std::exception& e) {
4059	–	SWIG_exception(SWIG_RuntimeError, e.what());
4060	–	}
4061	–	}
4062	–	{
4063	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4064	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4065	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4066	–	}
4067	–	return resultobj;
4068	–	fail:
4069	–	return NULL;
4070	–	}
4071	–
4072	–
4697		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4698		PyObject *resultobj;
4699		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4106 | Line 4730 | static PyObject *_wrap_BossTask_declare_
4730		try {
4731		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4732
4733	+	}catch (const BossSchedFailure & e) {
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 4145 | Line 4773 | static PyObject *_wrap_BossTask_declare_
4773		try {
4774		(arg1)->declare(arg2,(std::string const &)*arg3);
4775
4776	+	}catch (const BossSchedFailure & e) {
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 4244 | Line 4876 | static PyObject *_wrap_BossTask_remove(P
4876		try {
4877		(arg1)->remove();
4878
4879	+	}catch (const BossSchedFailure & e) {
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 4280 | Line 4916 | static PyObject *_wrap_BossTask_archive(
4916		try {
4917		(arg1)->archive((std::string const &)*arg2);
4918
4919	+	}catch (const BossSchedFailure & e) {
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 4304 | 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 4318 | 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 4372 | 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	+	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 4419 | Line 5069 | static PyObject *_wrap_BossTask_reSubmit
5069		try {
5070		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
5071
5072	+	}catch (const BossSchedFailure & e) {
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 4434 | 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 4452 | 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	+	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 4477 | 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 4487 | 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 4511 | 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	+	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);
#	Line 4533 | Line 5207 | static PyObject *_wrap_BossTask_getOutpu
5207		}
5208
5209
5210	<	static PyObject *_wrap_BossTask_getAllOutput(PyObject *self, PyObject *args) {
5210	>	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
5211		PyObject *resultobj;
5212		BossTask *arg1 = (BossTask *) 0 ;
5213	<	std::string const &arg2_defvalue = "" ;
4540	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
4541	<	bool arg3 = (bool) false ;
4542	<	bool arg4 = (bool) false ;
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);
5242	+	return resultobj;
5243	+	fail:
5244	+	return NULL;
5245	+	}
5246	+
5247	+
5248	+	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
5249	+	PyObject *resultobj;
5250	+	BossTask *arg1 = (BossTask *) 0 ;
5251	+	int arg2 = (int) SCHEDULED ;
5252	+	std::string const &arg3_defvalue = "all" ;
5253	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
5254	+	std::string const &arg4_defvalue = "" ;
5255	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
5256	+	std::string arg5 = (std::string) "" ;
5257	+	std::string arg6 = (std::string) "" ;
5258	+	std::string arg7 = (std::string) "" ;
5259	+	std::string arg8 = (std::string) "" ;
5260	+	int result;
5261	+	std::string temp3 ;
5262	+	std::string temp4 ;
5263	+	PyObject * obj0 = 0 ;
5264		PyObject * obj2 = 0 ;
5265		PyObject * obj3 = 0 ;
5266	+	PyObject * obj4 = 0 ;
5267	+	PyObject * obj5 = 0 ;
5268	+	PyObject * obj6 = 0 ;
5269	+	PyObject * obj7 = 0 ;
5270
5271	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
5271	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5272		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5273	<	if (obj1) {
5273	>	if (obj2) {
5274		{
5275	<	if (PyString_Check(obj1)) {
5276	<	temp2 = std::string(PyString_AsString(obj1));
5277	<	arg2 = &temp2;
5275	>	if (PyString_Check(obj2)) {
5276	>	temp3 = std::string(PyString_AsString(obj2));
5277	>	arg3 = &temp3;
5278	>	}else {
5279	>	SWIG_exception(SWIG_TypeError, "string expected");
5280	>	}
5281	>	}
5282	>	}
5283	>	if (obj3) {
5284	>	{
5285	>	if (PyString_Check(obj3)) {
5286	>	temp4 = std::string(PyString_AsString(obj3));
5287	>	arg4 = &temp4;
5288		}else {
5289		SWIG_exception(SWIG_TypeError, "string expected");
5290		}
5291		}
5292		}
5293	+	if (obj4) {
5294	+	{
5295	+	if (PyString_Check(obj4))
5296	+	arg5 = std::string(PyString_AsString(obj4));
5297	+	else
5298	+	SWIG_exception(SWIG_TypeError, "string expected");
5299	+	}
5300	+	}
5301	+	if (obj5) {
5302	+	{
5303	+	if (PyString_Check(obj5))
5304	+	arg6 = std::string(PyString_AsString(obj5));
5305	+	else
5306	+	SWIG_exception(SWIG_TypeError, "string expected");
5307	+	}
5308	+	}
5309	+	if (obj6) {
5310	+	{
5311	+	if (PyString_Check(obj6))
5312	+	arg7 = std::string(PyString_AsString(obj6));
5313	+	else
5314	+	SWIG_exception(SWIG_TypeError, "string expected");
5315	+	}
5316	+	}
5317	+	if (obj7) {
5318	+	{
5319	+	if (PyString_Check(obj7))
5320	+	arg8 = std::string(PyString_AsString(obj7));
5321	+	else
5322	+	SWIG_exception(SWIG_TypeError, "string expected");
5323	+	}
5324	+	}
5325	+	{
5326	+	try {
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	+	PyErr_SetString ( SchedulerError, e.what() );
5331	+	return NULL;
5332	+	}catch (const std::exception& e) {
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	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5373	<	if (PyErr_Occurred()) SWIG_fail;
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	<	arg4 = PyInt_AsLong(obj3) ? true : false;
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)->getAllOutput((std::string const &)*arg2,arg3,arg4);
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	<	SWIG_exception(SWIG_RuntimeError, e.what());
5435	>	PyErr_SetString ( BossError, e.what() );
5436	>	return NULL;
5437		}
5438		}
5439		resultobj = PyInt_FromLong((long)result);
#	Line 4594 | 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 4606 | 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 4662 | 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	+	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 4728 | Line 5599 | static PyObject *_wrap_BossTask_query_ou
5599		try {
5600		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5601
5602	+	}catch (const BossSchedFailure & e) {
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 4750 | Line 5625 | static PyObject *_wrap_BossTask_clear(Py
5625		try {
5626		(arg1)->clear();
5627
5628	+	}catch (const BossSchedFailure & e) {
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 4761 | Line 5640 | static PyObject *_wrap_BossTask_clear(Py
5640		}
5641
5642
5643	<	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5644	<	PyObject *obj;
5645	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5646	<	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5647	<	Py_INCREF(obj);
5648	<	return Py_BuildValue((char *)"");
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	<	static PyObject *_wrap_prompt(PyObject *self, PyObject *args) {
5676	>
5677	>
5678	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5679		PyObject *resultobj;
5680	<	std::string *arg1 = 0 ;
5681	<	bool result;
5682	<	std::string temp1 ;
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 *)"O:prompt",&obj0)) goto fail;
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	<	if (PyString_Check(obj0)) {
5693	<	temp1 = std::string(PyString_AsString(obj0));
5694	<	arg1 = &temp1;
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 = (bool)prompt((std::string const &)*arg1);
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	<	SWIG_exception(SWIG_RuntimeError, e.what());
5764	>	PyErr_SetString ( BossError, e.what() );
5765	>	return NULL;
5766		}
5767		}
5768	<	resultobj = PyInt_FromLong((long)result);
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;
6088	+	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
6089	+	Py_INCREF(obj);
6090	+	return Py_BuildValue((char *)"");
6091	+	}
6092		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
6093		PyObject *resultobj;
6094		std::string arg1 = (std::string) "" ;
6095	<	bool arg2 = (bool) false ;
6095	>	std::string arg2 = (std::string) "2" ;
6096	>	std::string arg3 = (std::string) "" ;
6097	>	std::string arg4 = (std::string) "" ;
6098	>	bool arg5 = (bool) false ;
6099		BossAdministratorSession *result;
6100		PyObject * obj0 = 0 ;
6101		PyObject * obj1 = 0 ;
6102	+	PyObject * obj2 = 0 ;
6103	+	PyObject * obj3 = 0 ;
6104	+	PyObject * obj4 = 0 ;
6105
6106	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
6106	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6107		if (obj0) {
6108		{
6109		if (PyString_Check(obj0))
#	Line 4817 | Line 6113 | static PyObject *_wrap_new_BossAdministr
6113		}
6114		}
6115		if (obj1) {
6116	<	arg2 = PyInt_AsLong(obj1) ? true : false;
6116	>	{
6117	>	if (PyString_Check(obj1))
6118	>	arg2 = std::string(PyString_AsString(obj1));
6119	>	else
6120	>	SWIG_exception(SWIG_TypeError, "string expected");
6121	>	}
6122	>	}
6123	>	if (obj2) {
6124	>	{
6125	>	if (PyString_Check(obj2))
6126	>	arg3 = std::string(PyString_AsString(obj2));
6127	>	else
6128	>	SWIG_exception(SWIG_TypeError, "string expected");
6129	>	}
6130	>	}
6131	>	if (obj3) {
6132	>	{
6133	>	if (PyString_Check(obj3))
6134	>	arg4 = std::string(PyString_AsString(obj3));
6135	>	else
6136	>	SWIG_exception(SWIG_TypeError, "string expected");
6137	>	}
6138	>	}
6139	>	if (obj4) {
6140	>	arg5 = PyInt_AsLong(obj4) ? true : false;
6141		if (PyErr_Occurred()) SWIG_fail;
6142		}
6143		{
6144		try {
6145	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
6145	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
6146
6147	+	}catch (const BossSchedFailure & e) {
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 4846 | Line 6170 | static PyObject *_wrap_delete_BossAdmini
6170		try {
6171		delete arg1;
6172
6173	+	}catch (const BossSchedFailure & e) {
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 4869 | Line 6197 | static PyObject *_wrap_BossAdministrator
6197		try {
6198		result = (int)(arg1)->configureDB();
6199
6200	+	}catch (const BossSchedFailure & e) {
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 4903 | Line 6235 | static PyObject *_wrap_BossAdministrator
6235		try {
6236		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
6237
6238	+	}catch (const BossSchedFailure & e) {
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 4937 | Line 6273 | static PyObject *_wrap_BossAdministrator
6273		try {
6274		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
6275
6276	+	}catch (const BossSchedFailure & e) {
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 4971 | Line 6311 | static PyObject *_wrap_BossAdministrator
6311		try {
6312		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
6313
6314	+	}catch (const BossSchedFailure & e) {
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 5005 | Line 6349 | static PyObject *_wrap_BossAdministrator
6349		try {
6350		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
6351
6352	+	}catch (const BossSchedFailure & e) {
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 5039 | Line 6387 | static PyObject *_wrap_BossAdministrator
6387		try {
6388		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
6389
6390	+	}catch (const BossSchedFailure & e) {
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 5105 | Line 6457 | static PyObject *_wrap_BossAdministrator
6457		try {
6458		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
6459
6460	+	}catch (const BossSchedFailure & e) {
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 5195 | Line 6551 | static PyObject *_wrap_BossAdministrator
6551		try {
6552		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
6553
6554	+	}catch (const BossSchedFailure & e) {
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 5271 | Line 6631 | static PyObject *_wrap_BossAdministrator
6631		try {
6632		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6633
6634	+	}catch (const BossSchedFailure & e) {
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 5300 | Line 6664 | static PyObject *_wrap_BossAdministrator
6664		std::string arg13 = (std::string) "" ;
6665		bool arg14 = (bool) false ;
6666		bool arg15 = (bool) false ;
6667	+	bool arg16 = (bool) false ;
6668	+	bool arg17 = (bool) false ;
6669		int result;
6670		std::string temp2 ;
6671		std::string temp11 ;
#	Line 5318 | Line 6684 | static PyObject *_wrap_BossAdministrator
6684		PyObject * obj12 = 0 ;
6685		PyObject * obj13 = 0 ;
6686		PyObject * obj14 = 0 ;
6687	+	PyObject * obj15 = 0 ;
6688	+	PyObject * obj16 = 0 ;
6689
6690	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) goto fail;
6690	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) goto fail;
6691		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6692		{
6693		if (PyString_Check(obj1)) {
#	Line 5427 | Line 6795 | static PyObject *_wrap_BossAdministrator
6795		arg15 = PyInt_AsLong(obj14) ? true : false;
6796		if (PyErr_Occurred()) SWIG_fail;
6797		}
6798	+	if (obj15) {
6799	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6800	+	if (PyErr_Occurred()) SWIG_fail;
6801	+	}
6802	+	if (obj16) {
6803	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6804	+	if (PyErr_Occurred()) SWIG_fail;
6805	+	}
6806		{
6807		try {
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);
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	+	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 5454 | Line 6834 | static PyObject *_wrap_BossAdministrator
6834		try {
6835		result = (arg1)->help();
6836
6837	+	}catch (const BossSchedFailure & e) {
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 5493 | Line 6877 | static PyObject *_wrap_BossAdministrator
6877		try {
6878		result = (arg1)->SQL(arg2,arg3);
6879
6880	+	}catch (const BossSchedFailure & e) {
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 5565 | Line 6953 | static PyObject *_wrap_BossAdministrator
6953		try {
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	+	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 5596 | Line 6988 | static PyObject *_wrap_BossAdministrator
6988		try {
6989		result = (int)(arg1)->registerPlugins(arg2);
6990
6991	+	}catch (const BossSchedFailure & e) {
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 5644 | 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 },
5647	–	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5648	–	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5649	–	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5650	–	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5651	–	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5652	–	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5653	–	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
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 5667 | 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 },
5672	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5673	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7078		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
5675	–	{ (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 },
5688	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5689	–	{ (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 },
5693	–	{ (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 5698 | 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_getAllOutput", _wrap_BossTask_getAllOutput, 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 },
5706	–	{ (char *)"prompt", _wrap_prompt, METH_VARARGS },
7121		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7122		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
7123		{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
#	Line 5728 | 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}};
5731	–	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 5749 | 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,
5752	–	_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 5809 | 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