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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.8 by gcodispo, Fri Oct 27 15:24:50 2006 UTC vs.
Revision 1.32 by gcodispo, Fri May 18 16:10:19 2007 UTC

#	Line 654 \| Line 654 \| *SWIG_InstallConstants(PyObject d, swig_**
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define SWIGTYPE_p_XMLDoc swig_types[0]
658	<	#define SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
657	>	#define SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[0]
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_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[3]
661	<	#define SWIGTYPE_p_BossTask swig_types[4]
662	<	#define SWIGTYPE_p_BossTaskException swig_types[5]
663	<	#define SWIGTYPE_p_std__ostream swig_types[6]
664	<	#define SWIGTYPE_p_BossAttributeContainer swig_types[7]
665	<	#define SWIGTYPE_p_printOption swig_types[8]
666	<	#define SWIGTYPE_p_BossJob swig_types[9]
667	<	#define SWIGTYPE_p_BossDatabase swig_types[10]
668	<	#define SWIGTYPE_p_BossSession swig_types[11]
669	<	#define SWIGTYPE_p_std__vectorTstd__string_t swig_types[12]
670	<	#define SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[13]
671	<	#define SWIGTYPE_p_BossAdministratorSession swig_types[14]
672	<	#define SWIGTYPE_p_BossTask__job_iterator swig_types[15]
673	<	#define SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	<	#define SWIGTYPE_p_jobStates swig_types[17]
675	<	static swig_type_info *swig_types[19];
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 850 \| Line 854 \| *PyObject std_maplstd_stringcstd_string_**
854		" for iterator support");
855		#endif
856		}
857	+	std::string std_vectorlstd_string_g_pop___(std::vector<std::string > *self){
858	+	if (self->size() == 0)
859	+	throw std::out_of_range("pop from empty vector");
860	+	std::string x = self->back();
861	+	self->pop_back();
862	+	return x;
863	+	}
864	+	std::string std_vectorlstd_string_g___getitem_____(std::vector<std::string > *self,int i){
865	+	int size = int(self->size());
866	+	if (i<0) i += size;
867	+	if (i>=0 && i<size)
868	+	return (*self)[i];
869	+	else
870	+	throw std::out_of_range("vector index out of range");
871	+	}
872	+	std::vector<std::string > std_vectorlstd_string_g___getslice_____(std::vector<std::string > *self,int i,int j){
873	+	int size = int(self->size());
874	+	if (i<0) i = size+i;
875	+	if (j<0) j = size+j;
876	+	if (i<0) i = 0;
877	+	if (j>size) j = size;
878	+	std::vector<std::string > tmp(j-i);
879	+	std::copy(self->begin()+i,self->begin()+j,tmp.begin());
880	+	return tmp;
881	+	}
882	+	void std_vectorlstd_string_g___setitem_____(std::vector<std::string > *self,int i,std::string x){
883	+	int size = int(self->size());
884	+	if (i<0) i+= size;
885	+	if (i>=0 && i<size)
886	+	(*self)[i] = x;
887	+	else
888	+	throw std::out_of_range("vector index out of range");
889	+	}
890	+	void std_vectorlstd_string_g___setslice_____(std::vector<std::string > *self,int i,int j,std::vector<std::string > const &v){
891	+	int size = int(self->size());
892	+	if (i<0) i = size+i;
893	+	if (j<0) j = size+j;
894	+	if (i<0) i = 0;
895	+	if (j>size) j = size;
896	+	if (int(v.size()) == j-i) {
897	+	std::copy(v.begin(),v.end(),self->begin()+i);
898	+	} else {
899	+	self->erase(self->begin()+i,self->begin()+j);
900	+	if (i+1 <= int(self->size()))
901	+	self->insert(self->begin()+i,v.begin(),v.end());
902	+	else
903	+	self->insert(self->end(),v.begin(),v.end());
904	+	}
905	+	}
906	+	void std_vectorlstd_string_g___delitem_____(std::vector<std::string > *self,int i){
907	+	int size = int(self->size());
908	+	if (i<0) i+= size;
909	+	if (i>=0 && i<size)
910	+	self->erase(self->begin()+i);
911	+	else
912	+	throw std::out_of_range("vector index out of range");
913	+	}
914	+	void std_vectorlstd_string_g___delslice_____(std::vector<std::string > *self,int i,int j){
915	+	int size = int(self->size());
916	+	if (i<0) i = size+i;
917	+	if (j<0) j = size+j;
918	+	if (i<0) i = 0;
919	+	if (j>size) j = size;
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 871 \| Line 945 \| PyObject BossSession_show(BossSession
945		}
946		return my_list;
947		}
948	<	PyObject BossSession_showCHTools__SWIG_1(BossSession self){
948	>	PyObject BossSession_CHTools(BossSession self){
949		std::vector<std::string> my_vec = self->showCHTools();
950		return BossSession_show( self, my_vec );
951		}
952	<	PyObject BossSession_showProgramTypes__SWIG_1(BossSession self){
952	>	PyObject BossSession_ProgramTypes(BossSession self){
953		std::vector<std::string> my_vec = self->showProgramTypes();
954		return BossSession_show( self, my_vec );
955		}
956	<	PyObject BossSession_showRTMon__SWIG_1(BossSession self){
956	>	PyObject BossSession_RTMons(BossSession self){
957		std::vector<std::string> my_vec = self->showRTMon();
958		return BossSession_show( self, my_vec );
959		}
960	<	PyObject BossSession_showSchedulers__SWIG_1(BossSession self){
960	>	PyObject BossSession_schedulers(BossSession self){
961		std::vector<std::string> my_vec = self->showSchedulers();
962		return BossSession_show( self, my_vec );
963		}
964	<	PyObject BossSession_listMatch__SWIG_1(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,bool keepfile){
965		std::vector<std::string> my_vec = self->listMatch( scheduler,
966		schclassad,
967		keepfile,
968		taskid,
969	<	jobid);
969	>	jobid,
970	>	timeout);
971		return BossSession_show( self, my_vec );
972		}
973	<	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){
974	<	if ( !avoidCheck ) {
975	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
976	<	type, user, after, before);
977	<	}
978	<	PyObject * job_dict = PyList_New(0);
979	<	std::vector <std::string>
905	<	taskList = self->selectTasks( taskRange, before, after, user);
906	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
907	<	it!= taskList.end(); ++it ) {
908	<	PyList_Append( job_dict, PyString_FromString(it->c_str() ) );
973	>	PyObject BossSession_queryTasks(BossSession self,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
974	>	PyObject * task_list = PyList_New(0);
975	>	std::vector <std::string> taskList;
976	>	if ( taskName.empty() ) {
977	>	taskList = self->selectTasks( taskRange, before, after, user);
978	>	} else {
979	>	taskList = self->selectTasksByName( taskName );
980		}
981	<
982	<	// int size = taskList.size();
983	<	// PyObject * job_dict = PyList_New(0);
913	<	// for ( unsigned int i = 0; i < size; ++i ) {
914	<	// PyList_SetItem(job_dict,i, );
915	<	// self->makeBossTask( *it );
916	<	// }
917	<	return job_dict;
918	<	}
919	<	PyObject BossTask_appendToPyDict(BossTask const self,PyObject *dict,BossAttributeContainer const &obj){
920	<	std::string tmp;
921	<	BossAttributeContainer::const_iterator it_end = obj.end ();
922	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
923	<	it != it_end; ++it) {
924	<	tmp = (*it).first.name ();
925	<	char * key = new char[ tmp.size() ];
926	<	key = strdup(tmp.c_str());
927	<	tmp = (*it).second.value ();
928	<	PyObject * val = PyString_FromString( tmp.c_str() );
929	<	PyDict_SetItemString( dict, key, val );
930	<	delete [] key;
981	>	for ( std::vector <std::string>::const_iterator it= taskList.begin();
982	>	it!= taskList.end(); ++it ) {
983	>	PyList_Append( task_list, PyString_FromString(it->c_str() ) );
984		}
985	<	return dict;
985	>	return task_list;
986		}
987	<	PyObject BossTask_jobDict(BossTask const self,std::vector<BossJob * >::const_iterator &jit){
987	>	void BossTask_appendToPyDict(BossTask const self,PyObject dict,BossAttributeContainer const &obj){
988	>	std::string tmp;
989	>	BossAttributeContainer::const_iterator it_end = obj.end ();
990	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
991	>	it != it_end; ++it) {
992	>
993	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
994	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
995	>	PyDict_SetItem( dict, key, val);
996	>	Py_DECREF(key);
997	>	Py_DECREF(val);
998	>	}
999	>	return;
1000	>	}
1001	>	void BossTask_jobDict(BossTask const self,BossJob const jobH,PyObject *job_dict){
1002
1003	<	PyObject * job_dict = PyDict_New();
1003	>	// PyObject * job_dict = PyDict_New();
1004		std::string tmp;
1005
1006	<	BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1007	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1006	>	BossAttributeContainer obj = jobH->getTableEntries("JOB");
1007	>	BossTask_appendToPyDict ( self, job_dict, obj );
1008
1009	<	std::set<std::string> sch = (*jit)->getSchedulerElements();
1009	>	std::set<std::string> sch = jobH->getSchedulerElements();
1010		std::set<std::string>::const_iterator sch_end = sch.end();
1011		for (std::set<std::string>::const_iterator it =sch.begin();
1012		it != sch_end; ++ it ) {
1013	<	tmp = (*it);
1014	<	char * key = new char[ tmp.size() ];
1015	<	key = strdup(tmp.c_str());
949	<	tmp = (*jit)["JOB_SCHED_INFO."+(it)];
1013	>
1014	>	tmp = (jobH)["JOB_SCHED_INFO."+(it)];
1015	>	PyObject * key = PyString_FromString( it->c_str() );
1016		PyObject * val = PyString_FromString( tmp.c_str() );
1017	<	PyDict_SetItemString( job_dict, key, val );
1018	<	delete [] key;
1017	>	PyDict_SetItem( job_dict, key, val);
1018	>	Py_DECREF(key);
1019	>	Py_DECREF(val);
1020	>	}
1021	>	return;
1022	>	}
1023	>	PyObject BossTask_jobsDict(BossTask self){
1024	>
1025	>	PyObject * job_dict = PyDict_New();
1026	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1027	>	for (BossTask::job_iterator jit = self->job_begin ();
1028	>	jit != self->job_end (); ++jit) {
1029	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1030	>	PyObject * tmp_dict = PyDict_New();
1031	>	BossTask_jobDict( self, *jit, tmp_dict );
1032	>	PyDict_SetItem( job_dict, id, tmp_dict );
1033	>	Py_DECREF(id);
1034	>	Py_DECREF(tmp_dict);
1035		}
1036		return job_dict;
1037		}
1038	<	PyObject BossTask_jobsMap__SWIG_1(BossTask const self){
1038	>	PyObject BossTask_job(BossTask self,std::string const &jobid){
1039
1040		PyObject * job_dict = PyDict_New();
1041	+	self->load( ALL, jobid );
1042	+	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1043	+	return job_dict;
1044	+	}
1045	+	PyObject BossTask_Chain(BossTask self,std::string const &jobid){
1046	+
1047	+	PyObject * chain_dict = PyDict_New();
1048	+	BossAttributeContainer obj =
1049	+	self->chain( jobid ).getTableEntries("CHAIN");
1050	+	BossTask_appendToPyDict ( self, chain_dict, obj );
1051	+	return chain_dict;
1052	+	}
1053	+	PyObject BossTask_jobStates(BossTask self){
1054	+
1055	+	PyObject * job_dict = PyDict_New();
1056	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1057		for (BossTask::job_iterator jit = self->job_begin ();
1058		jit != self->job_end (); ++jit) {
1059	<	std::string id = (*jit)->chainId();
1060	<	PyObject * tmp = BossTask_jobDict( self, jit );
1061	<	PyObject * myid = PyString_FromString(id.c_str() );
1062	<	PyDict_SetItem( job_dict, myid,tmp );
1059	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1060	>	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1061	>	PyDict_SetItem( job_dict, id, status );
1062	>	Py_DECREF(id);
1063	>	Py_DECREF(status);
1064	>	}
1065	>	return job_dict;
1066	>	}
1067	>	PyObject BossTask_jobStatistic(BossTask self){
1068	>
1069	>	PyObject * job_dict = PyDict_New();
1070	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1071	>	std::map< std::string, int > states;
1072	>	for (BossTask::job_iterator jit = self->job_begin ();
1073	>	jit != self->job_end (); ++jit) {
1074	>	++states[(**jit)["JOB.STATUS"]];
1075	>	}
1076	>
1077	>	std::map< std::string, int >::const_iterator end = states.end ();
1078	>	for (std::map< std::string, int >::const_iterator it = states.begin ();
1079	>	it != end; ++it) {
1080	>	PyObject * status = PyString_FromString( (it->first).c_str() );
1081	>	PyObject * jobs = PyString_FromFormat( "%d", it->second );
1082	>	PyDict_SetItem( job_dict, status, jobs );
1083	>	Py_DECREF(jobs);
1084	>	Py_DECREF(status);
1085		}
1086		return job_dict;
1087		}
#	Line 1006 \| Line 1126 \| *PyObject BossTask_jobPrograms(BossTask**
1126		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1127		++programs_it ) {
1128		std::string id = (programs_it->first)["PROGRAM.ID"];
1129	<	PyObject * tmp = BossTask_progDict( self, programs_it );
1129	>	PyObject * tmp_dict = BossTask_progDict( self, programs_it );
1130		PyObject * myid = PyString_FromString(id.c_str() );
1131	<	PyDict_SetItem( job_dict, myid,tmp );
1131	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1132	>	Py_DECREF(myid);
1133	>	Py_DECREF(tmp_dict);
1134	>	}
1135	>	return job_dict;
1136	>	}
1137	>	PyObject BossTask_program(BossTask self,std::string const &jobid,std::string const &programId){
1138	>
1139	>	PyObject * job_dict = PyDict_New();
1140	>
1141	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1142	>	BossAttributeContainer obj =
1143	>	self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1144	>	BossTask_appendToPyDict ( self, job_dict, obj );
1145	>	return job_dict;
1146	>	}
1147	>	PyObject BossTask_programExec(BossTask self,std::string const &jobid,std::string const &programId){
1148	>
1149	>	PyObject * job_dict = PyDict_New();
1150	>
1151	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1152	>
1153	>	// PROGRAM_EXEC
1154	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1155	>	BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1156	>	BossTask_appendToPyDict ( self, job_dict, obj );
1157	>
1158	>	// SPECIFICS
1159	>	std::vector < BossAttributeContainer >::const_iterator it;
1160	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1161	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1162	>	BossTask_appendToPyDict ( self, job_dict, *it );
1163	>	}
1164	>	return job_dict;
1165	>	}
1166	>	PyObject BossTask_specific(BossTask self,std::string const &jobid,std::string const &programId){
1167	>
1168	>	PyObject * job_dict = PyDict_New();
1169	>
1170	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1171	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1172	>	BossAttributeContainer obj = programExec.getKeys ();
1173	>	BossTask_appendToPyDict ( self, job_dict, obj );
1174	>
1175	>	std::vector < BossAttributeContainer >::const_iterator it;
1176	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1177	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1178	>	BossTask_appendToPyDict ( self, job_dict, *it );
1179		}
1180		return job_dict;
1181		}
#	Line 1024 \| Line 1191 \| *static PyObject _wrap_new_objectMap__SW**
1191		try {
1192		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1193
1194	+	}catch (const BossSchedFailure & e) {
1195	+	PyErr_SetString ( SchedulerError, e.what() );
1196	+	return NULL;
1197		}catch (const std::exception& e) {
1198	<	SWIG_exception(SWIG_RuntimeError, e.what());
1198	>	PyErr_SetString ( BossError, e.what() );
1199	>	return NULL;
1200		}
1201		}
1202		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1083 \| Line 1254 \| *static PyObject _wrap_new_objectMap__SW**
1254		try {
1255		result = (std::map<std::string,std::string > )new std::map<std::string,std::string >((std::map<std::string,std::string > const &)arg1);
1256
1257	+	}catch (const BossSchedFailure & e) {
1258	+	PyErr_SetString ( SchedulerError, e.what() );
1259	+	return NULL;
1260		}catch (const std::exception& e) {
1261	<	SWIG_exception(SWIG_RuntimeError, e.what());
1261	>	PyErr_SetString ( BossError, e.what() );
1262	>	return NULL;
1263		}
1264		}
1265		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1198 \| Line 1373 \| *static PyObject _wrap_objectMap___len__**
1373		try {
1374		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1375
1376	+	}catch (const BossSchedFailure & e) {
1377	+	PyErr_SetString ( SchedulerError, e.what() );
1378	+	return NULL;
1379		}catch (const std::exception& e) {
1380	<	SWIG_exception(SWIG_RuntimeError, e.what());
1380	>	PyErr_SetString ( BossError, e.what() );
1381	>	return NULL;
1382		}
1383		}
1384		resultobj = PyInt_FromLong((long)result);
#	Line 1220 \| Line 1399 \| *static PyObject _wrap_objectMap_clear(P**
1399		try {
1400		(arg1)->clear();
1401
1402	+	}catch (const BossSchedFailure & e) {
1403	+	PyErr_SetString ( SchedulerError, e.what() );
1404	+	return NULL;
1405		}catch (const std::exception& e) {
1406	<	SWIG_exception(SWIG_RuntimeError, e.what());
1406	>	PyErr_SetString ( BossError, e.what() );
1407	>	return NULL;
1408		}
1409		}
1410		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1243 \| Line 1426 \| *static PyObject _wrap_objectMap___nonze**
1426		try {
1427		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1428
1429	+	}catch (const BossSchedFailure & e) {
1430	+	PyErr_SetString ( SchedulerError, e.what() );
1431	+	return NULL;
1432		}catch (const std::exception& e) {
1433	<	SWIG_exception(SWIG_RuntimeError, e.what());
1433	>	PyErr_SetString ( BossError, e.what() );
1434	>	return NULL;
1435		}
1436		}
1437		resultobj = PyInt_FromLong((long)result);
#	Line 1315 \| Line 1502 \| *static PyObject _wrap_objectMap___setit**
1502		try {
1503		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1504
1505	+	}catch (const BossSchedFailure & e) {
1506	+	PyErr_SetString ( SchedulerError, e.what() );
1507	+	return NULL;
1508		}catch (const std::exception& e) {
1509	<	SWIG_exception(SWIG_RuntimeError, e.what());
1509	>	PyErr_SetString ( BossError, e.what() );
1510	>	return NULL;
1511		}
1512		}
1513		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1377 \| Line 1568 \| *static PyObject _wrap_objectMap_has_key**
1568		try {
1569		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1570
1571	+	}catch (const BossSchedFailure & e) {
1572	+	PyErr_SetString ( SchedulerError, e.what() );
1573	+	return NULL;
1574		}catch (const std::exception& e) {
1575	<	SWIG_exception(SWIG_RuntimeError, e.what());
1575	>	PyErr_SetString ( BossError, e.what() );
1576	>	return NULL;
1577		}
1578		}
1579		resultobj = PyInt_FromLong((long)result);
#	Line 1400 \| Line 1595 \| *static PyObject _wrap_objectMap_keys(Py**
1595		try {
1596		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1597
1598	+	}catch (const BossSchedFailure & e) {
1599	+	PyErr_SetString ( SchedulerError, e.what() );
1600	+	return NULL;
1601		}catch (const std::exception& e) {
1602	<	SWIG_exception(SWIG_RuntimeError, e.what());
1602	>	PyErr_SetString ( BossError, e.what() );
1603	>	return NULL;
1604		}
1605		}
1606		resultobj = result;
#	Line 1423 \| Line 1622 \| *static PyObject _wrap_objectMap_values(**
1622		try {
1623		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1624
1625	+	}catch (const BossSchedFailure & e) {
1626	+	PyErr_SetString ( SchedulerError, e.what() );
1627	+	return NULL;
1628		}catch (const std::exception& e) {
1629	<	SWIG_exception(SWIG_RuntimeError, e.what());
1629	>	PyErr_SetString ( BossError, e.what() );
1630	>	return NULL;
1631		}
1632		}
1633		resultobj = result;
#	Line 1446 \| Line 1649 \| *static PyObject _wrap_objectMap_items(P**
1649		try {
1650		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1651
1652	+	}catch (const BossSchedFailure & e) {
1653	+	PyErr_SetString ( SchedulerError, e.what() );
1654	+	return NULL;
1655		}catch (const std::exception& e) {
1656	<	SWIG_exception(SWIG_RuntimeError, e.what());
1656	>	PyErr_SetString ( BossError, e.what() );
1657	>	return NULL;
1658		}
1659		}
1660		resultobj = result;
#	Line 1477 \| Line 1684 \| *static PyObject _wrap_objectMap___conta**
1684		try {
1685		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1686
1687	+	}catch (const BossSchedFailure & e) {
1688	+	PyErr_SetString ( SchedulerError, e.what() );
1689	+	return NULL;
1690		}catch (const std::exception& e) {
1691	<	SWIG_exception(SWIG_RuntimeError, e.what());
1691	>	PyErr_SetString ( BossError, e.what() );
1692	>	return NULL;
1693		}
1694		}
1695		resultobj = PyInt_FromLong((long)result);
#	Line 1523 \| Line 1734 \| *static PyObject _wrap_delete_objectMap(**
1734		try {
1735		delete arg1;
1736
1737	+	}catch (const BossSchedFailure & e) {
1738	+	PyErr_SetString ( SchedulerError, e.what() );
1739	+	return NULL;
1740		}catch (const std::exception& e) {
1741	<	SWIG_exception(SWIG_RuntimeError, e.what());
1741	>	PyErr_SetString ( BossError, e.what() );
1742	>	return NULL;
1743		}
1744		}
1745		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1541 \| Line 1756 \| *static PyObject objectMap_swigregister**
1756		Py_INCREF(obj);
1757		return Py_BuildValue((char *)"");
1758		}
1759	<	static PyObject _wrap_BossSession_show(PyObject self, PyObject *args) {
1759	>	static PyObject _wrap_new_vector_string__SWIG_0(PyObject self, PyObject *args) {
1760		PyObject *resultobj;
1761	<	BossSession arg1 = (BossSession ) 0 ;
1762	<	std::vector<std::string > *arg2 = 0 ;
1763	<	PyObject *result;
1761	>	unsigned int arg1 = (unsigned int) 0 ;
1762	>	std::vector<std::string > *result;
1763	>	PyObject * obj0 = 0 ;
1764	>
1765	>	if(!PyArg_ParseTuple(args,(char *)"\|O:new_vector_string",&obj0)) goto fail;
1766	>	if (obj0) {
1767	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1768	>	if (PyErr_Occurred()) SWIG_fail;
1769	>	}
1770	>	{
1771	>	try {
1772	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1773	>
1774	>	}catch (const BossSchedFailure & e) {
1775	>	PyErr_SetString ( SchedulerError, e.what() );
1776	>	return NULL;
1777	>	}catch (const std::exception& e) {
1778	>	PyErr_SetString ( BossError, e.what() );
1779	>	return NULL;
1780	>	}
1781	>	}
1782	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1783	>	return resultobj;
1784	>	fail:
1785	>	return NULL;
1786	>	}
1787	>
1788	>
1789	>	static PyObject _wrap_new_vector_string__SWIG_1(PyObject self, PyObject *args) {
1790	>	PyObject *resultobj;
1791	>	unsigned int arg1 ;
1792	>	std::string *arg2 = 0 ;
1793	>	std::vector<std::string > *result;
1794	>	std::string temp2 ;
1795		PyObject * obj0 = 0 ;
1796		PyObject * obj1 = 0 ;
1797
1798	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
1799	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
1800	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
1801	<	if (arg2 == NULL) {
1802	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
1798	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1799	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1800	>	if (PyErr_Occurred()) SWIG_fail;
1801	>	{
1802	>	if (PyString_Check(obj1)) {
1803	>	temp2 = std::string(PyString_AsString(obj1));
1804	>	arg2 = &temp2;
1805	>	}else {
1806	>	SWIG_exception(SWIG_TypeError, "string expected");
1807	>	}
1808		}
1809		{
1810		try {
1811	<	result = (PyObject )BossSession_show(arg1,arg2);
1811	>	result = (std::vector<std::string > )new std::vector<std::string >(arg1,(std::string const &)arg2);
1812
1813	+	}catch (const BossSchedFailure & e) {
1814	+	PyErr_SetString ( SchedulerError, e.what() );
1815	+	return NULL;
1816		}catch (const std::exception& e) {
1817	<	SWIG_exception(SWIG_RuntimeError, e.what());
1817	>	PyErr_SetString ( BossError, e.what() );
1818	>	return NULL;
1819		}
1820		}
1821	<	resultobj = result;
1821	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1822		return resultobj;
1823		fail:
1824		return NULL;
1825		}
1826
1827
1828	<	static PyObject _wrap_BossSession_showCHTools__SWIG_1(PyObject self, PyObject *args) {
1828	>	static PyObject _wrap_new_vector_string__SWIG_2(PyObject self, PyObject *args) {
1829		PyObject *resultobj;
1830	<	BossSession arg1 = (BossSession ) 0 ;
1831	<	PyObject *result;
1830	>	std::vector<std::string > *arg1 = 0 ;
1831	>	std::vector<std::string > *result;
1832	>	std::vector<std::string > temp1 ;
1833	>	std::vector<std::string > *v1 ;
1834		PyObject * obj0 = 0 ;
1835
1836	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
1837	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
1836	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1837	>	{
1838	>	if (PyTuple_Check(obj0) \|\| PyList_Check(obj0)) {
1839	>	unsigned int size = (PyTuple_Check(obj0) ?
1840	>	PyTuple_Size(obj0) :
1841	>	PyList_Size(obj0));
1842	>	temp1 = std::vector<std::string >(size);
1843	>	arg1 = &temp1;
1844	>	for (unsigned int i=0; i<size; i++) {
1845	>	PyObject* o = PySequence_GetItem(obj0,i);
1846	>	if (PyString_Check(o)) {
1847	>	temp1[i] = (std::string)(\
1848	>	SwigString_AsString(o));
1849	>	Py_DECREF(o);
1850	>	}else {
1851	>	Py_DECREF(o);
1852	>	PyErr_SetString(PyExc_TypeError,
1853	>	"vector<""std::string""> expected");
1854	>	SWIG_fail;
1855	>	}
1856	>	}
1857	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1858	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1859	>	arg1 = v1;
1860	>	}else {
1861	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1862	>	SWIG_fail;
1863	>	}
1864	>	}
1865		{
1866		try {
1867	<	result = (PyObject *)BossSession_showCHTools__SWIG_1(arg1);
1867	>	result = (std::vector<std::string > )new std::vector<std::string >((std::vector<std::string > const &)arg1);
1868
1869	+	}catch (const BossSchedFailure & e) {
1870	+	PyErr_SetString ( SchedulerError, e.what() );
1871	+	return NULL;
1872		}catch (const std::exception& e) {
1873	<	SWIG_exception(SWIG_RuntimeError, e.what());
1873	>	PyErr_SetString ( BossError, e.what() );
1874	>	return NULL;
1875		}
1876		}
1877	<	resultobj = result;
1877	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1878		return resultobj;
1879		fail:
1880		return NULL;
1881		}
1882
1883
1884	<	static PyObject _wrap_BossSession_showCHTools(PyObject self, PyObject *args) {
1884	>	static PyObject _wrap_new_vector_string(PyObject self, PyObject *args) {
1885		int argc;
1886	<	PyObject *argv[2];
1886	>	PyObject *argv[3];
1887		int ii;
1888
1889		argc = PyObject_Length(args);
1890	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1890	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1891		argv[ii] = PyTuple_GetItem(args,ii);
1892		}
1893	+	if ((argc >= 0) && (argc <= 1)) {
1894	+	int _v;
1895	+	if (argc <= 0) {
1896	+	return _wrap_new_vector_string__SWIG_0(self,args);
1897	+	}
1898	+	{
1899	+	_v = (PyInt_Check(argv[0]) \|\| PyLong_Check(argv[0])) ? 1 : 0;
1900	+	}
1901	+	if (_v) {
1902	+	return _wrap_new_vector_string__SWIG_0(self,args);
1903	+	}
1904	+	}
1905		if (argc == 1) {
1906		int _v;
1907		{
1908	<	void *ptr;
1909	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1910	<	_v = 0;
1911	<	PyErr_Clear();
1908	>	/* native sequence? */
1909	>	if (PyTuple_Check(argv[0]) \|\| PyList_Check(argv[0])) {
1910	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1911	>	PyTuple_Size(argv[0]) :
1912	>	PyList_Size(argv[0]));
1913	>	if (size == 0) {
1914	>	/* an empty sequence can be of any type */
1915	>	_v = 1;
1916	>	}else {
1917	>	/* check the first element only */
1918	>	PyObject* o = PySequence_GetItem(argv[0],0);
1919	>	if (PyString_Check(o))
1920	>	_v = 1;
1921	>	else
1922	>	_v = 0;
1923	>	Py_DECREF(o);
1924	>	}
1925		}else {
1926	+	/* wrapped vector? */
1927	+	std::vector<std::string >* v;
1928	+	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1929	+	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1930		_v = 1;
1931	+	else
1932	+	_v = 0;
1933		}
1934		}
1935		if (_v) {
1936	<	return _wrap_BossSession_showCHTools__SWIG_1(self,args);
1936	>	return _wrap_new_vector_string__SWIG_2(self,args);
1937	>	}
1938	>	}
1939	>	if (argc == 2) {
1940	>	int _v;
1941	>	{
1942	>	_v = (PyInt_Check(argv[0]) \|\| PyLong_Check(argv[0])) ? 1 : 0;
1943	>	}
1944	>	if (_v) {
1945	>	{
1946	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1947	>	}
1948	>	if (_v) {
1949	>	return _wrap_new_vector_string__SWIG_1(self,args);
1950	>	}
1951		}
1952		}
1953
1954	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showCHTools'");
1954	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1955		return NULL;
1956		}
1957
1958
1959	<	static PyObject _wrap_BossSession_showProgramTypes__SWIG_1(PyObject self, PyObject *args) {
1959	>	static PyObject _wrap_vector_string___len__(PyObject self, PyObject *args) {
1960		PyObject *resultobj;
1961	<	BossSession arg1 = (BossSession ) 0 ;
1962	<	PyObject *result;
1961	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
1962	>	unsigned int result;
1963	>	std::vector<std::string > temp1 ;
1964	>	std::vector<std::string > *v1 ;
1965		PyObject * obj0 = 0 ;
1966
1967	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
1968	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
1967	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1968	>	{
1969	>	if (PyTuple_Check(obj0) \|\| PyList_Check(obj0)) {
1970	>	unsigned int size = (PyTuple_Check(obj0) ?
1971	>	PyTuple_Size(obj0) :
1972	>	PyList_Size(obj0));
1973	>	temp1 = std::vector<std::string >(size);
1974	>	arg1 = &temp1;
1975	>	for (unsigned int i=0; i<size; i++) {
1976	>	PyObject* o = PySequence_GetItem(obj0,i);
1977	>	if (PyString_Check(o)) {
1978	>	temp1[i] = (std::string)(\
1979	>	SwigString_AsString(o));
1980	>	Py_DECREF(o);
1981	>	}else {
1982	>	Py_DECREF(o);
1983	>	PyErr_SetString(PyExc_TypeError,
1984	>	"vector<""std::string""> expected");
1985	>	SWIG_fail;
1986	>	}
1987	>	}
1988	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1989	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1990	>	arg1 = v1;
1991	>	}else {
1992	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1993	>	SWIG_fail;
1994	>	}
1995	>	}
1996		{
1997		try {
1998	<	result = (PyObject *)BossSession_showProgramTypes__SWIG_1(arg1);
1998	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1999
2000	+	}catch (const BossSchedFailure & e) {
2001	+	PyErr_SetString ( SchedulerError, e.what() );
2002	+	return NULL;
2003		}catch (const std::exception& e) {
2004	<	SWIG_exception(SWIG_RuntimeError, e.what());
2004	>	PyErr_SetString ( BossError, e.what() );
2005	>	return NULL;
2006		}
2007		}
2008	<	resultobj = result;
2008	>	resultobj = PyInt_FromLong((long)result);
2009		return resultobj;
2010		fail:
2011		return NULL;
2012		}
2013
2014
2015	<	static PyObject _wrap_BossSession_showProgramTypes(PyObject self, PyObject *args) {
2016	<	int argc;
2017	<	PyObject *argv[2];
2018	<	int ii;
2015	>	static PyObject _wrap_vector_string___nonzero__(PyObject self, PyObject *args) {
2016	>	PyObject *resultobj;
2017	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2018	>	bool result;
2019	>	std::vector<std::string > temp1 ;
2020	>	std::vector<std::string > *v1 ;
2021	>	PyObject * obj0 = 0 ;
2022
2023	<	argc = PyObject_Length(args);
2024	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2025	<	argv[ii] = PyTuple_GetItem(args,ii);
2026	<	}
2027	<	if (argc == 1) {
2028	<	int _v;
2029	<	{
2030	<	void *ptr;
2031	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2032	<	_v = 0;
2033	<	PyErr_Clear();
2034	<	}else {
2035	<	_v = 1;
2023	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
2024	>	{
2025	>	if (PyTuple_Check(obj0) \|\| PyList_Check(obj0)) {
2026	>	unsigned int size = (PyTuple_Check(obj0) ?
2027	>	PyTuple_Size(obj0) :
2028	>	PyList_Size(obj0));
2029	>	temp1 = std::vector<std::string >(size);
2030	>	arg1 = &temp1;
2031	>	for (unsigned int i=0; i<size; i++) {
2032	>	PyObject* o = PySequence_GetItem(obj0,i);
2033	>	if (PyString_Check(o)) {
2034	>	temp1[i] = (std::string)(\
2035	>	SwigString_AsString(o));
2036	>	Py_DECREF(o);
2037	>	}else {
2038	>	Py_DECREF(o);
2039	>	PyErr_SetString(PyExc_TypeError,
2040	>	"vector<""std::string""> expected");
2041	>	SWIG_fail;
2042	>	}
2043		}
2044	+	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
2045	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2046	+	arg1 = v1;
2047	+	}else {
2048	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2049	+	SWIG_fail;
2050		}
2051	<	if (_v) {
2052	<	return _wrap_BossSession_showProgramTypes__SWIG_1(self,args);
2051	>	}
2052	>	{
2053	>	try {
2054	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
2055	>
2056	>	}catch (const BossSchedFailure & e) {
2057	>	PyErr_SetString ( SchedulerError, e.what() );
2058	>	return NULL;
2059	>	}catch (const std::exception& e) {
2060	>	PyErr_SetString ( BossError, e.what() );
2061	>	return NULL;
2062		}
2063		}
2064	<
2065	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showProgramTypes'");
2064	>	resultobj = PyInt_FromLong((long)result);
2065	>	return resultobj;
2066	>	fail:
2067		return NULL;
2068		}
2069
2070
2071	<	static PyObject _wrap_BossSession_showRTMon__SWIG_1(PyObject self, PyObject *args) {
2071	>	static PyObject _wrap_vector_string_clear(PyObject self, PyObject *args) {
2072		PyObject *resultobj;
2073	<	BossSession arg1 = (BossSession ) 0 ;
1682	<	PyObject *result;
2073	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2074		PyObject * obj0 = 0 ;
2075
2076	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2077	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2076	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
2077	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2078		{
2079		try {
2080	<	result = (PyObject *)BossSession_showRTMon__SWIG_1(arg1);
2080	>	(arg1)->clear();
2081
2082	+	}catch (const BossSchedFailure & e) {
2083	+	PyErr_SetString ( SchedulerError, e.what() );
2084	+	return NULL;
2085		}catch (const std::exception& e) {
2086	<	SWIG_exception(SWIG_RuntimeError, e.what());
2086	>	PyErr_SetString ( BossError, e.what() );
2087	>	return NULL;
2088		}
2089		}
2090	<	resultobj = result;
2090	>	Py_INCREF(Py_None); resultobj = Py_None;
2091		return resultobj;
2092		fail:
2093		return NULL;
2094		}
2095
2096
2097	<	static PyObject _wrap_BossSession_showRTMon(PyObject self, PyObject *args) {
2098	<	int argc;
2099	<	PyObject *argv[2];
2100	<	int ii;
2097	>	static PyObject _wrap_vector_string_append(PyObject self, PyObject *args) {
2098	>	PyObject *resultobj;
2099	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2100	>	std::string arg2 ;
2101	>	PyObject * obj0 = 0 ;
2102	>	PyObject * obj1 = 0 ;
2103
2104	<	argc = PyObject_Length(args);
2105	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2106	<	argv[ii] = PyTuple_GetItem(args,ii);
2104	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
2105	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2106	>	{
2107	>	if (PyString_Check(obj1))
2108	>	arg2 = std::string(PyString_AsString(obj1));
2109	>	else
2110	>	SWIG_exception(SWIG_TypeError, "string expected");
2111		}
2112	<	if (argc == 1) {
2113	<	int _v;
2114	<	{
2115	<	void *ptr;
2116	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2117	<	_v = 0;
2118	<	PyErr_Clear();
2119	<	}else {
2120	<	_v = 1;
2121	<	}
2112	>	{
2113	>	try {
2114	>	(arg1)->push_back(arg2);
2115	>
2116	>	}catch (const BossSchedFailure & e) {
2117	>	PyErr_SetString ( SchedulerError, e.what() );
2118	>	return NULL;
2119	>	}catch (const std::exception& e) {
2120	>	PyErr_SetString ( BossError, e.what() );
2121	>	return NULL;
2122		}
2123	<	if (_v) {
2124	<	return _wrap_BossSession_showRTMon__SWIG_1(self,args);
2123	>	}
2124	>	Py_INCREF(Py_None); resultobj = Py_None;
2125	>	return resultobj;
2126	>	fail:
2127	>	return NULL;
2128	>	}
2129	>
2130	>
2131	>	static PyObject _wrap_vector_string_pop(PyObject self, PyObject *args) {
2132	>	PyObject *resultobj;
2133	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2134	>	std::string result;
2135	>	PyObject * obj0 = 0 ;
2136	>
2137	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
2138	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2139	>	{
2140	>	try {
2141	>	result = std_vectorlstd_string_g_pop___(arg1);
2142	>
2143	>	}catch (std::out_of_range& e) {
2144	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2145		}
2146		}
2147	+	{
2148	+	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2149	+	}
2150	+	return resultobj;
2151	+	fail:
2152	+	return NULL;
2153	+	}
2154	+
2155	+
2156	+	static PyObject _wrap_vector_string___getitem__(PyObject self, PyObject *args) {
2157	+	PyObject *resultobj;
2158	+	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2159	+	int arg2 ;
2160	+	std::string result;
2161	+	PyObject * obj0 = 0 ;
2162
2163	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showRTMon'");
2163	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2164	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2165	>	{
2166	>	try {
2167	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2168	>
2169	>	}catch (std::out_of_range& e) {
2170	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2171	>	}
2172	>	}
2173	>	{
2174	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2175	>	}
2176	>	return resultobj;
2177	>	fail:
2178		return NULL;
2179		}
2180
2181
2182	<	static PyObject _wrap_BossSession_showSchedulers__SWIG_1(PyObject self, PyObject *args) {
2182	>	static PyObject _wrap_vector_string___getslice__(PyObject self, PyObject *args) {
2183		PyObject *resultobj;
2184	<	BossSession arg1 = (BossSession ) 0 ;
2185	<	PyObject *result;
2184	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2185	>	int arg2 ;
2186	>	int arg3 ;
2187	>	std::vector<std::string > result;
2188		PyObject * obj0 = 0 ;
2189
2190	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2191	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2190	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2191	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2192		{
2193		try {
2194	<	result = (PyObject *)BossSession_showSchedulers__SWIG_1(arg1);
2194	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2195
2196	+	}catch (const BossSchedFailure & e) {
2197	+	PyErr_SetString ( SchedulerError, e.what() );
2198	+	return NULL;
2199		}catch (const std::exception& e) {
2200	<	SWIG_exception(SWIG_RuntimeError, e.what());
2200	>	PyErr_SetString ( BossError, e.what() );
2201	>	return NULL;
2202		}
2203		}
2204	<	resultobj = result;
2204	>	{
2205	>	resultobj = PyTuple_New((&result)->size());
2206	>	for (unsigned int i=0; i<(&result)->size(); i++)
2207	>	PyTuple_SetItem(resultobj,i,
2208	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2209	>	}
2210		return resultobj;
2211		fail:
2212		return NULL;
2213		}
2214
2215
2216	<	static PyObject _wrap_BossSession_showSchedulers(PyObject self, PyObject *args) {
2217	<	int argc;
2218	<	PyObject *argv[2];
2219	<	int ii;
2216	>	static PyObject _wrap_vector_string___setitem__(PyObject self, PyObject *args) {
2217	>	PyObject *resultobj;
2218	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2219	>	int arg2 ;
2220	>	std::string arg3 ;
2221	>	PyObject * obj0 = 0 ;
2222	>	PyObject * obj2 = 0 ;
2223
2224	<	argc = PyObject_Length(args);
2225	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2226	<	argv[ii] = PyTuple_GetItem(args,ii);
2224	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2225	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2226	>	{
2227	>	if (PyString_Check(obj2))
2228	>	arg3 = std::string(PyString_AsString(obj2));
2229	>	else
2230	>	SWIG_exception(SWIG_TypeError, "string expected");
2231		}
2232	<	if (argc == 1) {
2233	<	int _v;
2234	<	{
2235	<	void *ptr;
2236	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2237	<	_v = 0;
1770	<	PyErr_Clear();
1771	<	}else {
1772	<	_v = 1;
1773	<	}
1774	<	}
1775	<	if (_v) {
1776	<	return _wrap_BossSession_showSchedulers__SWIG_1(self,args);
2232	>	{
2233	>	try {
2234	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2235	>
2236	>	}catch (std::out_of_range& e) {
2237	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2238		}
2239		}
2240	<
2241	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showSchedulers'");
2240	>	Py_INCREF(Py_None); resultobj = Py_None;
2241	>	return resultobj;
2242	>	fail:
2243		return NULL;
2244		}
2245
2246
2247	<	static PyObject _wrap_BossSession_listMatch__SWIG_1(PyObject self, PyObject *args) {
2247	>	static PyObject _wrap_vector_string___setslice__(PyObject self, PyObject *args) {
2248		PyObject *resultobj;
2249	<	BossSession arg1 = (BossSession ) 0 ;
2250	<	std::string *arg2 = 0 ;
2251	<	std::string *arg3 = 0 ;
2252	<	std::string const &arg4_defvalue = "" ;
2253	<	std::string arg4 = (std::string ) &arg4_defvalue ;
2254	<	std::string const &arg5_defvalue = "" ;
1793	<	std::string arg5 = (std::string ) &arg5_defvalue ;
1794	<	bool arg6 = (bool) false ;
1795	<	PyObject *result;
1796	<	std::string temp2 ;
1797	<	std::string temp3 ;
1798	<	std::string temp4 ;
1799	<	std::string temp5 ;
2249	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2250	>	int arg2 ;
2251	>	int arg3 ;
2252	>	std::vector<std::string > *arg4 = 0 ;
2253	>	std::vector<std::string > temp4 ;
2254	>	std::vector<std::string > *v4 ;
2255		PyObject * obj0 = 0 ;
1801	–	PyObject * obj1 = 0 ;
1802	–	PyObject * obj2 = 0 ;
2256		PyObject * obj3 = 0 ;
1804	–	PyObject * obj4 = 0 ;
1805	–	PyObject * obj5 = 0 ;
2257
2258	<	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2259	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2258	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2259	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2260		{
2261	<	if (PyString_Check(obj1)) {
2262	<	temp2 = std::string(PyString_AsString(obj1));
2263	<	arg2 = &temp2;
2261	>	if (PyTuple_Check(obj3) \|\| PyList_Check(obj3)) {
2262	>	unsigned int size = (PyTuple_Check(obj3) ?
2263	>	PyTuple_Size(obj3) :
2264	>	PyList_Size(obj3));
2265	>	temp4 = std::vector<std::string >(size);
2266	>	arg4 = &temp4;
2267	>	for (unsigned int i=0; i<size; i++) {
2268	>	PyObject* o = PySequence_GetItem(obj3,i);
2269	>	if (PyString_Check(o)) {
2270	>	temp4[i] = (std::string)(\
2271	>	SwigString_AsString(o));
2272	>	Py_DECREF(o);
2273	>	}else {
2274	>	Py_DECREF(o);
2275	>	PyErr_SetString(PyExc_TypeError,
2276	>	"vector<""std::string""> expected");
2277	>	SWIG_fail;
2278	>	}
2279	>	}
2280	>	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2281	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2282	>	arg4 = v4;
2283		}else {
2284	<	SWIG_exception(SWIG_TypeError, "string expected");
2284	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2285	>	SWIG_fail;
2286		}
2287		}
2288		{
2289	<	if (PyString_Check(obj2)) {
2290	<	temp3 = std::string(PyString_AsString(obj2));
2291	<	arg3 = &temp3;
2292	<	}else {
2293	<	SWIG_exception(SWIG_TypeError, "string expected");
2294	<	}
2295	<	}
2296	<	if (obj3) {
2297	<	{
1827	<	if (PyString_Check(obj3)) {
1828	<	temp4 = std::string(PyString_AsString(obj3));
1829	<	arg4 = &temp4;
1830	<	}else {
1831	<	SWIG_exception(SWIG_TypeError, "string expected");
1832	<	}
2289	>	try {
2290	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2291	>
2292	>	}catch (const BossSchedFailure & e) {
2293	>	PyErr_SetString ( SchedulerError, e.what() );
2294	>	return NULL;
2295	>	}catch (const std::exception& e) {
2296	>	PyErr_SetString ( BossError, e.what() );
2297	>	return NULL;
2298		}
2299		}
2300	<	if (obj4) {
2301	<	{
2302	<	if (PyString_Check(obj4)) {
2303	<	temp5 = std::string(PyString_AsString(obj4));
2304	<	arg5 = &temp5;
2305	<	}else {
2306	<	SWIG_exception(SWIG_TypeError, "string expected");
2307	<	}
2300	>	Py_INCREF(Py_None); resultobj = Py_None;
2301	>	return resultobj;
2302	>	fail:
2303	>	return NULL;
2304	>	}
2305	>
2306	>
2307	>	static PyObject _wrap_vector_string___delitem__(PyObject self, PyObject *args) {
2308	>	PyObject *resultobj;
2309	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2310	>	int arg2 ;
2311	>	PyObject * obj0 = 0 ;
2312	>
2313	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2314	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2315	>	{
2316	>	try {
2317	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2318	>
2319	>	}catch (std::out_of_range& e) {
2320	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2321		}
2322		}
2323	<	if (obj5) {
2324	<	arg6 = PyInt_AsLong(obj5) ? true : false;
2325	<	if (PyErr_Occurred()) SWIG_fail;
2326	<	}
2323	>	Py_INCREF(Py_None); resultobj = Py_None;
2324	>	return resultobj;
2325	>	fail:
2326	>	return NULL;
2327	>	}
2328	>
2329	>
2330	>	static PyObject _wrap_vector_string___delslice__(PyObject self, PyObject *args) {
2331	>	PyObject *resultobj;
2332	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2333	>	int arg2 ;
2334	>	int arg3 ;
2335	>	PyObject * obj0 = 0 ;
2336	>
2337	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2338	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2339		{
2340		try {
2341	<	result = (PyObject )BossSession_listMatch__SWIG_1(arg1,(std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6);
2341	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2342
2343	+	}catch (const BossSchedFailure & e) {
2344	+	PyErr_SetString ( SchedulerError, e.what() );
2345	+	return NULL;
2346		}catch (const std::exception& e) {
2347	<	SWIG_exception(SWIG_RuntimeError, e.what());
2347	>	PyErr_SetString ( BossError, e.what() );
2348	>	return NULL;
2349		}
2350		}
2351	<	resultobj = result;
2351	>	Py_INCREF(Py_None); resultobj = Py_None;
2352		return resultobj;
2353		fail:
2354		return NULL;
2355		}
2356
2357
2358	<	static PyObject _wrap_BossSession_listMatch(PyObject self, PyObject *args) {
2359	<	int argc;
2360	<	PyObject *argv[7];
2361	<	int ii;
2358	>	static PyObject _wrap_delete_vector_string(PyObject self, PyObject *args) {
2359	>	PyObject *resultobj;
2360	>	std::vector<std::string > arg1 = (std::vector<std::string > ) 0 ;
2361	>	PyObject * obj0 = 0 ;
2362
2363	<	argc = PyObject_Length(args);
2364	<	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
2365	<	argv[ii] = PyTuple_GetItem(args,ii);
2366	<	}
2367	<	if ((argc >= 3) && (argc <= 6)) {
2368	<	int _v;
2369	<	{
2370	<	void *ptr;
2371	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2372	<	_v = 0;
2373	<	PyErr_Clear();
2374	<	}else {
1881	<	_v = 1;
1882	<	}
1883	<	}
1884	<	if (_v) {
1885	<	{
1886	<	_v = PyString_Check(argv[1]) ? 1 : 0;
1887	<	}
1888	<	if (_v) {
1889	<	{
1890	<	_v = PyString_Check(argv[2]) ? 1 : 0;
1891	<	}
1892	<	if (_v) {
1893	<	if (argc <= 3) {
1894	<	return _wrap_BossSession_listMatch__SWIG_1(self,args);
1895	<	}
1896	<	{
1897	<	_v = PyString_Check(argv[3]) ? 1 : 0;
1898	<	}
1899	<	if (_v) {
1900	<	if (argc <= 4) {
1901	<	return _wrap_BossSession_listMatch__SWIG_1(self,args);
1902	<	}
1903	<	{
1904	<	_v = PyString_Check(argv[4]) ? 1 : 0;
1905	<	}
1906	<	if (_v) {
1907	<	if (argc <= 5) {
1908	<	return _wrap_BossSession_listMatch__SWIG_1(self,args);
1909	<	}
1910	<	{
1911	<	_v = (PyInt_Check(argv[5]) \|\| PyLong_Check(argv[5])) ? 1 : 0;
1912	<	}
1913	<	if (_v) {
1914	<	return _wrap_BossSession_listMatch__SWIG_1(self,args);
1915	<	}
1916	<	}
1917	<	}
1918	<	}
1919	<	}
2363	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2364	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2365	>	{
2366	>	try {
2367	>	delete arg1;
2368	>
2369	>	}catch (const BossSchedFailure & e) {
2370	>	PyErr_SetString ( SchedulerError, e.what() );
2371	>	return NULL;
2372	>	}catch (const std::exception& e) {
2373	>	PyErr_SetString ( BossError, e.what() );
2374	>	return NULL;
2375		}
2376		}
2377	<
2378	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_listMatch'");
2377	>	Py_INCREF(Py_None); resultobj = Py_None;
2378	>	return resultobj;
2379	>	fail:
2380		return NULL;
2381		}
2382
2383
2384	<	static PyObject _wrap_BossSession_queryTasks(PyObject self, PyObject *args) {
2384	>	static PyObject * vector_string_swigregister(PyObject self, PyObject args) {
2385	>	PyObject *obj;
2386	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2387	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2388	>	Py_INCREF(obj);
2389	>	return Py_BuildValue((char *)"");
2390	>	}
2391	>	static PyObject _wrap_new_BossSession(PyObject self, PyObject *args) {
2392		PyObject *resultobj;
2393	<	BossSession arg1 = (BossSession ) 0 ;
2394	<	int arg2 = (int) SCHEDULED ;
2395	<	std::string const &arg3_defvalue = "all" ;
2396	<	std::string arg3 = (std::string ) &arg3_defvalue ;
2397	<	std::string const &arg4_defvalue = "all" ;
1935	<	std::string arg4 = (std::string ) &arg4_defvalue ;
1936	<	std::string const &arg5_defvalue = "" ;
1937	<	std::string arg5 = (std::string ) &arg5_defvalue ;
1938	<	std::string arg6 = (std::string) "" ;
1939	<	std::string arg7 = (std::string) "" ;
1940	<	std::string arg8 = (std::string) "" ;
1941	<	std::string arg9 = (std::string) "" ;
1942	<	bool arg10 = (bool) false ;
1943	<	PyObject *result;
1944	<	std::string temp3 ;
1945	<	std::string temp4 ;
1946	<	std::string temp5 ;
2393	>	std::string arg1 = (std::string) "" ;
2394	>	std::string arg2 = (std::string) "2" ;
2395	>	std::string arg3 = (std::string) "" ;
2396	>	std::string arg4 = (std::string) "" ;
2397	>	BossSession *result;
2398		PyObject * obj0 = 0 ;
2399	+	PyObject * obj1 = 0 ;
2400		PyObject * obj2 = 0 ;
2401		PyObject * obj3 = 0 ;
1950	–	PyObject * obj4 = 0 ;
1951	–	PyObject * obj5 = 0 ;
1952	–	PyObject * obj6 = 0 ;
1953	–	PyObject * obj7 = 0 ;
1954	–	PyObject * obj8 = 0 ;
1955	–	PyObject * obj9 = 0 ;
2402
2403	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2404	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
1959	<	if (obj2) {
1960	<	{
1961	<	if (PyString_Check(obj2)) {
1962	<	temp3 = std::string(PyString_AsString(obj2));
1963	<	arg3 = &temp3;
1964	<	}else {
1965	<	SWIG_exception(SWIG_TypeError, "string expected");
1966	<	}
1967	<	}
1968	<	}
1969	<	if (obj3) {
1970	<	{
1971	<	if (PyString_Check(obj3)) {
1972	<	temp4 = std::string(PyString_AsString(obj3));
1973	<	arg4 = &temp4;
1974	<	}else {
1975	<	SWIG_exception(SWIG_TypeError, "string expected");
1976	<	}
1977	<	}
1978	<	}
1979	<	if (obj4) {
1980	<	{
1981	<	if (PyString_Check(obj4)) {
1982	<	temp5 = std::string(PyString_AsString(obj4));
1983	<	arg5 = &temp5;
1984	<	}else {
1985	<	SWIG_exception(SWIG_TypeError, "string expected");
1986	<	}
1987	<	}
1988	<	}
1989	<	if (obj5) {
2403	>	if(!PyArg_ParseTuple(args,(char *)"\|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2404	>	if (obj0) {
2405		{
2406	<	if (PyString_Check(obj5))
2407	<	arg6 = std::string(PyString_AsString(obj5));
2406	>	if (PyString_Check(obj0))
2407	>	arg1 = std::string(PyString_AsString(obj0));
2408		else
2409		SWIG_exception(SWIG_TypeError, "string expected");
2410		}
2411		}
2412	<	if (obj6) {
2412	>	if (obj1) {
2413		{
2414	<	if (PyString_Check(obj6))
2415	<	arg7 = std::string(PyString_AsString(obj6));
2414	>	if (PyString_Check(obj1))
2415	>	arg2 = std::string(PyString_AsString(obj1));
2416		else
2417		SWIG_exception(SWIG_TypeError, "string expected");
2418		}
2419		}
2420	<	if (obj7) {
2420	>	if (obj2) {
2421		{
2422	<	if (PyString_Check(obj7))
2423	<	arg8 = std::string(PyString_AsString(obj7));
2422	>	if (PyString_Check(obj2))
2423	>	arg3 = std::string(PyString_AsString(obj2));
2424		else
2425		SWIG_exception(SWIG_TypeError, "string expected");
2426		}
2427		}
2428	<	if (obj8) {
2428	>	if (obj3) {
2429		{
2430	<	if (PyString_Check(obj8))
2431	<	arg9 = std::string(PyString_AsString(obj8));
2430	>	if (PyString_Check(obj3))
2431	>	arg4 = std::string(PyString_AsString(obj3));
2432		else
2433		SWIG_exception(SWIG_TypeError, "string expected");
2434		}
2435		}
2021	–	if (obj9) {
2022	–	arg10 = PyInt_AsLong(obj9) ? true : false;
2023	–	if (PyErr_Occurred()) SWIG_fail;
2024	–	}
2436		{
2437		try {
2438	<	result = (PyObject )BossSession_queryTasks(arg1,arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5,arg6,arg7,arg8,arg9,arg10);
2438	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2439
2440	+	}catch (const BossSchedFailure & e) {
2441	+	PyErr_SetString ( SchedulerError, e.what() );
2442	+	return NULL;
2443		}catch (const std::exception& e) {
2444	<	SWIG_exception(SWIG_RuntimeError, e.what());
2444	>	PyErr_SetString ( BossError, e.what() );
2445	>	return NULL;
2446		}
2447		}
2448	<	resultobj = result;
2448	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2449		return resultobj;
2450		fail:
2451		return NULL;
2452		}
2453
2454
2455	<	static PyObject _wrap_new_BossSession(PyObject self, PyObject *args) {
2455	>	static PyObject _wrap_delete_BossSession(PyObject self, PyObject *args) {
2456		PyObject *resultobj;
2457	<	std::string arg1 = (std::string) "" ;
2043	<	BossSession *result;
2457	>	BossSession arg1 = (BossSession ) 0 ;
2458		PyObject * obj0 = 0 ;
2459
2460	<	if(!PyArg_ParseTuple(args,(char *)"\|O:new_BossSession",&obj0)) goto fail;
2461	<	if (obj0) {
2048	<	{
2049	<	if (PyString_Check(obj0))
2050	<	arg1 = std::string(PyString_AsString(obj0));
2051	<	else
2052	<	SWIG_exception(SWIG_TypeError, "string expected");
2053	<	}
2054	<	}
2460	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2461	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2462		{
2463		try {
2464	<	result = (BossSession *)new BossSession(arg1);
2464	>	delete arg1;
2465
2466	+	}catch (const BossSchedFailure & e) {
2467	+	PyErr_SetString ( SchedulerError, e.what() );
2468	+	return NULL;
2469		}catch (const std::exception& e) {
2470	<	SWIG_exception(SWIG_RuntimeError, e.what());
2470	>	PyErr_SetString ( BossError, e.what() );
2471	>	return NULL;
2472		}
2473		}
2474	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2474	>	Py_INCREF(Py_None); resultobj = Py_None;
2475		return resultobj;
2476		fail:
2477		return NULL;
2478		}
2479
2480
2481	<	static PyObject _wrap_delete_BossSession(PyObject self, PyObject *args) {
2481	>	static PyObject _wrap_BossSession_resetDB(PyObject self, PyObject *args) {
2482		PyObject *resultobj;
2483		BossSession arg1 = (BossSession ) 0 ;
2484		PyObject * obj0 = 0 ;
2485
2486	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2486	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2487		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2488		{
2489		try {
2490	<	delete arg1;
2490	>	(arg1)->resetDB();
2491
2492	+	}catch (const BossSchedFailure & e) {
2493	+	PyErr_SetString ( SchedulerError, e.what() );
2494	+	return NULL;
2495		}catch (const std::exception& e) {
2496	<	SWIG_exception(SWIG_RuntimeError, e.what());
2496	>	PyErr_SetString ( BossError, e.what() );
2497	>	return NULL;
2498		}
2499		}
2500		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2100 \| Line 2515 \| *static PyObject _wrap_BossSession_clear**
2515		try {
2516		(arg1)->clear();
2517
2518	+	}catch (const BossSchedFailure & e) {
2519	+	PyErr_SetString ( SchedulerError, e.what() );
2520	+	return NULL;
2521		}catch (const std::exception& e) {
2522	<	SWIG_exception(SWIG_RuntimeError, e.what());
2522	>	PyErr_SetString ( BossError, e.what() );
2523	>	return NULL;
2524		}
2525		}
2526		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2137 \| Line 2556 \| *static PyObject _wrap_BossSession_makeB**
2556		try {
2557		result = (BossTask )(arg1)->makeBossTask((std::string const &)arg2);
2558
2559	+	}catch (const BossSchedFailure & e) {
2560	+	PyErr_SetString ( SchedulerError, e.what() );
2561	+	return NULL;
2562		}catch (const std::exception& e) {
2563	<	SWIG_exception(SWIG_RuntimeError, e.what());
2563	>	PyErr_SetString ( BossError, e.what() );
2564	>	return NULL;
2565		}
2566		}
2567		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
#	Line 2162 \| Line 2585 \| *static PyObject _wrap_BossSession_destr**
2585		try {
2586		(arg1)->destroyBossTask(arg2);
2587
2588	+	}catch (const BossSchedFailure & e) {
2589	+	PyErr_SetString ( SchedulerError, e.what() );
2590	+	return NULL;
2591		}catch (const std::exception& e) {
2592	<	SWIG_exception(SWIG_RuntimeError, e.what());
2592	>	PyErr_SetString ( BossError, e.what() );
2593	>	return NULL;
2594		}
2595		}
2596		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2173 \| Line 2600 \| *static PyObject _wrap_BossSession_destr**
2600		}
2601
2602
2603	<	static PyObject _wrap_BossSession_showCHTools__SWIG_0(PyObject self, PyObject *args) {
2603	>	static PyObject _wrap_BossSession_showCHTools(PyObject self, PyObject *args) {
2604		PyObject *resultobj;
2605		BossSession arg1 = (BossSession ) 0 ;
2606	<	SwigValueWrapper< std::vector<std::string > > result;
2606	>	std::vector<std::string > result;
2607		PyObject * obj0 = 0 ;
2608
2609		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
#	Line 2185 \| Line 2612 \| *static PyObject _wrap_BossSession_showC**
2612		try {
2613		result = (arg1)->showCHTools();
2614
2615	+	}catch (const BossSchedFailure & e) {
2616	+	PyErr_SetString ( SchedulerError, e.what() );
2617	+	return NULL;
2618		}catch (const std::exception& e) {
2619	<	SWIG_exception(SWIG_RuntimeError, e.what());
2619	>	PyErr_SetString ( BossError, e.what() );
2620	>	return NULL;
2621		}
2622		}
2623		{
2624	<	std::vector<std::string > * resultptr;
2625	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2626	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2624	>	resultobj = PyTuple_New((&result)->size());
2625	>	for (unsigned int i=0; i<(&result)->size(); i++)
2626	>	PyTuple_SetItem(resultobj,i,
2627	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2628		}
2629		return resultobj;
2630		fail:
#	Line 2200 \| Line 2632 \| *static PyObject _wrap_BossSession_showC**
2632		}
2633
2634
2635	<	static PyObject _wrap_BossSession_showProgramTypes__SWIG_0(PyObject self, PyObject *args) {
2635	>	static PyObject _wrap_BossSession_showProgramTypes(PyObject self, PyObject *args) {
2636		PyObject *resultobj;
2637		BossSession arg1 = (BossSession ) 0 ;
2638	<	SwigValueWrapper< std::vector<std::string > > result;
2638	>	std::vector<std::string > result;
2639		PyObject * obj0 = 0 ;
2640
2641		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
#	Line 2212 \| Line 2644 \| *static PyObject _wrap_BossSession_showP**
2644		try {
2645		result = (arg1)->showProgramTypes();
2646
2647	+	}catch (const BossSchedFailure & e) {
2648	+	PyErr_SetString ( SchedulerError, e.what() );
2649	+	return NULL;
2650		}catch (const std::exception& e) {
2651	<	SWIG_exception(SWIG_RuntimeError, e.what());
2651	>	PyErr_SetString ( BossError, e.what() );
2652	>	return NULL;
2653		}
2654		}
2655		{
2656	<	std::vector<std::string > * resultptr;
2657	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2658	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2656	>	resultobj = PyTuple_New((&result)->size());
2657	>	for (unsigned int i=0; i<(&result)->size(); i++)
2658	>	PyTuple_SetItem(resultobj,i,
2659	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2660		}
2661		return resultobj;
2662		fail:
#	Line 2227 \| Line 2664 \| *static PyObject _wrap_BossSession_showP**
2664		}
2665
2666
2667	<	static PyObject _wrap_BossSession_showRTMon__SWIG_0(PyObject self, PyObject *args) {
2667	>	static PyObject _wrap_BossSession_showRTMon(PyObject self, PyObject *args) {
2668		PyObject *resultobj;
2669		BossSession arg1 = (BossSession ) 0 ;
2670	<	SwigValueWrapper< std::vector<std::string > > result;
2670	>	std::vector<std::string > result;
2671		PyObject * obj0 = 0 ;
2672
2673		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
#	Line 2239 \| Line 2676 \| *static PyObject _wrap_BossSession_showR**
2676		try {
2677		result = (arg1)->showRTMon();
2678
2679	+	}catch (const BossSchedFailure & e) {
2680	+	PyErr_SetString ( SchedulerError, e.what() );
2681	+	return NULL;
2682		}catch (const std::exception& e) {
2683	<	SWIG_exception(SWIG_RuntimeError, e.what());
2683	>	PyErr_SetString ( BossError, e.what() );
2684	>	return NULL;
2685		}
2686		}
2687		{
2688	<	std::vector<std::string > * resultptr;
2689	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2690	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2688	>	resultobj = PyTuple_New((&result)->size());
2689	>	for (unsigned int i=0; i<(&result)->size(); i++)
2690	>	PyTuple_SetItem(resultobj,i,
2691	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2692		}
2693		return resultobj;
2694		fail:
#	Line 2254 \| Line 2696 \| *static PyObject _wrap_BossSession_showR**
2696		}
2697
2698
2699	<	static PyObject _wrap_BossSession_showSchedulers__SWIG_0(PyObject self, PyObject *args) {
2699	>	static PyObject _wrap_BossSession_showSchedulers(PyObject self, PyObject *args) {
2700		PyObject *resultobj;
2701		BossSession arg1 = (BossSession ) 0 ;
2702	<	SwigValueWrapper< std::vector<std::string > > result;
2702	>	std::vector<std::string > result;
2703		PyObject * obj0 = 0 ;
2704
2705		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
#	Line 2266 \| Line 2708 \| *static PyObject _wrap_BossSession_showS**
2708		try {
2709		result = (arg1)->showSchedulers();
2710
2711	+	}catch (const BossSchedFailure & e) {
2712	+	PyErr_SetString ( SchedulerError, e.what() );
2713	+	return NULL;
2714		}catch (const std::exception& e) {
2715	<	SWIG_exception(SWIG_RuntimeError, e.what());
2715	>	PyErr_SetString ( BossError, e.what() );
2716	>	return NULL;
2717		}
2718		}
2719		{
2720	<	std::vector<std::string > * resultptr;
2721	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2722	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2720	>	resultobj = PyTuple_New((&result)->size());
2721	>	for (unsigned int i=0; i<(&result)->size(); i++)
2722	>	PyTuple_SetItem(resultobj,i,
2723	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2724		}
2725		return resultobj;
2726		fail:
#	Line 2293 \| Line 2740 \| *static PyObject _wrap_BossSession_defau**
2740		try {
2741		result = (arg1)->defaultCHTool();
2742
2743	+	}catch (const BossSchedFailure & e) {
2744	+	PyErr_SetString ( SchedulerError, e.what() );
2745	+	return NULL;
2746		}catch (const std::exception& e) {
2747	<	SWIG_exception(SWIG_RuntimeError, e.what());
2747	>	PyErr_SetString ( BossError, e.what() );
2748	>	return NULL;
2749		}
2750		}
2751		{
#	Line 2318 \| Line 2769 \| *static PyObject _wrap_BossSession_defau**
2769		try {
2770		result = (arg1)->defaultProgramType();
2771
2772	+	}catch (const BossSchedFailure & e) {
2773	+	PyErr_SetString ( SchedulerError, e.what() );
2774	+	return NULL;
2775		}catch (const std::exception& e) {
2776	<	SWIG_exception(SWIG_RuntimeError, e.what());
2776	>	PyErr_SetString ( BossError, e.what() );
2777	>	return NULL;
2778		}
2779		}
2780		{
#	Line 2343 \| Line 2798 \| *static PyObject _wrap_BossSession_defau**
2798		try {
2799		result = (arg1)->defaultRTMon();
2800
2801	+	}catch (const BossSchedFailure & e) {
2802	+	PyErr_SetString ( SchedulerError, e.what() );
2803	+	return NULL;
2804		}catch (const std::exception& e) {
2805	<	SWIG_exception(SWIG_RuntimeError, e.what());
2805	>	PyErr_SetString ( BossError, e.what() );
2806	>	return NULL;
2807		}
2808		}
2809		{
#	Line 2368 \| Line 2827 \| *static PyObject _wrap_BossSession_defau**
2827		try {
2828		result = (arg1)->defaultScheduler();
2829
2830	+	}catch (const BossSchedFailure & e) {
2831	+	PyErr_SetString ( SchedulerError, e.what() );
2832	+	return NULL;
2833		}catch (const std::exception& e) {
2834	<	SWIG_exception(SWIG_RuntimeError, e.what());
2834	>	PyErr_SetString ( BossError, e.what() );
2835	>	return NULL;
2836		}
2837		}
2838		{
#	Line 2393 \| Line 2856 \| *static PyObject _wrap_BossSession_versi**
2856		try {
2857		result = (arg1)->version();
2858
2859	+	}catch (const BossSchedFailure & e) {
2860	+	PyErr_SetString ( SchedulerError, e.what() );
2861	+	return NULL;
2862		}catch (const std::exception& e) {
2863	<	SWIG_exception(SWIG_RuntimeError, e.what());
2863	>	PyErr_SetString ( BossError, e.what() );
2864	>	return NULL;
2865		}
2866		}
2867		{
#	Line 2418 \| Line 2885 \| *static PyObject _wrap_BossSession_clien**
2885		try {
2886		result = (arg1)->clientID();
2887
2888	+	}catch (const BossSchedFailure & e) {
2889	+	PyErr_SetString ( SchedulerError, e.what() );
2890	+	return NULL;
2891		}catch (const std::exception& e) {
2892	<	SWIG_exception(SWIG_RuntimeError, e.what());
2892	>	PyErr_SetString ( BossError, e.what() );
2893	>	return NULL;
2894		}
2895		}
2896		{
#	Line 2449 \| Line 2920 \| *static PyObject _wrap_BossSession_showC**
2920		try {
2921		result = (int)(arg1)->showConfigs(arg2);
2922
2923	+	}catch (const BossSchedFailure & e) {
2924	+	PyErr_SetString ( SchedulerError, e.what() );
2925	+	return NULL;
2926		}catch (const std::exception& e) {
2927	<	SWIG_exception(SWIG_RuntimeError, e.what());
2927	>	PyErr_SetString ( BossError, e.what() );
2928	>	return NULL;
2929		}
2930		}
2931		resultobj = PyInt_FromLong((long)result);
#	Line 2502 \| Line 2977 \| *static PyObject _wrap_BossSession_RTupd**
2977		try {
2978		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2979
2980	+	}catch (const BossSchedFailure & e) {
2981	+	PyErr_SetString ( SchedulerError, e.what() );
2982	+	return NULL;
2983		}catch (const std::exception& e) {
2984	<	SWIG_exception(SWIG_RuntimeError, e.what());
2984	>	PyErr_SetString ( BossError, e.what() );
2985	>	return NULL;
2986		}
2987		}
2988		resultobj = PyInt_FromLong((long)result);
#	Line 2513 \| Line 2992 \| *static PyObject _wrap_BossSession_RTupd**
2992		}
2993
2994
2995	<	static PyObject _wrap_BossSession_listMatch__SWIG_0(PyObject self, PyObject *args) {
2995	>	static PyObject _wrap_BossSession_listMatch(PyObject self, PyObject *args) {
2996		PyObject *resultobj;
2997		BossSession arg1 = (BossSession ) 0 ;
2998		std::string *arg2 = 0 ;
#	Line 2523 \| Line 3002 \| *static PyObject _wrap_BossSession_listM**
3002		std::string arg5 = (std::string ) &arg5_defvalue ;
3003		std::string const &arg6_defvalue = "" ;
3004		std::string arg6 = (std::string ) &arg6_defvalue ;
3005	<	SwigValueWrapper< std::vector<std::string > > result;
3005	>	unsigned int arg7 = (unsigned int) 0 ;
3006	>	std::vector<std::string > result;
3007		std::string temp2 ;
3008		std::string temp3 ;
3009		std::string temp5 ;
#	Line 2534 \| Line 3014 \| *static PyObject _wrap_BossSession_listM**
3014		PyObject * obj3 = 0 ;
3015		PyObject * obj4 = 0 ;
3016		PyObject * obj5 = 0 ;
3017	+	PyObject * obj6 = 0 ;
3018
3019	<	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3019	>	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3020		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3021		{
3022		if (PyString_Check(obj1)) {
#	Line 2577 \| Line 3058 \| *static PyObject _wrap_BossSession_listM**
3058		}
3059		}
3060		}
3061	+	if (obj6) {
3062	+	arg7 = (unsigned int) PyInt_AsLong(obj6);
3063	+	if (PyErr_Occurred()) SWIG_fail;
3064	+	}
3065		{
3066		try {
3067	<	result = (arg1)->listMatch((std::string const &)arg2,(std::string const &)arg3,arg4,(std::string const &)arg5,(std::string const &)arg6);
3067	>	result = (arg1)->listMatch((std::string const &)arg2,(std::string const &)arg3,arg4,(std::string const &)arg5,(std::string const &)arg6,arg7);
3068
3069	+	}catch (const BossSchedFailure & e) {
3070	+	PyErr_SetString ( SchedulerError, e.what() );
3071	+	return NULL;
3072		}catch (const std::exception& e) {
3073	<	SWIG_exception(SWIG_RuntimeError, e.what());
3073	>	PyErr_SetString ( BossError, e.what() );
3074	>	return NULL;
3075		}
3076		}
3077		{
3078	<	std::vector<std::string > * resultptr;
3079	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3080	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3078	>	resultobj = PyTuple_New((&result)->size());
3079	>	for (unsigned int i=0; i<(&result)->size(); i++)
3080	>	PyTuple_SetItem(resultobj,i,
3081	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3082		}
3083		return resultobj;
3084		fail:
#	Line 2610 \| Line 3100 \| *static PyObject _wrap_BossSession_sched**
3100		std::string arg7 = (std::string) "" ;
3101		std::string arg8 = (std::string) "" ;
3102		std::string arg9 = (std::string) "" ;
3103	+	unsigned int arg10 = (unsigned int) 0 ;
3104		std::string temp3 ;
3105		std::string temp4 ;
3106		std::string temp5 ;
#	Line 2621 \| Line 3112 \| *static PyObject _wrap_BossSession_sched**
3112		PyObject * obj6 = 0 ;
3113		PyObject * obj7 = 0 ;
3114		PyObject * obj8 = 0 ;
3115	+	PyObject * obj9 = 0 ;
3116
3117	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3117	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3118		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3119		if (obj2) {
3120		{
#	Line 2686 \| Line 3178 \| *static PyObject _wrap_BossSession_sched**
3178		SWIG_exception(SWIG_TypeError, "string expected");
3179		}
3180		}
3181	+	if (obj9) {
3182	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3183	+	if (PyErr_Occurred()) SWIG_fail;
3184	+	}
3185		{
3186		try {
3187	<	(arg1)->schedulerQuery(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3187	>	(arg1)->schedulerQuery(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3188
3189	+	}catch (const BossSchedFailure & e) {
3190	+	PyErr_SetString ( SchedulerError, e.what() );
3191	+	return NULL;
3192		}catch (const std::exception& e) {
3193	<	SWIG_exception(SWIG_RuntimeError, e.what());
3193	>	PyErr_SetString ( BossError, e.what() );
3194	>	return NULL;
3195		}
3196		}
3197		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2712 \| Line 3212 \| *static PyObject _wrap_BossSession_selec**
3212		std::string arg4 = (std::string ) &arg4_defvalue ;
3213		std::string const &arg5_defvalue = "" ;
3214		std::string arg5 = (std::string ) &arg5_defvalue ;
3215	<	SwigValueWrapper< std::vector<std::string > > result;
3215	>	std::vector<std::string > result;
3216		std::string temp2 ;
3217		std::string temp3 ;
3218		std::string temp4 ;
#	Line 2769 \| Line 3269 \| *static PyObject _wrap_BossSession_selec**
3269		try {
3270		result = (arg1)->selectTasks((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5);
3271
3272	+	}catch (const BossSchedFailure & e) {
3273	+	PyErr_SetString ( SchedulerError, e.what() );
3274	+	return NULL;
3275		}catch (const std::exception& e) {
3276	<	SWIG_exception(SWIG_RuntimeError, e.what());
3276	>	PyErr_SetString ( BossError, e.what() );
3277	>	return NULL;
3278		}
3279		}
3280		{
3281	<	std::vector<std::string > * resultptr;
3282	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3283	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3281	>	resultobj = PyTuple_New((&result)->size());
3282	>	for (unsigned int i=0; i<(&result)->size(); i++)
3283	>	PyTuple_SetItem(resultobj,i,
3284	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3285		}
3286		return resultobj;
3287		fail:
#	Line 2784 \| Line 3289 \| *static PyObject _wrap_BossSession_selec**
3289		}
3290
3291
3292	<	static PyObject * BossSession_swigregister(PyObject self, PyObject args) {
2788	<	PyObject *obj;
2789	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2790	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
2791	<	Py_INCREF(obj);
2792	<	return Py_BuildValue((char *)"");
2793	<	}
2794	<	static PyObject _wrap_BossTaskException_key_set(PyObject self, PyObject *args) {
3292	>	static PyObject _wrap_BossSession_selectTasksByName(PyObject self, PyObject *args) {
3293		PyObject *resultobj;
3294	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3295	<	char *arg2 ;
3294	>	BossSession arg1 = (BossSession ) 0 ;
3295	>	std::string *arg2 = 0 ;
3296	>	std::vector<std::string > result;
3297	>	std::string temp2 ;
3298		PyObject * obj0 = 0 ;
3299	+	PyObject * obj1 = 0 ;
3300
3301	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3302	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3301	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3302	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3303		{
3304	<	if (arg2) {
3305	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3306	<	strcpy((char *) arg1->key,arg2);
3304	>	if (PyString_Check(obj1)) {
3305	>	temp2 = std::string(PyString_AsString(obj1));
3306	>	arg2 = &temp2;
3307		}else {
3308	<	arg1->key = 0;
3308	>	SWIG_exception(SWIG_TypeError, "string expected");
3309		}
3310		}
3311	<	Py_INCREF(Py_None); resultobj = Py_None;
3311	>	{
3312	>	try {
3313	>	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3314	>
3315	>	}catch (const BossSchedFailure & e) {
3316	>	PyErr_SetString ( SchedulerError, e.what() );
3317	>	return NULL;
3318	>	}catch (const std::exception& e) {
3319	>	PyErr_SetString ( BossError, e.what() );
3320	>	return NULL;
3321	>	}
3322	>	}
3323	>	{
3324	>	resultobj = PyTuple_New((&result)->size());
3325	>	for (unsigned int i=0; i<(&result)->size(); i++)
3326	>	PyTuple_SetItem(resultobj,i,
3327	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3328	>	}
3329		return resultobj;
3330		fail:
3331		return NULL;
3332		}
3333
3334
3335	<	static PyObject _wrap_BossTaskException_key_get(PyObject self, PyObject *args) {
3335	>	static PyObject _wrap_BossSession_query(PyObject self, PyObject *args) {
3336		PyObject *resultobj;
3337	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3338	<	char *result;
3337	>	BossSession arg1 = (BossSession ) 0 ;
3338	>	int arg2 = (int) SCHEDULED ;
3339	>	std::string const &arg3_defvalue = "all" ;
3340	>	std::string arg3 = (std::string ) &arg3_defvalue ;
3341	>	std::string const &arg4_defvalue = "all" ;
3342	>	std::string arg4 = (std::string ) &arg4_defvalue ;
3343	>	std::string const &arg5_defvalue = "" ;
3344	>	std::string arg5 = (std::string ) &arg5_defvalue ;
3345	>	std::string arg6 = (std::string) "" ;
3346	>	std::string arg7 = (std::string) "" ;
3347	>	std::string arg8 = (std::string) "" ;
3348	>	std::string arg9 = (std::string) "" ;
3349	>	unsigned int arg10 = (unsigned int) 0 ;
3350	>	bool arg11 = (bool) false ;
3351	>	SwigValueWrapper< std::vector<BossTask * > > result;
3352	>	std::string temp3 ;
3353	>	std::string temp4 ;
3354	>	std::string temp5 ;
3355		PyObject * obj0 = 0 ;
3356	+	PyObject * obj2 = 0 ;
3357	+	PyObject * obj3 = 0 ;
3358	+	PyObject * obj4 = 0 ;
3359	+	PyObject * obj5 = 0 ;
3360	+	PyObject * obj6 = 0 ;
3361	+	PyObject * obj7 = 0 ;
3362	+	PyObject * obj8 = 0 ;
3363	+	PyObject * obj9 = 0 ;
3364	+	PyObject * obj10 = 0 ;
3365
3366	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3367	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3368	<	result = (char *) ((arg1)->key);
3369	<
3370	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3366	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3367	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3368	>	if (obj2) {
3369	>	{
3370	>	if (PyString_Check(obj2)) {
3371	>	temp3 = std::string(PyString_AsString(obj2));
3372	>	arg3 = &temp3;
3373	>	}else {
3374	>	SWIG_exception(SWIG_TypeError, "string expected");
3375	>	}
3376	>	}
3377	>	}
3378	>	if (obj3) {
3379	>	{
3380	>	if (PyString_Check(obj3)) {
3381	>	temp4 = std::string(PyString_AsString(obj3));
3382	>	arg4 = &temp4;
3383	>	}else {
3384	>	SWIG_exception(SWIG_TypeError, "string expected");
3385	>	}
3386	>	}
3387	>	}
3388	>	if (obj4) {
3389	>	{
3390	>	if (PyString_Check(obj4)) {
3391	>	temp5 = std::string(PyString_AsString(obj4));
3392	>	arg5 = &temp5;
3393	>	}else {
3394	>	SWIG_exception(SWIG_TypeError, "string expected");
3395	>	}
3396	>	}
3397	>	}
3398	>	if (obj5) {
3399	>	{
3400	>	if (PyString_Check(obj5))
3401	>	arg6 = std::string(PyString_AsString(obj5));
3402	>	else
3403	>	SWIG_exception(SWIG_TypeError, "string expected");
3404	>	}
3405	>	}
3406	>	if (obj6) {
3407	>	{
3408	>	if (PyString_Check(obj6))
3409	>	arg7 = std::string(PyString_AsString(obj6));
3410	>	else
3411	>	SWIG_exception(SWIG_TypeError, "string expected");
3412	>	}
3413	>	}
3414	>	if (obj7) {
3415	>	{
3416	>	if (PyString_Check(obj7))
3417	>	arg8 = std::string(PyString_AsString(obj7));
3418	>	else
3419	>	SWIG_exception(SWIG_TypeError, "string expected");
3420	>	}
3421	>	}
3422	>	if (obj8) {
3423	>	{
3424	>	if (PyString_Check(obj8))
3425	>	arg9 = std::string(PyString_AsString(obj8));
3426	>	else
3427	>	SWIG_exception(SWIG_TypeError, "string expected");
3428	>	}
3429	>	}
3430	>	if (obj9) {
3431	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3432	>	if (PyErr_Occurred()) SWIG_fail;
3433	>	}
3434	>	if (obj10) {
3435	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3436	>	if (PyErr_Occurred()) SWIG_fail;
3437	>	}
3438	>	{
3439	>	try {
3440	>	result = (arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3441	>
3442	>	}catch (const BossSchedFailure & e) {
3443	>	PyErr_SetString ( SchedulerError, e.what() );
3444	>	return NULL;
3445	>	}catch (const std::exception& e) {
3446	>	PyErr_SetString ( BossError, e.what() );
3447	>	return NULL;
3448	>	}
3449	>	}
3450	>	{
3451	>	std::vector<BossTask * > * resultptr;
3452	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3453	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3454	>	}
3455		return resultobj;
3456		fail:
3457		return NULL;
3458		}
3459
3460
3461	<	static PyObject _wrap_new_BossTaskException(PyObject self, PyObject *args) {
3461	>	static PyObject _wrap_BossSession_getTasksByName(PyObject self, PyObject *args) {
3462		PyObject *resultobj;
3463	<	char *arg1 ;
3464	<	BossTaskException *result;
3463	>	BossSession arg1 = (BossSession ) 0 ;
3464	>	std::string *arg2 = 0 ;
3465	>	SwigValueWrapper< std::vector<BossTask * > > result;
3466	>	std::string temp2 ;
3467	>	PyObject * obj0 = 0 ;
3468	>	PyObject * obj1 = 0 ;
3469
3470	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3470	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3471	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3472	>	{
3473	>	if (PyString_Check(obj1)) {
3474	>	temp2 = std::string(PyString_AsString(obj1));
3475	>	arg2 = &temp2;
3476	>	}else {
3477	>	SWIG_exception(SWIG_TypeError, "string expected");
3478	>	}
3479	>	}
3480		{
3481		try {
3482	<	result = (BossTaskException )new BossTaskException((char const )arg1);
3482	>	result = (arg1)->getTasksByName((std::string const &)*arg2);
3483
3484	+	}catch (const BossSchedFailure & e) {
3485	+	PyErr_SetString ( SchedulerError, e.what() );
3486	+	return NULL;
3487		}catch (const std::exception& e) {
3488	<	SWIG_exception(SWIG_RuntimeError, e.what());
3488	>	PyErr_SetString ( BossError, e.what() );
3489	>	return NULL;
3490		}
3491		}
3492	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3492	>	{
3493	>	std::vector<BossTask * > * resultptr;
3494	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3495	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3496	>	}
3497		return resultobj;
3498		fail:
3499		return NULL;
3500		}
3501
3502
3503	<	static PyObject _wrap_BossTaskException_what(PyObject self, PyObject *args) {
3503	>	static PyObject _wrap_BossSession_getTasksByJobName(PyObject self, PyObject *args) {
3504		PyObject *resultobj;
3505	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3506	<	char *result;
3505	>	BossSession arg1 = (BossSession ) 0 ;
3506	>	std::string *arg2 = 0 ;
3507	>	SwigValueWrapper< std::vector<BossTask * > > result;
3508	>	std::string temp2 ;
3509		PyObject * obj0 = 0 ;
3510	+	PyObject * obj1 = 0 ;
3511
3512	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3513	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3512	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3513	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3514	>	{
3515	>	if (PyString_Check(obj1)) {
3516	>	temp2 = std::string(PyString_AsString(obj1));
3517	>	arg2 = &temp2;
3518	>	}else {
3519	>	SWIG_exception(SWIG_TypeError, "string expected");
3520	>	}
3521	>	}
3522		{
3523		try {
3524	<	result = (char )((BossTaskException const )arg1)->what();
3524	>	result = (arg1)->getTasksByJobName((std::string const &)*arg2);
3525
3526	+	}catch (const BossSchedFailure & e) {
3527	+	PyErr_SetString ( SchedulerError, e.what() );
3528	+	return NULL;
3529		}catch (const std::exception& e) {
3530	<	SWIG_exception(SWIG_RuntimeError, e.what());
3530	>	PyErr_SetString ( BossError, e.what() );
3531	>	return NULL;
3532		}
3533		}
3534	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3534	>	{
3535	>	std::vector<BossTask * > * resultptr;
3536	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3537	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3538	>	}
3539		return resultobj;
3540		fail:
3541		return NULL;
3542		}
3543
3544
3545	<	static PyObject _wrap_delete_BossTaskException(PyObject self, PyObject *args) {
3545	>	static PyObject _wrap_BossSession_tasksInMemory(PyObject self, PyObject *args) {
3546		PyObject *resultobj;
3547	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3547	>	BossSession arg1 = (BossSession ) 0 ;
3548	>	unsigned int result;
3549		PyObject * obj0 = 0 ;
3550
3551	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3552	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3551	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
3552	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3553		{
3554		try {
3555	<	delete arg1;
3555	>	result = (unsigned int)(arg1)->tasksInMemory();
3556
3557	+	}catch (const BossSchedFailure & e) {
3558	+	PyErr_SetString ( SchedulerError, e.what() );
3559	+	return NULL;
3560		}catch (const std::exception& e) {
3561	<	SWIG_exception(SWIG_RuntimeError, e.what());
3561	>	PyErr_SetString ( BossError, e.what() );
3562	>	return NULL;
3563		}
3564		}
3565	<	Py_INCREF(Py_None); resultobj = Py_None;
3565	>	resultobj = PyInt_FromLong((long)result);
3566		return resultobj;
3567		fail:
3568		return NULL;
3569		}
3570
3571
3572	<	static PyObject * BossTaskException_swigregister(PyObject self, PyObject args) {
3573	<	PyObject *obj;
3574	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3575	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3576	<	Py_INCREF(obj);
3577	<	return Py_BuildValue((char *)"");
3572	>	static PyObject _wrap_BossSession_locate(PyObject self, PyObject *args) {
3573	>	PyObject *resultobj;
3574	>	BossSession arg1 = (BossSession ) 0 ;
3575	>	unsigned int arg2 ;
3576	>	BossTask *result;
3577	>	PyObject * obj0 = 0 ;
3578	>	PyObject * obj1 = 0 ;
3579	>
3580	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
3581	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3582	>	arg2 = (unsigned int) PyInt_AsLong(obj1);
3583	>	if (PyErr_Occurred()) SWIG_fail;
3584	>	{
3585	>	try {
3586	>	result = (BossTask *)(arg1)->locate(arg2);
3587	>
3588	>	}catch (const BossSchedFailure & e) {
3589	>	PyErr_SetString ( SchedulerError, e.what() );
3590	>	return NULL;
3591	>	}catch (const std::exception& e) {
3592	>	PyErr_SetString ( BossError, e.what() );
3593	>	return NULL;
3594	>	}
3595	>	}
3596	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
3597	>	return resultobj;
3598	>	fail:
3599	>	return NULL;
3600		}
3601	<	static PyObject _wrap_BossTask_appendToPyDict(PyObject self, PyObject *args) {
3601	>
3602	>
3603	>	static PyObject _wrap_BossSession_show(PyObject self, PyObject *args) {
3604		PyObject *resultobj;
3605	<	BossTask arg1 = (BossTask ) 0 ;
3606	<	PyObject arg2 = (PyObject ) 0 ;
2911	<	BossAttributeContainer *arg3 = 0 ;
3605	>	BossSession arg1 = (BossSession ) 0 ;
3606	>	std::vector<std::string > *arg2 = 0 ;
3607		PyObject *result;
3608		PyObject * obj0 = 0 ;
3609		PyObject * obj1 = 0 ;
2915	–	PyObject * obj2 = 0 ;
3610
3611	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3612	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3613	<	arg2 = obj1;
3614	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2921	<	if (arg3 == NULL) {
3611	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3612	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3613	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3614	>	if (arg2 == NULL) {
3615		PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3616		}
3617		{
3618		try {
3619	<	result = (PyObject )BossTask_appendToPyDict((BossTask const )arg1,arg2,(BossAttributeContainer const &)*arg3);
3619	>	result = (PyObject )BossSession_show(arg1,arg2);
3620
3621	+	}catch (const BossSchedFailure & e) {
3622	+	PyErr_SetString ( SchedulerError, e.what() );
3623	+	return NULL;
3624		}catch (const std::exception& e) {
3625	<	SWIG_exception(SWIG_RuntimeError, e.what());
3625	>	PyErr_SetString ( BossError, e.what() );
3626	>	return NULL;
3627		}
3628		}
3629		resultobj = result;
#	Line 2936 \| Line 3633 \| *static PyObject _wrap_BossTask_appendTo**
3633		}
3634
3635
3636	<	static PyObject _wrap_BossTask_jobDict(PyObject self, PyObject *args) {
3636	>	static PyObject _wrap_BossSession_CHTools(PyObject self, PyObject *args) {
3637		PyObject *resultobj;
3638	<	BossTask arg1 = (BossTask ) 0 ;
2942	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3638	>	BossSession arg1 = (BossSession ) 0 ;
3639		PyObject *result;
3640		PyObject * obj0 = 0 ;
2945	–	PyObject * obj1 = 0 ;
3641
3642	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3643	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3644	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3645	<	if (arg2 == NULL) {
3646	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3642	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3643	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3644	>	{
3645	>	try {
3646	>	result = (PyObject *)BossSession_CHTools(arg1);
3647	>
3648	>	}catch (const BossSchedFailure & e) {
3649	>	PyErr_SetString ( SchedulerError, e.what() );
3650	>	return NULL;
3651	>	}catch (const std::exception& e) {
3652	>	PyErr_SetString ( BossError, e.what() );
3653	>	return NULL;
3654	>	}
3655		}
3656	+	resultobj = result;
3657	+	return resultobj;
3658	+	fail:
3659	+	return NULL;
3660	+	}
3661	+
3662	+
3663	+	static PyObject _wrap_BossSession_ProgramTypes(PyObject self, PyObject *args) {
3664	+	PyObject *resultobj;
3665	+	BossSession arg1 = (BossSession ) 0 ;
3666	+	PyObject *result;
3667	+	PyObject * obj0 = 0 ;
3668	+
3669	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3670	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3671		{
3672		try {
3673	<	result = (PyObject )BossTask_jobDict((BossTask const )arg1,*arg2);
3673	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3674
3675	+	}catch (const BossSchedFailure & e) {
3676	+	PyErr_SetString ( SchedulerError, e.what() );
3677	+	return NULL;
3678		}catch (const std::exception& e) {
3679	<	SWIG_exception(SWIG_RuntimeError, e.what());
3679	>	PyErr_SetString ( BossError, e.what() );
3680	>	return NULL;
3681		}
3682		}
3683		resultobj = result;
#	Line 2965 \| Line 3687 \| *static PyObject _wrap_BossTask_jobDict(**
3687		}
3688
3689
3690	<	static PyObject _wrap_BossTask_jobsMap__SWIG_1(PyObject self, PyObject *args) {
3690	>	static PyObject _wrap_BossSession_RTMons(PyObject self, PyObject *args) {
3691		PyObject *resultobj;
3692	<	BossTask arg1 = (BossTask ) 0 ;
3692	>	BossSession arg1 = (BossSession ) 0 ;
3693		PyObject *result;
3694		PyObject * obj0 = 0 ;
3695
3696	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3697	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3696	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3697	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3698		{
3699		try {
3700	<	result = (PyObject )BossTask_jobsMap__SWIG_1((BossTask const )arg1);
3700	>	result = (PyObject *)BossSession_RTMons(arg1);
3701
3702	+	}catch (const BossSchedFailure & e) {
3703	+	PyErr_SetString ( SchedulerError, e.what() );
3704	+	return NULL;
3705		}catch (const std::exception& e) {
3706	<	SWIG_exception(SWIG_RuntimeError, e.what());
3706	>	PyErr_SetString ( BossError, e.what() );
3707	>	return NULL;
3708		}
3709		}
3710		resultobj = result;
#	Line 2988 \| Line 3714 \| *static PyObject _wrap_BossTask_jobsMap_**
3714		}
3715
3716
3717	<	static PyObject _wrap_BossTask_jobsMap(PyObject self, PyObject *args) {
3718	<	int argc;
3719	<	PyObject *argv[2];
3720	<	int ii;
3717	>	static PyObject _wrap_BossSession_schedulers(PyObject self, PyObject *args) {
3718	>	PyObject *resultobj;
3719	>	BossSession arg1 = (BossSession ) 0 ;
3720	>	PyObject *result;
3721	>	PyObject * obj0 = 0 ;
3722
3723	<	argc = PyObject_Length(args);
3724	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3725	<	argv[ii] = PyTuple_GetItem(args,ii);
3723	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3724	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3725	>	{
3726	>	try {
3727	>	result = (PyObject *)BossSession_schedulers(arg1);
3728	>
3729	>	}catch (const BossSchedFailure & e) {
3730	>	PyErr_SetString ( SchedulerError, e.what() );
3731	>	return NULL;
3732	>	}catch (const std::exception& e) {
3733	>	PyErr_SetString ( BossError, e.what() );
3734	>	return NULL;
3735	>	}
3736		}
3737	<	if (argc == 1) {
3738	<	int _v;
3737	>	resultobj = result;
3738	>	return resultobj;
3739	>	fail:
3740	>	return NULL;
3741	>	}
3742	>
3743	>
3744	>	static PyObject _wrap_BossSession_schedListMatch(PyObject self, PyObject *args) {
3745	>	PyObject *resultobj;
3746	>	BossSession arg1 = (BossSession ) 0 ;
3747	>	std::string *arg2 = 0 ;
3748	>	std::string *arg3 = 0 ;
3749	>	std::string const &arg4_defvalue = "" ;
3750	>	std::string arg4 = (std::string ) &arg4_defvalue ;
3751	>	std::string const &arg5_defvalue = "" ;
3752	>	std::string arg5 = (std::string ) &arg5_defvalue ;
3753	>	unsigned int arg6 = (unsigned int) 0 ;
3754	>	bool arg7 = (bool) false ;
3755	>	PyObject *result;
3756	>	std::string temp2 ;
3757	>	std::string temp3 ;
3758	>	std::string temp4 ;
3759	>	std::string temp5 ;
3760	>	PyObject * obj0 = 0 ;
3761	>	PyObject * obj1 = 0 ;
3762	>	PyObject * obj2 = 0 ;
3763	>	PyObject * obj3 = 0 ;
3764	>	PyObject * obj4 = 0 ;
3765	>	PyObject * obj5 = 0 ;
3766	>	PyObject * obj6 = 0 ;
3767	>
3768	>	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3769	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3770	>	{
3771	>	if (PyString_Check(obj1)) {
3772	>	temp2 = std::string(PyString_AsString(obj1));
3773	>	arg2 = &temp2;
3774	>	}else {
3775	>	SWIG_exception(SWIG_TypeError, "string expected");
3776	>	}
3777	>	}
3778	>	{
3779	>	if (PyString_Check(obj2)) {
3780	>	temp3 = std::string(PyString_AsString(obj2));
3781	>	arg3 = &temp3;
3782	>	}else {
3783	>	SWIG_exception(SWIG_TypeError, "string expected");
3784	>	}
3785	>	}
3786	>	if (obj3) {
3787		{
3788	<	void *ptr;
3789	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3790	<	_v = 0;
3006	<	PyErr_Clear();
3788	>	if (PyString_Check(obj3)) {
3789	>	temp4 = std::string(PyString_AsString(obj3));
3790	>	arg4 = &temp4;
3791		}else {
3792	<	_v = 1;
3792	>	SWIG_exception(SWIG_TypeError, "string expected");
3793		}
3794		}
3795	<	if (_v) {
3796	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
3795	>	}
3796	>	if (obj4) {
3797	>	{
3798	>	if (PyString_Check(obj4)) {
3799	>	temp5 = std::string(PyString_AsString(obj4));
3800	>	arg5 = &temp5;
3801	>	}else {
3802	>	SWIG_exception(SWIG_TypeError, "string expected");
3803	>	}
3804	>	}
3805	>	}
3806	>	if (obj5) {
3807	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3808	>	if (PyErr_Occurred()) SWIG_fail;
3809	>	}
3810	>	if (obj6) {
3811	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3812	>	if (PyErr_Occurred()) SWIG_fail;
3813	>	}
3814	>	{
3815	>	try {
3816	>	result = (PyObject )BossSession_schedListMatch(arg1,(std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7);
3817	>
3818	>	}catch (const BossSchedFailure & e) {
3819	>	PyErr_SetString ( SchedulerError, e.what() );
3820	>	return NULL;
3821	>	}catch (const std::exception& e) {
3822	>	PyErr_SetString ( BossError, e.what() );
3823	>	return NULL;
3824		}
3825		}
3826	+	resultobj = result;
3827	+	return resultobj;
3828	+	fail:
3829	+	return NULL;
3830	+	}
3831	+
3832	+
3833	+	static PyObject _wrap_BossSession_queryTasks(PyObject self, PyObject *args) {
3834	+	PyObject *resultobj;
3835	+	BossSession arg1 = (BossSession ) 0 ;
3836	+	std::string const &arg2_defvalue = "" ;
3837	+	std::string arg2 = (std::string ) &arg2_defvalue ;
3838	+	std::string const &arg3_defvalue = "all" ;
3839	+	std::string arg3 = (std::string ) &arg3_defvalue ;
3840	+	std::string arg4 = (std::string) "" ;
3841	+	std::string arg5 = (std::string) "" ;
3842	+	std::string arg6 = (std::string) "" ;
3843	+	PyObject *result;
3844	+	std::string temp2 ;
3845	+	std::string temp3 ;
3846	+	PyObject * obj0 = 0 ;
3847	+	PyObject * obj1 = 0 ;
3848	+	PyObject * obj2 = 0 ;
3849	+	PyObject * obj3 = 0 ;
3850	+	PyObject * obj4 = 0 ;
3851	+	PyObject * obj5 = 0 ;
3852
3853	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3853	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3854	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3855	>	if (obj1) {
3856	>	{
3857	>	if (PyString_Check(obj1)) {
3858	>	temp2 = std::string(PyString_AsString(obj1));
3859	>	arg2 = &temp2;
3860	>	}else {
3861	>	SWIG_exception(SWIG_TypeError, "string expected");
3862	>	}
3863	>	}
3864	>	}
3865	>	if (obj2) {
3866	>	{
3867	>	if (PyString_Check(obj2)) {
3868	>	temp3 = std::string(PyString_AsString(obj2));
3869	>	arg3 = &temp3;
3870	>	}else {
3871	>	SWIG_exception(SWIG_TypeError, "string expected");
3872	>	}
3873	>	}
3874	>	}
3875	>	if (obj3) {
3876	>	{
3877	>	if (PyString_Check(obj3))
3878	>	arg4 = std::string(PyString_AsString(obj3));
3879	>	else
3880	>	SWIG_exception(SWIG_TypeError, "string expected");
3881	>	}
3882	>	}
3883	>	if (obj4) {
3884	>	{
3885	>	if (PyString_Check(obj4))
3886	>	arg5 = std::string(PyString_AsString(obj4));
3887	>	else
3888	>	SWIG_exception(SWIG_TypeError, "string expected");
3889	>	}
3890	>	}
3891	>	if (obj5) {
3892	>	{
3893	>	if (PyString_Check(obj5))
3894	>	arg6 = std::string(PyString_AsString(obj5));
3895	>	else
3896	>	SWIG_exception(SWIG_TypeError, "string expected");
3897	>	}
3898	>	}
3899	>	{
3900	>	try {
3901	>	result = (PyObject )BossSession_queryTasks(arg1,(std::string const &)arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3902	>
3903	>	}catch (const BossSchedFailure & e) {
3904	>	PyErr_SetString ( SchedulerError, e.what() );
3905	>	return NULL;
3906	>	}catch (const std::exception& e) {
3907	>	PyErr_SetString ( BossError, e.what() );
3908	>	return NULL;
3909	>	}
3910	>	}
3911	>	resultobj = result;
3912	>	return resultobj;
3913	>	fail:
3914		return NULL;
3915		}
3916
3917
3918	<	static PyObject _wrap_BossTask_progDict(PyObject self, PyObject *args) {
3918	>	static PyObject * BossSession_swigregister(PyObject self, PyObject args) {
3919	>	PyObject *obj;
3920	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3921	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3922	>	Py_INCREF(obj);
3923	>	return Py_BuildValue((char *)"");
3924	>	}
3925	>	static PyObject _wrap_new_BossTaskException(PyObject self, PyObject *args) {
3926	>	PyObject *resultobj;
3927	>	char *arg1 ;
3928	>	BossTaskException *result;
3929	>
3930	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3931	>	{
3932	>	try {
3933	>	result = (BossTaskException )new BossTaskException((char const )arg1);
3934	>
3935	>	}catch (const BossSchedFailure & e) {
3936	>	PyErr_SetString ( SchedulerError, e.what() );
3937	>	return NULL;
3938	>	}catch (const std::exception& e) {
3939	>	PyErr_SetString ( BossError, e.what() );
3940	>	return NULL;
3941	>	}
3942	>	}
3943	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3944	>	return resultobj;
3945	>	fail:
3946	>	return NULL;
3947	>	}
3948	>
3949	>
3950	>	static PyObject _wrap_delete_BossTaskException(PyObject self, PyObject *args) {
3951	>	PyObject *resultobj;
3952	>	BossTaskException arg1 = (BossTaskException ) 0 ;
3953	>	PyObject * obj0 = 0 ;
3954	>
3955	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3956	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3957	>	{
3958	>	try {
3959	>	delete arg1;
3960	>
3961	>	}catch (const BossSchedFailure & e) {
3962	>	PyErr_SetString ( SchedulerError, e.what() );
3963	>	return NULL;
3964	>	}catch (const std::exception& e) {
3965	>	PyErr_SetString ( BossError, e.what() );
3966	>	return NULL;
3967	>	}
3968	>	}
3969	>	Py_INCREF(Py_None); resultobj = Py_None;
3970	>	return resultobj;
3971	>	fail:
3972	>	return NULL;
3973	>	}
3974	>
3975	>
3976	>	static PyObject * BossTaskException_swigregister(PyObject self, PyObject args) {
3977	>	PyObject *obj;
3978	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3979	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3980	>	Py_INCREF(obj);
3981	>	return Py_BuildValue((char *)"");
3982	>	}
3983	>	static PyObject _wrap_BossTask_job_begin(PyObject self, PyObject *args) {
3984		PyObject *resultobj;
3985		BossTask arg1 = (BossTask ) 0 ;
3986	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3987	<	PyObject *result;
3986	>	BossTask::job_iterator result;
3987	>	PyObject * obj0 = 0 ;
3988	>
3989	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3990	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3991	>	{
3992	>	try {
3993	>	result = ((BossTask const *)arg1)->job_begin();
3994	>
3995	>	}catch (const BossSchedFailure & e) {
3996	>	PyErr_SetString ( SchedulerError, e.what() );
3997	>	return NULL;
3998	>	}catch (const std::exception& e) {
3999	>	PyErr_SetString ( BossError, e.what() );
4000	>	return NULL;
4001	>	}
4002	>	}
4003	>	{
4004	>	BossTask::job_iterator * resultptr;
4005	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4006	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4007	>	}
4008	>	return resultobj;
4009	>	fail:
4010	>	return NULL;
4011	>	}
4012	>
4013	>
4014	>	static PyObject _wrap_BossTask_job_end(PyObject self, PyObject *args) {
4015	>	PyObject *resultobj;
4016	>	BossTask arg1 = (BossTask ) 0 ;
4017	>	BossTask::job_iterator result;
4018	>	PyObject * obj0 = 0 ;
4019	>
4020	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4021	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4022	>	{
4023	>	try {
4024	>	result = ((BossTask const *)arg1)->job_end();
4025	>
4026	>	}catch (const BossSchedFailure & e) {
4027	>	PyErr_SetString ( SchedulerError, e.what() );
4028	>	return NULL;
4029	>	}catch (const std::exception& e) {
4030	>	PyErr_SetString ( BossError, e.what() );
4031	>	return NULL;
4032	>	}
4033	>	}
4034	>	{
4035	>	BossTask::job_iterator * resultptr;
4036	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4037	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4038	>	}
4039	>	return resultobj;
4040	>	fail:
4041	>	return NULL;
4042	>	}
4043	>
4044	>
4045	>	static PyObject _wrap_BossTask_queryJobPrograms(PyObject self, PyObject *args) {
4046	>	PyObject *resultobj;
4047	>	BossTask arg1 = (BossTask ) 0 ;
4048	>	BossJob arg2 = (BossJob ) 0 ;
4049	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4050		PyObject * obj0 = 0 ;
4051		PyObject * obj1 = 0 ;
4052
4053	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
4053	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4054		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4055	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4056	<	if (arg2 == NULL) {
4057	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
4055	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4056	>	{
4057	>	try {
4058	>	result = ((BossTask const )arg1)->queryJobPrograms((BossJob const )arg2);
4059	>
4060	>	}catch (const BossSchedFailure & e) {
4061	>	PyErr_SetString ( SchedulerError, e.what() );
4062	>	return NULL;
4063	>	}catch (const std::exception& e) {
4064	>	PyErr_SetString ( BossError, e.what() );
4065	>	return NULL;
4066	>	}
4067	>	}
4068	>	{
4069	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4070	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4071	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4072	>	}
4073	>	return resultobj;
4074	>	fail:
4075	>	return NULL;
4076	>	}
4077	>
4078	>
4079	>	static PyObject _wrap_BossTask_queryProgram(PyObject self, PyObject *args) {
4080	>	PyObject *resultobj;
4081	>	BossTask arg1 = (BossTask ) 0 ;
4082	>	BossJob arg2 = (BossJob ) 0 ;
4083	>	std::string *arg3 = 0 ;
4084	>	BossProgram result;
4085	>	std::string temp3 ;
4086	>	PyObject * obj0 = 0 ;
4087	>	PyObject * obj1 = 0 ;
4088	>	PyObject * obj2 = 0 ;
4089	>
4090	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
4091	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4092	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4093	>	{
4094	>	if (PyString_Check(obj2)) {
4095	>	temp3 = std::string(PyString_AsString(obj2));
4096	>	arg3 = &temp3;
4097	>	}else {
4098	>	SWIG_exception(SWIG_TypeError, "string expected");
4099	>	}
4100		}
4101		{
4102		try {
4103	<	result = (PyObject )BossTask_progDict((BossTask const )arg1,*arg2);
4103	>	result = ((BossTask const )arg1)->queryProgram((BossJob const )arg2,(std::string const &)*arg3);
4104
4105	+	}catch (const BossSchedFailure & e) {
4106	+	PyErr_SetString ( SchedulerError, e.what() );
4107	+	return NULL;
4108		}catch (const std::exception& e) {
4109	<	SWIG_exception(SWIG_RuntimeError, e.what());
4109	>	PyErr_SetString ( BossError, e.what() );
4110	>	return NULL;
4111		}
4112		}
4113	<	resultobj = result;
4113	>	{
4114	>	BossProgram * resultptr;
4115	>	resultptr = new BossProgram((BossProgram &) result);
4116	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4117	>	}
4118		return resultobj;
4119		fail:
4120		return NULL;
4121		}
4122
4123
4124	<	static PyObject _wrap_BossTask_jobPrograms(PyObject self, PyObject *args) {
4124	>	static PyObject _wrap_BossTask_queryProgramExec(PyObject self, PyObject *args) {
4125		PyObject *resultobj;
4126		BossTask arg1 = (BossTask ) 0 ;
4127	<	std::string *arg2 = 0 ;
4128	<	PyObject *result;
4129	<	std::string temp2 ;
4127	>	BossJob arg2 = (BossJob ) 0 ;
4128	>	std::string *arg3 = 0 ;
4129	>	BossProgramExec result;
4130	>	std::string temp3 ;
4131		PyObject * obj0 = 0 ;
4132		PyObject * obj1 = 0 ;
4133	+	PyObject * obj2 = 0 ;
4134
4135	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
4135	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4136		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4137	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4138		{
4139	<	if (PyString_Check(obj1)) {
4140	<	temp2 = std::string(PyString_AsString(obj1));
4141	<	arg2 = &temp2;
4139	>	if (PyString_Check(obj2)) {
4140	>	temp3 = std::string(PyString_AsString(obj2));
4141	>	arg3 = &temp3;
4142		}else {
4143		SWIG_exception(SWIG_TypeError, "string expected");
4144		}
4145		}
4146		{
4147		try {
4148	<	result = (PyObject )BossTask_jobPrograms((BossTask const )arg1,(std::string const &)*arg2);
4148	>	result = ((BossTask const )arg1)->queryProgramExec((BossJob const )arg2,(std::string const &)*arg3);
4149
4150	+	}catch (const BossSchedFailure & e) {
4151	+	PyErr_SetString ( SchedulerError, e.what() );
4152	+	return NULL;
4153		}catch (const std::exception& e) {
4154	<	SWIG_exception(SWIG_RuntimeError, e.what());
4154	>	PyErr_SetString ( BossError, e.what() );
4155	>	return NULL;
4156		}
4157		}
4158	<	resultobj = result;
4158	>	{
4159	>	BossProgramExec * resultptr;
4160	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4161	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4162	>	}
4163		return resultobj;
4164		fail:
4165		return NULL;
#	Line 3093 \| Line 4178 \| *static PyObject _wrap_new_BossTask__SWI**
4178		try {
4179		result = (BossTask *)new BossTask(arg1);
4180
4181	+	}catch (const BossSchedFailure & e) {
4182	+	PyErr_SetString ( SchedulerError, e.what() );
4183	+	return NULL;
4184		}catch (const std::exception& e) {
4185	<	SWIG_exception(SWIG_RuntimeError, e.what());
4185	>	PyErr_SetString ( BossError, e.what() );
4186	>	return NULL;
4187		}
4188		}
4189		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3127 \| Line 4216 \| *static PyObject _wrap_new_BossTask__SWI**
4216		try {
4217		result = (BossTask )new BossTask(arg1,(std::string const &)arg2);
4218
4219	+	}catch (const BossSchedFailure & e) {
4220	+	PyErr_SetString ( SchedulerError, e.what() );
4221	+	return NULL;
4222		}catch (const std::exception& e) {
4223	<	SWIG_exception(SWIG_RuntimeError, e.what());
4223	>	PyErr_SetString ( BossError, e.what() );
4224	>	return NULL;
4225		}
4226		}
4227		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3149 \| Line 4242 \| *static PyObject _wrap_delete_BossTask(P**
4242		try {
4243		delete arg1;
4244
4245	+	}catch (const BossSchedFailure & e) {
4246	+	PyErr_SetString ( SchedulerError, e.what() );
4247	+	return NULL;
4248		}catch (const std::exception& e) {
4249	<	SWIG_exception(SWIG_RuntimeError, e.what());
4249	>	PyErr_SetString ( BossError, e.what() );
4250	>	return NULL;
4251		}
4252		}
4253		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3175 \| Line 4272 \| *static PyObject _wrap_new_BossTask__SWI**
4272		try {
4273		result = (BossTask )new BossTask((BossTask const &)arg1);
4274
4275	+	}catch (const BossSchedFailure & e) {
4276	+	PyErr_SetString ( SchedulerError, e.what() );
4277	+	return NULL;
4278		}catch (const std::exception& e) {
4279	<	SWIG_exception(SWIG_RuntimeError, e.what());
4279	>	PyErr_SetString ( BossError, e.what() );
4280	>	return NULL;
4281		}
4282		}
4283		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3266 \| Line 4367 \| *static PyObject _wrap_BossTask_id(PyObj**
4367		result = (std::string *) &_result_ref;
4368		}
4369
4370	+	}catch (const BossSchedFailure & e) {
4371	+	PyErr_SetString ( SchedulerError, e.what() );
4372	+	return NULL;
4373		}catch (const std::exception& e) {
4374	<	SWIG_exception(SWIG_RuntimeError, e.what());
4374	>	PyErr_SetString ( BossError, e.what() );
4375	>	return NULL;
4376		}
4377		}
4378		{
#	Line 3294 \| Line 4399 \| *static PyObject _wrap_BossTask_name(PyO**
4399		result = (std::string *) &_result_ref;
4400		}
4401
4402	+	}catch (const BossSchedFailure & e) {
4403	+	PyErr_SetString ( SchedulerError, e.what() );
4404	+	return NULL;
4405		}catch (const std::exception& e) {
4406	<	SWIG_exception(SWIG_RuntimeError, e.what());
4406	>	PyErr_SetString ( BossError, e.what() );
4407	>	return NULL;
4408		}
4409		}
4410		{
#	Line 3307 \| Line 4416 \| *static PyObject _wrap_BossTask_name(PyO**
4416		}
4417
4418
4419	<	static PyObject _wrap_BossTask_taskMap(PyObject self, PyObject *args) {
4419	>	static PyObject _wrap_BossTask_chain(PyObject self, PyObject *args) {
4420		PyObject *resultobj;
4421		BossTask arg1 = (BossTask ) 0 ;
4422	<	std::map<std::string,std::string > result;
4422	>	std::string *arg2 = 0 ;
4423	>	BossChain result;
4424	>	std::string temp2 ;
4425		PyObject * obj0 = 0 ;
4426	+	PyObject * obj1 = 0 ;
4427
4428	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4428	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4429		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4430		{
4431	<	try {
4432	<	result = ((BossTask const *)arg1)->taskMap();
4433	<
4434	<	}catch (const std::exception& e) {
4435	<	SWIG_exception(SWIG_RuntimeError, e.what());
3324	<	}
3325	<	}
3326	<	{
3327	<	resultobj = PyDict_New();
3328	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3329	<	PyDict_SetItem(resultobj,
3330	<	SwigString_FromString(i->first),
3331	<	SwigString_FromString(i->second));
4431	>	if (PyString_Check(obj1)) {
4432	>	temp2 = std::string(PyString_AsString(obj1));
4433	>	arg2 = &temp2;
4434	>	}else {
4435	>	SWIG_exception(SWIG_TypeError, "string expected");
4436		}
4437		}
3334	–	return resultobj;
3335	–	fail:
3336	–	return NULL;
3337	–	}
3338	–
3339	–
3340	–	static PyObject _wrap_BossTask_job_begin(PyObject self, PyObject *args) {
3341	–	PyObject *resultobj;
3342	–	BossTask arg1 = (BossTask ) 0 ;
3343	–	BossTask::job_iterator result;
3344	–	PyObject * obj0 = 0 ;
3345	–
3346	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3347	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4438		{
4439		try {
4440	<	result = ((BossTask const *)arg1)->job_begin();
4440	>	result = ((BossTask const )arg1)->chain((std::string const &)arg2);
4441
4442	+	}catch (const BossSchedFailure & e) {
4443	+	PyErr_SetString ( SchedulerError, e.what() );
4444	+	return NULL;
4445		}catch (const std::exception& e) {
4446	<	SWIG_exception(SWIG_RuntimeError, e.what());
4446	>	PyErr_SetString ( BossError, e.what() );
4447	>	return NULL;
4448		}
4449		}
4450		{
4451	<	BossTask::job_iterator * resultptr;
4452	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4453	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4451	>	BossChain * resultptr;
4452	>	resultptr = new BossChain((BossChain &) result);
4453	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4454		}
4455		return resultobj;
4456		fail:
#	Line 3364 \| Line 4458 \| *static PyObject _wrap_BossTask_job_begi**
4458		}
4459
4460
4461	<	static PyObject _wrap_BossTask_job_end(PyObject self, PyObject *args) {
4461	>	static PyObject _wrap_BossTask_taskMap(PyObject self, PyObject *args) {
4462		PyObject *resultobj;
4463		BossTask arg1 = (BossTask ) 0 ;
4464	<	BossTask::job_iterator result;
4464	>	std::map<std::string,std::string > result;
4465		PyObject * obj0 = 0 ;
4466
4467	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4467	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4468		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4469		{
4470		try {
4471	<	result = ((BossTask const *)arg1)->job_end();
4471	>	result = ((BossTask const *)arg1)->taskMap();
4472
4473	+	}catch (const BossSchedFailure & e) {
4474	+	PyErr_SetString ( SchedulerError, e.what() );
4475	+	return NULL;
4476		}catch (const std::exception& e) {
4477	<	SWIG_exception(SWIG_RuntimeError, e.what());
4477	>	PyErr_SetString ( BossError, e.what() );
4478	>	return NULL;
4479		}
4480		}
4481		{
4482	<	BossTask::job_iterator * resultptr;
4483	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4484	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4482	>	resultobj = PyDict_New();
4483	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4484	>	PyDict_SetItem(resultobj,
4485	>	SwigString_FromString(i->first),
4486	>	SwigString_FromString(i->second));
4487	>	}
4488		}
4489		return resultobj;
4490		fail:
#	Line 3391 \| Line 4492 \| *static PyObject _wrap_BossTask_job_end(**
4492		}
4493
4494
4495	<	static PyObject _wrap_BossTask_jobsMap__SWIG_0(PyObject self, PyObject *args) {
4495	>	static PyObject _wrap_BossTask_jobsMap(PyObject self, PyObject *args) {
4496		PyObject *resultobj;
4497		BossTask arg1 = (BossTask ) 0 ;
4498		SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
#	Line 3403 \| Line 4504 \| *static PyObject _wrap_BossTask_jobsMap_**
4504		try {
4505		result = ((BossTask const *)arg1)->jobsMap();
4506
4507	+	}catch (const BossSchedFailure & e) {
4508	+	PyErr_SetString ( SchedulerError, e.what() );
4509	+	return NULL;
4510		}catch (const std::exception& e) {
4511	<	SWIG_exception(SWIG_RuntimeError, e.what());
4511	>	PyErr_SetString ( BossError, e.what() );
4512	>	return NULL;
4513		}
4514		}
4515		{
#	Line 3441 \| Line 4546 \| *static PyObject _wrap_BossTask_jobMap__**
4546		try {
4547		result = ((BossTask const )arg1)->jobMap(arg2,arg3);
4548
4549	+	}catch (const BossSchedFailure & e) {
4550	+	PyErr_SetString ( SchedulerError, e.what() );
4551	+	return NULL;
4552		}catch (const std::exception& e) {
4553	<	SWIG_exception(SWIG_RuntimeError, e.what());
4553	>	PyErr_SetString ( BossError, e.what() );
4554	>	return NULL;
4555		}
4556		}
4557		{
#	Line 3470 \| Line 4579 \| *static PyObject _wrap_BossTask_jobMap__**
4579		try {
4580		result = ((BossTask const *)arg1)->jobMap(arg2);
4581
4582	+	}catch (const BossSchedFailure & e) {
4583	+	PyErr_SetString ( SchedulerError, e.what() );
4584	+	return NULL;
4585		}catch (const std::exception& e) {
4586	<	SWIG_exception(SWIG_RuntimeError, e.what());
4586	>	PyErr_SetString ( BossError, e.what() );
4587	>	return NULL;
4588		}
4589		}
4590		{
#	Line 3575 \| Line 4688 \| *static PyObject _wrap_BossTask_programs**
4688		try {
4689		result = ((BossTask const )arg1)->programsMap((BossJob const )arg2);
4690
4691	+	}catch (const BossSchedFailure & e) {
4692	+	PyErr_SetString ( SchedulerError, e.what() );
4693	+	return NULL;
4694		}catch (const std::exception& e) {
4695	<	SWIG_exception(SWIG_RuntimeError, e.what());
4695	>	PyErr_SetString ( BossError, e.what() );
4696	>	return NULL;
4697		}
4698		}
4699		{
#	Line 3590 \| Line 4707 \| *static PyObject _wrap_BossTask_programs**
4707		}
4708
4709
3593	–	static PyObject _wrap_BossTask_queryJobPrograms(PyObject self, PyObject *args) {
3594	–	PyObject *resultobj;
3595	–	BossTask arg1 = (BossTask ) 0 ;
3596	–	BossJob arg2 = (BossJob ) 0 ;
3597	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3598	–	PyObject * obj0 = 0 ;
3599	–	PyObject * obj1 = 0 ;
3600	–
3601	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3602	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3603	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3604	–	{
3605	–	try {
3606	–	result = ((BossTask const )arg1)->queryJobPrograms((BossJob const )arg2);
3607	–
3608	–	}catch (const std::exception& e) {
3609	–	SWIG_exception(SWIG_RuntimeError, e.what());
3610	–	}
3611	–	}
3612	–	{
3613	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3614	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3615	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3616	–	}
3617	–	return resultobj;
3618	–	fail:
3619	–	return NULL;
3620	–	}
3621	–
3622	–
4710		static PyObject _wrap_BossTask_declare__SWIG_0(PyObject self, PyObject *args) {
4711		PyObject *resultobj;
4712		BossTask arg1 = (BossTask ) 0 ;
#	Line 3656 \| Line 4743 \| *static PyObject _wrap_BossTask_declare_**
4743		try {
4744		(arg1)->declare((std::string const &)arg2,(std::string const &)arg3);
4745
4746	+	}catch (const BossSchedFailure & e) {
4747	+	PyErr_SetString ( SchedulerError, e.what() );
4748	+	return NULL;
4749		}catch (const std::exception& e) {
4750	<	SWIG_exception(SWIG_RuntimeError, e.what());
4750	>	PyErr_SetString ( BossError, e.what() );
4751	>	return NULL;
4752		}
4753		}
4754		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3695 \| Line 4786 \| *static PyObject _wrap_BossTask_declare_**
4786		try {
4787		(arg1)->declare(arg2,(std::string const &)*arg3);
4788
4789	+	}catch (const BossSchedFailure & e) {
4790	+	PyErr_SetString ( SchedulerError, e.what() );
4791	+	return NULL;
4792		}catch (const std::exception& e) {
4793	<	SWIG_exception(SWIG_RuntimeError, e.what());
4793	>	PyErr_SetString ( BossError, e.what() );
4794	>	return NULL;
4795		}
4796		}
4797		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3794 \| Line 4889 \| *static PyObject _wrap_BossTask_remove(P**
4889		try {
4890		(arg1)->remove();
4891
4892	+	}catch (const BossSchedFailure & e) {
4893	+	PyErr_SetString ( SchedulerError, e.what() );
4894	+	return NULL;
4895		}catch (const std::exception& e) {
4896	<	SWIG_exception(SWIG_RuntimeError, e.what());
4896	>	PyErr_SetString ( BossError, e.what() );
4897	>	return NULL;
4898		}
4899		}
4900		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3830 \| Line 4929 \| *static PyObject _wrap_BossTask_archive(**
4929		try {
4930		(arg1)->archive((std::string const &)*arg2);
4931
4932	+	}catch (const BossSchedFailure & e) {
4933	+	PyErr_SetString ( SchedulerError, e.what() );
4934	+	return NULL;
4935		}catch (const std::exception& e) {
4936	<	SWIG_exception(SWIG_RuntimeError, e.what());
4936	>	PyErr_SetString ( BossError, e.what() );
4937	>	return NULL;
4938		}
4939		}
4940		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3854 \| Line 4957 \| *static PyObject _wrap_BossTask_submit(P**
4957		std::string arg5 = (std::string ) &arg5_defvalue ;
4958		std::string const &arg6_defvalue = "" ;
4959		std::string arg6 = (std::string ) &arg6_defvalue ;
4960	<	bool arg7 = (bool) false ;
4960	>	unsigned int arg7 = (unsigned int) 0 ;
4961	>	bool arg8 = (bool) false ;
4962		int result;
4963		std::string temp2 ;
4964		std::string temp3 ;
#	Line 3868 \| Line 4972 \| *static PyObject _wrap_BossTask_submit(P**
4972		PyObject * obj4 = 0 ;
4973		PyObject * obj5 = 0 ;
4974		PyObject * obj6 = 0 ;
4975	+	PyObject * obj7 = 0 ;
4976
4977	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4977	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4978		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4979		if (obj1) {
4980		{
#	Line 3922 \| Line 5027 \| *static PyObject _wrap_BossTask_submit(P**
5027		}
5028		}
5029		if (obj6) {
5030	<	arg7 = PyInt_AsLong(obj6) ? true : false;
5030	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
5031	>	if (PyErr_Occurred()) SWIG_fail;
5032	>	}
5033	>	if (obj7) {
5034	>	arg8 = PyInt_AsLong(obj7) ? true : false;
5035		if (PyErr_Occurred()) SWIG_fail;
5036		}
5037		{
5038		try {
5039	<	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);
5039	>	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);
5040
5041	+	}catch (const BossSchedFailure & e) {
5042	+	PyErr_SetString ( SchedulerError, e.what() );
5043	+	return NULL;
5044		}catch (const std::exception& e) {
5045	<	SWIG_exception(SWIG_RuntimeError, e.what());
5045	>	PyErr_SetString ( BossError, e.what() );
5046	>	return NULL;
5047		}
5048		}
5049		resultobj = PyInt_FromLong((long)result);
#	Line 3969 \| Line 5082 \| *static PyObject _wrap_BossTask_reSubmit**
5082		try {
5083		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
5084
5085	+	}catch (const BossSchedFailure & e) {
5086	+	PyErr_SetString ( SchedulerError, e.what() );
5087	+	return NULL;
5088		}catch (const std::exception& e) {
5089	<	SWIG_exception(SWIG_RuntimeError, e.what());
5089	>	PyErr_SetString ( BossError, e.what() );
5090	>	return NULL;
5091		}
5092		}
5093		resultobj = PyInt_FromLong((long)result);
#	Line 3984 \| Line 5101 \| *static PyObject _wrap_BossTask_kill(PyO**
5101		PyObject *resultobj;
5102		BossTask arg1 = (BossTask ) 0 ;
5103		std::string *arg2 = 0 ;
5104	<	bool arg3 = (bool) false ;
5104	>	unsigned int arg3 = (unsigned int) 0 ;
5105	>	bool arg4 = (bool) false ;
5106		int result;
5107		std::string temp2 ;
5108		PyObject * obj0 = 0 ;
5109		PyObject * obj1 = 0 ;
5110		PyObject * obj2 = 0 ;
5111	+	PyObject * obj3 = 0 ;
5112
5113	<	if(!PyArg_ParseTuple(args,(char *)"OO\|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
5113	>	if(!PyArg_ParseTuple(args,(char *)"OO\|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
5114		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5115		{
5116		if (PyString_Check(obj1)) {
#	Line 4002 \| Line 5121 \| *static PyObject _wrap_BossTask_kill(PyO**
5121		}
5122		}
5123		if (obj2) {
5124	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5124	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
5125	>	if (PyErr_Occurred()) SWIG_fail;
5126	>	}
5127	>	if (obj3) {
5128	>	arg4 = PyInt_AsLong(obj3) ? true : false;
5129		if (PyErr_Occurred()) SWIG_fail;
5130		}
5131		{
5132		try {
5133	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
5133	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
5134
5135	+	}catch (const BossSchedFailure & e) {
5136	+	PyErr_SetString ( SchedulerError, e.what() );
5137	+	return NULL;
5138		}catch (const std::exception& e) {
5139	<	SWIG_exception(SWIG_RuntimeError, e.what());
5139	>	PyErr_SetString ( BossError, e.what() );
5140	>	return NULL;
5141		}
5142		}
5143		resultobj = PyInt_FromLong((long)result);
#	Line 4020 \| Line 5147 \| *static PyObject _wrap_BossTask_kill(PyO**
5147		}
5148
5149
5150	<	static PyObject _wrap_BossTask_getOutput__SWIG_0(PyObject self, PyObject *args) {
5150	>	static PyObject _wrap_BossTask_getOutput(PyObject self, PyObject *args) {
5151		PyObject *resultobj;
5152		BossTask arg1 = (BossTask ) 0 ;
5153		std::string const &arg2_defvalue = "all" ;
5154		std::string arg2 = (std::string ) &arg2_defvalue ;
5155		std::string const &arg3_defvalue = "" ;
5156		std::string arg3 = (std::string ) &arg3_defvalue ;
5157	<	bool arg4 = (bool) false ;
5157	>	unsigned int arg4 = (unsigned int) 0 ;
5158		bool arg5 = (bool) false ;
5159	+	bool arg6 = (bool) false ;
5160		int result;
5161		std::string temp2 ;
5162		std::string temp3 ;
#	Line 4037 \| Line 5165 \| *static PyObject _wrap_BossTask_getOutpu**
5165		PyObject * obj2 = 0 ;
5166		PyObject * obj3 = 0 ;
5167		PyObject * obj4 = 0 ;
5168	+	PyObject * obj5 = 0 ;
5169
5170	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5170	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5171		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5172		if (obj1) {
5173		{
#	Line 4061 \| Line 5190 \| *static PyObject _wrap_BossTask_getOutpu**
5190		}
5191		}
5192		if (obj3) {
5193	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5193	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
5194		if (PyErr_Occurred()) SWIG_fail;
5195		}
5196		if (obj4) {
5197		arg5 = PyInt_AsLong(obj4) ? true : false;
5198		if (PyErr_Occurred()) SWIG_fail;
5199		}
5200	+	if (obj5) {
5201	+	arg6 = PyInt_AsLong(obj5) ? true : false;
5202	+	if (PyErr_Occurred()) SWIG_fail;
5203	+	}
5204		{
5205		try {
5206	<	result = (int)(arg1)->getOutput((std::string const &)arg2,(std::string const &)arg3,arg4,arg5);
5206	>	result = (int)(arg1)->getOutput((std::string const &)arg2,(std::string const &)arg3,arg4,arg5,arg6);
5207
5208	+	}catch (const BossSchedFailure & e) {
5209	+	PyErr_SetString ( SchedulerError, e.what() );
5210	+	return NULL;
5211		}catch (const std::exception& e) {
5212	<	SWIG_exception(SWIG_RuntimeError, e.what());
5212	>	PyErr_SetString ( BossError, e.what() );
5213	>	return NULL;
5214		}
5215		}
5216		resultobj = PyInt_FromLong((long)result);
#	Line 4083 \| Line 5220 \| *static PyObject _wrap_BossTask_getOutpu**
5220		}
5221
5222
5223	<	static PyObject _wrap_BossTask_getOutput__SWIG_1(PyObject self, PyObject *args) {
5223	>	static PyObject _wrap_BossTask_loadByName(PyObject self, PyObject *args) {
5224		PyObject *resultobj;
5225		BossTask arg1 = (BossTask ) 0 ;
5226	<	std::string const &arg2_defvalue = "" ;
4090	<	std::string arg2 = (std::string ) &arg2_defvalue ;
4091	<	bool arg3 = (bool) false ;
4092	<	bool arg4 = (bool) false ;
5226	>	std::string *arg2 = 0 ;
5227		int result;
5228		std::string temp2 ;
5229		PyObject * obj0 = 0 ;
5230		PyObject * obj1 = 0 ;
5231	+
5232	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5233	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5234	+	{
5235	+	if (PyString_Check(obj1)) {
5236	+	temp2 = std::string(PyString_AsString(obj1));
5237	+	arg2 = &temp2;
5238	+	}else {
5239	+	SWIG_exception(SWIG_TypeError, "string expected");
5240	+	}
5241	+	}
5242	+	{
5243	+	try {
5244	+	result = (int)(arg1)->loadByName((std::string const &)*arg2);
5245	+
5246	+	}catch (const BossSchedFailure & e) {
5247	+	PyErr_SetString ( SchedulerError, e.what() );
5248	+	return NULL;
5249	+	}catch (const std::exception& e) {
5250	+	PyErr_SetString ( BossError, e.what() );
5251	+	return NULL;
5252	+	}
5253	+	}
5254	+	resultobj = PyInt_FromLong((long)result);
5255	+	return resultobj;
5256	+	fail:
5257	+	return NULL;
5258	+	}
5259	+
5260	+
5261	+	static PyObject _wrap_BossTask_load(PyObject self, PyObject *args) {
5262	+	PyObject *resultobj;
5263	+	BossTask arg1 = (BossTask ) 0 ;
5264	+	int arg2 = (int) SCHEDULED ;
5265	+	std::string const &arg3_defvalue = "all" ;
5266	+	std::string arg3 = (std::string ) &arg3_defvalue ;
5267	+	std::string const &arg4_defvalue = "" ;
5268	+	std::string arg4 = (std::string ) &arg4_defvalue ;
5269	+	std::string arg5 = (std::string) "" ;
5270	+	std::string arg6 = (std::string) "" ;
5271	+	std::string arg7 = (std::string) "" ;
5272	+	std::string arg8 = (std::string) "" ;
5273	+	int result;
5274	+	std::string temp3 ;
5275	+	std::string temp4 ;
5276	+	PyObject * obj0 = 0 ;
5277		PyObject * obj2 = 0 ;
5278		PyObject * obj3 = 0 ;
5279	+	PyObject * obj4 = 0 ;
5280	+	PyObject * obj5 = 0 ;
5281	+	PyObject * obj6 = 0 ;
5282	+	PyObject * obj7 = 0 ;
5283
5284	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
5284	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5285		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5286	<	if (obj1) {
5286	>	if (obj2) {
5287		{
5288	<	if (PyString_Check(obj1)) {
5289	<	temp2 = std::string(PyString_AsString(obj1));
5290	<	arg2 = &temp2;
5288	>	if (PyString_Check(obj2)) {
5289	>	temp3 = std::string(PyString_AsString(obj2));
5290	>	arg3 = &temp3;
5291		}else {
5292		SWIG_exception(SWIG_TypeError, "string expected");
5293		}
5294		}
5295		}
4112	–	if (obj2) {
4113	–	arg3 = PyInt_AsLong(obj2) ? true : false;
4114	–	if (PyErr_Occurred()) SWIG_fail;
4115	–	}
5296		if (obj3) {
5297	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5298	<	if (PyErr_Occurred()) SWIG_fail;
5297	>	{
5298	>	if (PyString_Check(obj3)) {
5299	>	temp4 = std::string(PyString_AsString(obj3));
5300	>	arg4 = &temp4;
5301	>	}else {
5302	>	SWIG_exception(SWIG_TypeError, "string expected");
5303	>	}
5304	>	}
5305	>	}
5306	>	if (obj4) {
5307	>	{
5308	>	if (PyString_Check(obj4))
5309	>	arg5 = std::string(PyString_AsString(obj4));
5310	>	else
5311	>	SWIG_exception(SWIG_TypeError, "string expected");
5312	>	}
5313	>	}
5314	>	if (obj5) {
5315	>	{
5316	>	if (PyString_Check(obj5))
5317	>	arg6 = std::string(PyString_AsString(obj5));
5318	>	else
5319	>	SWIG_exception(SWIG_TypeError, "string expected");
5320	>	}
5321	>	}
5322	>	if (obj6) {
5323	>	{
5324	>	if (PyString_Check(obj6))
5325	>	arg7 = std::string(PyString_AsString(obj6));
5326	>	else
5327	>	SWIG_exception(SWIG_TypeError, "string expected");
5328	>	}
5329	>	}
5330	>	if (obj7) {
5331	>	{
5332	>	if (PyString_Check(obj7))
5333	>	arg8 = std::string(PyString_AsString(obj7));
5334	>	else
5335	>	SWIG_exception(SWIG_TypeError, "string expected");
5336	>	}
5337		}
5338		{
5339		try {
5340	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
5340	>	result = (int)(arg1)->load(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8);
5341
5342	+	}catch (const BossSchedFailure & e) {
5343	+	PyErr_SetString ( SchedulerError, e.what() );
5344	+	return NULL;
5345		}catch (const std::exception& e) {
5346	<	SWIG_exception(SWIG_RuntimeError, e.what());
5346	>	PyErr_SetString ( BossError, e.what() );
5347	>	return NULL;
5348		}
5349		}
5350		resultobj = PyInt_FromLong((long)result);
#	Line 4132 \| Line 5354 \| *static PyObject _wrap_BossTask_getOutpu**
5354		}
5355
5356
5357	<	static PyObject _wrap_BossTask_getOutput(PyObject self, PyObject *args) {
5358	<	int argc;
5359	<	PyObject *argv[6];
5360	<	int ii;
5357	>	static PyObject _wrap_BossTask_schedulerQuery(PyObject self, PyObject *args) {
5358	>	PyObject *resultobj;
5359	>	BossTask arg1 = (BossTask ) 0 ;
5360	>	int arg2 = (int) SCHEDULED ;
5361	>	std::string const &arg3_defvalue = "all" ;
5362	>	std::string arg3 = (std::string ) &arg3_defvalue ;
5363	>	std::string const &arg4_defvalue = "" ;
5364	>	std::string arg4 = (std::string ) &arg4_defvalue ;
5365	>	std::string arg5 = (std::string) "" ;
5366	>	std::string arg6 = (std::string) "" ;
5367	>	std::string arg7 = (std::string) "" ;
5368	>	std::string arg8 = (std::string) "" ;
5369	>	unsigned int arg9 = (unsigned int) 0 ;
5370	>	int result;
5371	>	std::string temp3 ;
5372	>	std::string temp4 ;
5373	>	PyObject * obj0 = 0 ;
5374	>	PyObject * obj2 = 0 ;
5375	>	PyObject * obj3 = 0 ;
5376	>	PyObject * obj4 = 0 ;
5377	>	PyObject * obj5 = 0 ;
5378	>	PyObject * obj6 = 0 ;
5379	>	PyObject * obj7 = 0 ;
5380	>	PyObject * obj8 = 0 ;
5381
5382	<	argc = PyObject_Length(args);
5383	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
5384	<	argv[ii] = PyTuple_GetItem(args,ii);
4143	<	}
4144	<	if ((argc >= 1) && (argc <= 5)) {
4145	<	int _v;
5382	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5383	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5384	>	if (obj2) {
5385		{
5386	<	void *ptr;
5387	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5388	<	_v = 0;
4150	<	PyErr_Clear();
5386	>	if (PyString_Check(obj2)) {
5387	>	temp3 = std::string(PyString_AsString(obj2));
5388	>	arg3 = &temp3;
5389		}else {
5390	<	_v = 1;
4153	<	}
4154	<	}
4155	<	if (_v) {
4156	<	if (argc <= 1) {
4157	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4158	<	}
4159	<	{
4160	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4161	<	}
4162	<	if (_v) {
4163	<	if (argc <= 2) {
4164	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4165	<	}
4166	<	{
4167	<	_v = PyString_Check(argv[2]) ? 1 : 0;
4168	<	}
4169	<	if (_v) {
4170	<	if (argc <= 3) {
4171	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4172	<	}
4173	<	{
4174	<	_v = (PyInt_Check(argv[3]) \|\| PyLong_Check(argv[3])) ? 1 : 0;
4175	<	}
4176	<	if (_v) {
4177	<	if (argc <= 4) {
4178	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4179	<	}
4180	<	{
4181	<	_v = (PyInt_Check(argv[4]) \|\| PyLong_Check(argv[4])) ? 1 : 0;
4182	<	}
4183	<	if (_v) {
4184	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4185	<	}
4186	<	}
4187	<	}
5390	>	SWIG_exception(SWIG_TypeError, "string expected");
5391		}
5392		}
5393		}
5394	<	if ((argc >= 1) && (argc <= 4)) {
4192	<	int _v;
5394	>	if (obj3) {
5395		{
5396	<	void *ptr;
5397	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5398	<	_v = 0;
4197	<	PyErr_Clear();
5396	>	if (PyString_Check(obj3)) {
5397	>	temp4 = std::string(PyString_AsString(obj3));
5398	>	arg4 = &temp4;
5399		}else {
5400	<	_v = 1;
5400	>	SWIG_exception(SWIG_TypeError, "string expected");
5401		}
5402		}
5403	<	if (_v) {
5404	<	if (argc <= 1) {
5405	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
5406	<	}
5407	<	{
5408	<	_v = PyString_Check(argv[1]) ? 1 : 0;
5409	<	}
4209	<	if (_v) {
4210	<	if (argc <= 2) {
4211	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4212	<	}
4213	<	{
4214	<	_v = (PyInt_Check(argv[2]) \|\| PyLong_Check(argv[2])) ? 1 : 0;
4215	<	}
4216	<	if (_v) {
4217	<	if (argc <= 3) {
4218	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4219	<	}
4220	<	{
4221	<	_v = (PyInt_Check(argv[3]) \|\| PyLong_Check(argv[3])) ? 1 : 0;
4222	<	}
4223	<	if (_v) {
4224	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4225	<	}
4226	<	}
4227	<	}
5403	>	}
5404	>	if (obj4) {
5405	>	{
5406	>	if (PyString_Check(obj4))
5407	>	arg5 = std::string(PyString_AsString(obj4));
5408	>	else
5409	>	SWIG_exception(SWIG_TypeError, "string expected");
5410		}
5411		}
5412	<
5413	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
5412	>	if (obj5) {
5413	>	{
5414	>	if (PyString_Check(obj5))
5415	>	arg6 = std::string(PyString_AsString(obj5));
5416	>	else
5417	>	SWIG_exception(SWIG_TypeError, "string expected");
5418	>	}
5419	>	}
5420	>	if (obj6) {
5421	>	{
5422	>	if (PyString_Check(obj6))
5423	>	arg7 = std::string(PyString_AsString(obj6));
5424	>	else
5425	>	SWIG_exception(SWIG_TypeError, "string expected");
5426	>	}
5427	>	}
5428	>	if (obj7) {
5429	>	{
5430	>	if (PyString_Check(obj7))
5431	>	arg8 = std::string(PyString_AsString(obj7));
5432	>	else
5433	>	SWIG_exception(SWIG_TypeError, "string expected");
5434	>	}
5435	>	}
5436	>	if (obj8) {
5437	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5438	>	if (PyErr_Occurred()) SWIG_fail;
5439	>	}
5440	>	{
5441	>	try {
5442	>	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9);
5443	>
5444	>	}catch (const BossSchedFailure & e) {
5445	>	PyErr_SetString ( SchedulerError, e.what() );
5446	>	return NULL;
5447	>	}catch (const std::exception& e) {
5448	>	PyErr_SetString ( BossError, e.what() );
5449	>	return NULL;
5450	>	}
5451	>	}
5452	>	resultobj = PyInt_FromLong((long)result);
5453	>	return resultobj;
5454	>	fail:
5455		return NULL;
5456		}
5457
#	Line 4245 \| Line 5468 \| *static PyObject _wrap_BossTask_query(Py**
5468		std::string arg6 = (std::string) "" ;
5469		std::string arg7 = (std::string) "" ;
5470		std::string arg8 = (std::string) "" ;
5471	<	bool arg9 = (bool) false ;
5471	>	unsigned int arg9 = (unsigned int) 0 ;
5472	>	bool arg10 = (bool) false ;
5473		int result;
5474		std::string temp3 ;
5475		std::string temp4 ;
#	Line 4257 \| Line 5481 \| *static PyObject _wrap_BossTask_query(Py**
5481		PyObject * obj6 = 0 ;
5482		PyObject * obj7 = 0 ;
5483		PyObject * obj8 = 0 ;
5484	+	PyObject * obj9 = 0 ;
5485
5486	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5486	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5487		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5488		if (obj2) {
5489		{
#	Line 4313 \| Line 5538 \| *static PyObject _wrap_BossTask_query(Py**
5538		}
5539		}
5540		if (obj8) {
5541	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5541	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5542	>	if (PyErr_Occurred()) SWIG_fail;
5543	>	}
5544	>	if (obj9) {
5545	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5546		if (PyErr_Occurred()) SWIG_fail;
5547		}
5548		{
5549		try {
5550	<	result = (int)(arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9);
5550	>	result = (int)(arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5551
5552	+	}catch (const BossSchedFailure & e) {
5553	+	PyErr_SetString ( SchedulerError, e.what() );
5554	+	return NULL;
5555		}catch (const std::exception& e) {
5556	<	SWIG_exception(SWIG_RuntimeError, e.what());
5556	>	PyErr_SetString ( BossError, e.what() );
5557	>	return NULL;
5558		}
5559		}
5560		resultobj = PyInt_FromLong((long)result);
#	Line 4379 \| Line 5612 \| *static PyObject _wrap_BossTask_query_ou**
5612		try {
5613		((BossTask const )arg1)->query_out(arg2,(jobStates const &)arg3,(printOption const &)arg4,arg5);
5614
5615	+	}catch (const BossSchedFailure & e) {
5616	+	PyErr_SetString ( SchedulerError, e.what() );
5617	+	return NULL;
5618		}catch (const std::exception& e) {
5619	<	SWIG_exception(SWIG_RuntimeError, e.what());
5619	>	PyErr_SetString ( BossError, e.what() );
5620	>	return NULL;
5621		}
5622		}
5623		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4401 \| Line 5638 \| *static PyObject _wrap_BossTask_clear(Py**
5638		try {
5639		(arg1)->clear();
5640
5641	+	}catch (const BossSchedFailure & e) {
5642	+	PyErr_SetString ( SchedulerError, e.what() );
5643	+	return NULL;
5644		}catch (const std::exception& e) {
5645	<	SWIG_exception(SWIG_RuntimeError, e.what());
5645	>	PyErr_SetString ( BossError, e.what() );
5646	>	return NULL;
5647		}
5648		}
5649		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4412 \| Line 5653 \| *static PyObject _wrap_BossTask_clear(Py**
5653		}
5654
5655
5656	<	static PyObject * BossTask_swigregister(PyObject self, PyObject args) {
5657	<	PyObject *obj;
5658	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5659	<	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5660	<	Py_INCREF(obj);
5661	<	return Py_BuildValue((char *)"");
5656	>	static PyObject _wrap_BossTask_appendToPyDict(PyObject self, PyObject *args) {
5657	>	PyObject *resultobj;
5658	>	BossTask arg1 = (BossTask ) 0 ;
5659	>	PyObject arg2 = (PyObject ) 0 ;
5660	>	BossAttributeContainer *arg3 = 0 ;
5661	>	PyObject * obj0 = 0 ;
5662	>	PyObject * obj1 = 0 ;
5663	>	PyObject * obj2 = 0 ;
5664	>
5665	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5666	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5667	>	arg2 = obj1;
5668	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5669	>	if (arg3 == NULL) {
5670	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5671	>	}
5672	>	{
5673	>	try {
5674	>	BossTask_appendToPyDict((BossTask const )arg1,arg2,(BossAttributeContainer const &)arg3);
5675	>
5676	>	}catch (const BossSchedFailure & e) {
5677	>	PyErr_SetString ( SchedulerError, e.what() );
5678	>	return NULL;
5679	>	}catch (const std::exception& e) {
5680	>	PyErr_SetString ( BossError, e.what() );
5681	>	return NULL;
5682	>	}
5683	>	}
5684	>	Py_INCREF(Py_None); resultobj = Py_None;
5685	>	return resultobj;
5686	>	fail:
5687	>	return NULL;
5688		}
5689	<	static PyObject _wrap_prompt(PyObject self, PyObject *args) {
5689	>
5690	>
5691	>	static PyObject _wrap_BossTask_jobDict(PyObject self, PyObject *args) {
5692		PyObject *resultobj;
5693	<	std::string *arg1 = 0 ;
5694	<	bool result;
5695	<	std::string temp1 ;
5693	>	BossTask arg1 = (BossTask ) 0 ;
5694	>	BossJob arg2 = (BossJob ) 0 ;
5695	>	PyObject arg3 = (PyObject ) 0 ;
5696		PyObject * obj0 = 0 ;
5697	+	PyObject * obj1 = 0 ;
5698	+	PyObject * obj2 = 0 ;
5699
5700	<	if(!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) goto fail;
5700	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5701	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5702	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5703	>	arg3 = obj2;
5704		{
5705	<	if (PyString_Check(obj0)) {
5706	<	temp1 = std::string(PyString_AsString(obj0));
5707	<	arg1 = &temp1;
5705	>	try {
5706	>	BossTask_jobDict((BossTask const )arg1,(BossJob const )arg2,arg3);
5707	>
5708	>	}catch (const BossSchedFailure & e) {
5709	>	PyErr_SetString ( SchedulerError, e.what() );
5710	>	return NULL;
5711	>	}catch (const std::exception& e) {
5712	>	PyErr_SetString ( BossError, e.what() );
5713	>	return NULL;
5714	>	}
5715	>	}
5716	>	Py_INCREF(Py_None); resultobj = Py_None;
5717	>	return resultobj;
5718	>	fail:
5719	>	return NULL;
5720	>	}
5721	>
5722	>
5723	>	static PyObject _wrap_BossTask_jobsDict(PyObject self, PyObject *args) {
5724	>	PyObject *resultobj;
5725	>	BossTask arg1 = (BossTask ) 0 ;
5726	>	PyObject *result;
5727	>	PyObject * obj0 = 0 ;
5728	>
5729	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5730	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5731	>	{
5732	>	try {
5733	>	result = (PyObject *)BossTask_jobsDict(arg1);
5734	>
5735	>	}catch (const BossSchedFailure & e) {
5736	>	PyErr_SetString ( SchedulerError, e.what() );
5737	>	return NULL;
5738	>	}catch (const std::exception& e) {
5739	>	PyErr_SetString ( BossError, e.what() );
5740	>	return NULL;
5741	>	}
5742	>	}
5743	>	resultobj = result;
5744	>	return resultobj;
5745	>	fail:
5746	>	return NULL;
5747	>	}
5748	>
5749	>
5750	>	static PyObject _wrap_BossTask_job(PyObject self, PyObject *args) {
5751	>	PyObject *resultobj;
5752	>	BossTask arg1 = (BossTask ) 0 ;
5753	>	std::string *arg2 = 0 ;
5754	>	PyObject *result;
5755	>	std::string temp2 ;
5756	>	PyObject * obj0 = 0 ;
5757	>	PyObject * obj1 = 0 ;
5758	>
5759	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5760	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5761	>	{
5762	>	if (PyString_Check(obj1)) {
5763	>	temp2 = std::string(PyString_AsString(obj1));
5764	>	arg2 = &temp2;
5765		}else {
5766		SWIG_exception(SWIG_TypeError, "string expected");
5767		}
5768		}
5769		{
5770		try {
5771	<	result = (bool)prompt((std::string const &)*arg1);
5771	>	result = (PyObject )BossTask_job(arg1,(std::string const &)arg2);
5772
5773	+	}catch (const BossSchedFailure & e) {
5774	+	PyErr_SetString ( SchedulerError, e.what() );
5775	+	return NULL;
5776		}catch (const std::exception& e) {
5777	<	SWIG_exception(SWIG_RuntimeError, e.what());
5777	>	PyErr_SetString ( BossError, e.what() );
5778	>	return NULL;
5779		}
5780		}
5781	<	resultobj = PyInt_FromLong((long)result);
5781	>	resultobj = result;
5782	>	return resultobj;
5783	>	fail:
5784	>	return NULL;
5785	>	}
5786	>
5787	>
5788	>	static PyObject _wrap_BossTask_Chain(PyObject self, PyObject *args) {
5789	>	PyObject *resultobj;
5790	>	BossTask arg1 = (BossTask ) 0 ;
5791	>	std::string *arg2 = 0 ;
5792	>	PyObject *result;
5793	>	std::string temp2 ;
5794	>	PyObject * obj0 = 0 ;
5795	>	PyObject * obj1 = 0 ;
5796	>
5797	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5798	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5799	>	{
5800	>	if (PyString_Check(obj1)) {
5801	>	temp2 = std::string(PyString_AsString(obj1));
5802	>	arg2 = &temp2;
5803	>	}else {
5804	>	SWIG_exception(SWIG_TypeError, "string expected");
5805	>	}
5806	>	}
5807	>	{
5808	>	try {
5809	>	result = (PyObject )BossTask_Chain(arg1,(std::string const &)arg2);
5810	>
5811	>	}catch (const BossSchedFailure & e) {
5812	>	PyErr_SetString ( SchedulerError, e.what() );
5813	>	return NULL;
5814	>	}catch (const std::exception& e) {
5815	>	PyErr_SetString ( BossError, e.what() );
5816	>	return NULL;
5817	>	}
5818	>	}
5819	>	resultobj = result;
5820	>	return resultobj;
5821	>	fail:
5822	>	return NULL;
5823	>	}
5824	>
5825	>
5826	>	static PyObject _wrap_BossTask_jobStates(PyObject self, PyObject *args) {
5827	>	PyObject *resultobj;
5828	>	BossTask arg1 = (BossTask ) 0 ;
5829	>	PyObject *result;
5830	>	PyObject * obj0 = 0 ;
5831	>
5832	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5833	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5834	>	{
5835	>	try {
5836	>	result = (PyObject *)BossTask_jobStates(arg1);
5837	>
5838	>	}catch (const BossSchedFailure & e) {
5839	>	PyErr_SetString ( SchedulerError, e.what() );
5840	>	return NULL;
5841	>	}catch (const std::exception& e) {
5842	>	PyErr_SetString ( BossError, e.what() );
5843	>	return NULL;
5844	>	}
5845	>	}
5846	>	resultobj = result;
5847	>	return resultobj;
5848	>	fail:
5849	>	return NULL;
5850	>	}
5851	>
5852	>
5853	>	static PyObject _wrap_BossTask_jobStatistic(PyObject self, PyObject *args) {
5854	>	PyObject *resultobj;
5855	>	BossTask arg1 = (BossTask ) 0 ;
5856	>	PyObject *result;
5857	>	PyObject * obj0 = 0 ;
5858	>
5859	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5860	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5861	>	{
5862	>	try {
5863	>	result = (PyObject *)BossTask_jobStatistic(arg1);
5864	>
5865	>	}catch (const BossSchedFailure & e) {
5866	>	PyErr_SetString ( SchedulerError, e.what() );
5867	>	return NULL;
5868	>	}catch (const std::exception& e) {
5869	>	PyErr_SetString ( BossError, e.what() );
5870	>	return NULL;
5871	>	}
5872	>	}
5873	>	resultobj = result;
5874		return resultobj;
5875		fail:
5876		return NULL;
5877		}
5878
5879
5880	+	static PyObject _wrap_BossTask_progDict(PyObject self, PyObject *args) {
5881	+	PyObject *resultobj;
5882	+	BossTask arg1 = (BossTask ) 0 ;
5883	+	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5884	+	PyObject *result;
5885	+	PyObject * obj0 = 0 ;
5886	+	PyObject * obj1 = 0 ;
5887	+
5888	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5889	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5890	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5891	+	if (arg2 == NULL) {
5892	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5893	+	}
5894	+	{
5895	+	try {
5896	+	result = (PyObject )BossTask_progDict((BossTask const )arg1,*arg2);
5897	+
5898	+	}catch (const BossSchedFailure & e) {
5899	+	PyErr_SetString ( SchedulerError, e.what() );
5900	+	return NULL;
5901	+	}catch (const std::exception& e) {
5902	+	PyErr_SetString ( BossError, e.what() );
5903	+	return NULL;
5904	+	}
5905	+	}
5906	+	resultobj = result;
5907	+	return resultobj;
5908	+	fail:
5909	+	return NULL;
5910	+	}
5911	+
5912	+
5913	+	static PyObject _wrap_BossTask_jobPrograms(PyObject self, PyObject *args) {
5914	+	PyObject *resultobj;
5915	+	BossTask arg1 = (BossTask ) 0 ;
5916	+	std::string *arg2 = 0 ;
5917	+	PyObject *result;
5918	+	std::string temp2 ;
5919	+	PyObject * obj0 = 0 ;
5920	+	PyObject * obj1 = 0 ;
5921	+
5922	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5923	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5924	+	{
5925	+	if (PyString_Check(obj1)) {
5926	+	temp2 = std::string(PyString_AsString(obj1));
5927	+	arg2 = &temp2;
5928	+	}else {
5929	+	SWIG_exception(SWIG_TypeError, "string expected");
5930	+	}
5931	+	}
5932	+	{
5933	+	try {
5934	+	result = (PyObject )BossTask_jobPrograms((BossTask const )arg1,(std::string const &)*arg2);
5935	+
5936	+	}catch (const BossSchedFailure & e) {
5937	+	PyErr_SetString ( SchedulerError, e.what() );
5938	+	return NULL;
5939	+	}catch (const std::exception& e) {
5940	+	PyErr_SetString ( BossError, e.what() );
5941	+	return NULL;
5942	+	}
5943	+	}
5944	+	resultobj = result;
5945	+	return resultobj;
5946	+	fail:
5947	+	return NULL;
5948	+	}
5949	+
5950	+
5951	+	static PyObject _wrap_BossTask_program(PyObject self, PyObject *args) {
5952	+	PyObject *resultobj;
5953	+	BossTask arg1 = (BossTask ) 0 ;
5954	+	std::string *arg2 = 0 ;
5955	+	std::string *arg3 = 0 ;
5956	+	PyObject *result;
5957	+	std::string temp2 ;
5958	+	std::string temp3 ;
5959	+	PyObject * obj0 = 0 ;
5960	+	PyObject * obj1 = 0 ;
5961	+	PyObject * obj2 = 0 ;
5962	+
5963	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5964	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5965	+	{
5966	+	if (PyString_Check(obj1)) {
5967	+	temp2 = std::string(PyString_AsString(obj1));
5968	+	arg2 = &temp2;
5969	+	}else {
5970	+	SWIG_exception(SWIG_TypeError, "string expected");
5971	+	}
5972	+	}
5973	+	{
5974	+	if (PyString_Check(obj2)) {
5975	+	temp3 = std::string(PyString_AsString(obj2));
5976	+	arg3 = &temp3;
5977	+	}else {
5978	+	SWIG_exception(SWIG_TypeError, "string expected");
5979	+	}
5980	+	}
5981	+	{
5982	+	try {
5983	+	result = (PyObject )BossTask_program(arg1,(std::string const &)arg2,(std::string const &)*arg3);
5984	+
5985	+	}catch (const BossSchedFailure & e) {
5986	+	PyErr_SetString ( SchedulerError, e.what() );
5987	+	return NULL;
5988	+	}catch (const std::exception& e) {
5989	+	PyErr_SetString ( BossError, e.what() );
5990	+	return NULL;
5991	+	}
5992	+	}
5993	+	resultobj = result;
5994	+	return resultobj;
5995	+	fail:
5996	+	return NULL;
5997	+	}
5998	+
5999	+
6000	+	static PyObject _wrap_BossTask_programExec(PyObject self, PyObject *args) {
6001	+	PyObject *resultobj;
6002	+	BossTask arg1 = (BossTask ) 0 ;
6003	+	std::string *arg2 = 0 ;
6004	+	std::string *arg3 = 0 ;
6005	+	PyObject *result;
6006	+	std::string temp2 ;
6007	+	std::string temp3 ;
6008	+	PyObject * obj0 = 0 ;
6009	+	PyObject * obj1 = 0 ;
6010	+	PyObject * obj2 = 0 ;
6011	+
6012	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
6013	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
6014	+	{
6015	+	if (PyString_Check(obj1)) {
6016	+	temp2 = std::string(PyString_AsString(obj1));
6017	+	arg2 = &temp2;
6018	+	}else {
6019	+	SWIG_exception(SWIG_TypeError, "string expected");
6020	+	}
6021	+	}
6022	+	{
6023	+	if (PyString_Check(obj2)) {
6024	+	temp3 = std::string(PyString_AsString(obj2));
6025	+	arg3 = &temp3;
6026	+	}else {
6027	+	SWIG_exception(SWIG_TypeError, "string expected");
6028	+	}
6029	+	}
6030	+	{
6031	+	try {
6032	+	result = (PyObject )BossTask_programExec(arg1,(std::string const &)arg2,(std::string const &)*arg3);
6033	+
6034	+	}catch (const BossSchedFailure & e) {
6035	+	PyErr_SetString ( SchedulerError, e.what() );
6036	+	return NULL;
6037	+	}catch (const std::exception& e) {
6038	+	PyErr_SetString ( BossError, e.what() );
6039	+	return NULL;
6040	+	}
6041	+	}
6042	+	resultobj = result;
6043	+	return resultobj;
6044	+	fail:
6045	+	return NULL;
6046	+	}
6047	+
6048	+
6049	+	static PyObject _wrap_BossTask_specific(PyObject self, PyObject *args) {
6050	+	PyObject *resultobj;
6051	+	BossTask arg1 = (BossTask ) 0 ;
6052	+	std::string *arg2 = 0 ;
6053	+	std::string *arg3 = 0 ;
6054	+	PyObject *result;
6055	+	std::string temp2 ;
6056	+	std::string temp3 ;
6057	+	PyObject * obj0 = 0 ;
6058	+	PyObject * obj1 = 0 ;
6059	+	PyObject * obj2 = 0 ;
6060	+
6061	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
6062	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
6063	+	{
6064	+	if (PyString_Check(obj1)) {
6065	+	temp2 = std::string(PyString_AsString(obj1));
6066	+	arg2 = &temp2;
6067	+	}else {
6068	+	SWIG_exception(SWIG_TypeError, "string expected");
6069	+	}
6070	+	}
6071	+	{
6072	+	if (PyString_Check(obj2)) {
6073	+	temp3 = std::string(PyString_AsString(obj2));
6074	+	arg3 = &temp3;
6075	+	}else {
6076	+	SWIG_exception(SWIG_TypeError, "string expected");
6077	+	}
6078	+	}
6079	+	{
6080	+	try {
6081	+	result = (PyObject )BossTask_specific(arg1,(std::string const &)arg2,(std::string const &)*arg3);
6082	+
6083	+	}catch (const BossSchedFailure & e) {
6084	+	PyErr_SetString ( SchedulerError, e.what() );
6085	+	return NULL;
6086	+	}catch (const std::exception& e) {
6087	+	PyErr_SetString ( BossError, e.what() );
6088	+	return NULL;
6089	+	}
6090	+	}
6091	+	resultobj = result;
6092	+	return resultobj;
6093	+	fail:
6094	+	return NULL;
6095	+	}
6096	+
6097	+
6098	+	static PyObject * BossTask_swigregister(PyObject self, PyObject args) {
6099	+	PyObject *obj;
6100	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6101	+	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
6102	+	Py_INCREF(obj);
6103	+	return Py_BuildValue((char *)"");
6104	+	}
6105		static PyObject _wrap_new_BossAdministratorSession(PyObject self, PyObject *args) {
6106		PyObject *resultobj;
6107		std::string arg1 = (std::string) "" ;
6108	<	bool arg2 = (bool) false ;
6108	>	std::string arg2 = (std::string) "2" ;
6109	>	std::string arg3 = (std::string) "" ;
6110	>	std::string arg4 = (std::string) "" ;
6111	>	bool arg5 = (bool) false ;
6112		BossAdministratorSession *result;
6113		PyObject * obj0 = 0 ;
6114		PyObject * obj1 = 0 ;
6115	+	PyObject * obj2 = 0 ;
6116	+	PyObject * obj3 = 0 ;
6117	+	PyObject * obj4 = 0 ;
6118
6119	<	if(!PyArg_ParseTuple(args,(char *)"\|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
6119	>	if(!PyArg_ParseTuple(args,(char *)"\|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6120		if (obj0) {
6121		{
6122		if (PyString_Check(obj0))
#	Line 4468 \| Line 6126 \| *static PyObject _wrap_new_BossAdministr**
6126		}
6127		}
6128		if (obj1) {
6129	<	arg2 = PyInt_AsLong(obj1) ? true : false;
6129	>	{
6130	>	if (PyString_Check(obj1))
6131	>	arg2 = std::string(PyString_AsString(obj1));
6132	>	else
6133	>	SWIG_exception(SWIG_TypeError, "string expected");
6134	>	}
6135	>	}
6136	>	if (obj2) {
6137	>	{
6138	>	if (PyString_Check(obj2))
6139	>	arg3 = std::string(PyString_AsString(obj2));
6140	>	else
6141	>	SWIG_exception(SWIG_TypeError, "string expected");
6142	>	}
6143	>	}
6144	>	if (obj3) {
6145	>	{
6146	>	if (PyString_Check(obj3))
6147	>	arg4 = std::string(PyString_AsString(obj3));
6148	>	else
6149	>	SWIG_exception(SWIG_TypeError, "string expected");
6150	>	}
6151	>	}
6152	>	if (obj4) {
6153	>	arg5 = PyInt_AsLong(obj4) ? true : false;
6154		if (PyErr_Occurred()) SWIG_fail;
6155		}
6156		{
6157		try {
6158	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
6158	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
6159
6160	+	}catch (const BossSchedFailure & e) {
6161	+	PyErr_SetString ( SchedulerError, e.what() );
6162	+	return NULL;
6163		}catch (const std::exception& e) {
6164	<	SWIG_exception(SWIG_RuntimeError, e.what());
6164	>	PyErr_SetString ( BossError, e.what() );
6165	>	return NULL;
6166		}
6167		}
6168		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4497 \| Line 6183 \| *static PyObject _wrap_delete_BossAdmini**
6183		try {
6184		delete arg1;
6185
6186	+	}catch (const BossSchedFailure & e) {
6187	+	PyErr_SetString ( SchedulerError, e.what() );
6188	+	return NULL;
6189		}catch (const std::exception& e) {
6190	<	SWIG_exception(SWIG_RuntimeError, e.what());
6190	>	PyErr_SetString ( BossError, e.what() );
6191	>	return NULL;
6192		}
6193		}
6194		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4520 \| Line 6210 \| *static PyObject _wrap_BossAdministrator**
6210		try {
6211		result = (int)(arg1)->configureDB();
6212
6213	+	}catch (const BossSchedFailure & e) {
6214	+	PyErr_SetString ( SchedulerError, e.what() );
6215	+	return NULL;
6216		}catch (const std::exception& e) {
6217	<	SWIG_exception(SWIG_RuntimeError, e.what());
6217	>	PyErr_SetString ( BossError, e.what() );
6218	>	return NULL;
6219		}
6220		}
6221		resultobj = PyInt_FromLong((long)result);
#	Line 4554 \| Line 6248 \| *static PyObject _wrap_BossAdministrator**
6248		try {
6249		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
6250
6251	+	}catch (const BossSchedFailure & e) {
6252	+	PyErr_SetString ( SchedulerError, e.what() );
6253	+	return NULL;
6254		}catch (const std::exception& e) {
6255	<	SWIG_exception(SWIG_RuntimeError, e.what());
6255	>	PyErr_SetString ( BossError, e.what() );
6256	>	return NULL;
6257		}
6258		}
6259		resultobj = PyInt_FromLong((long)result);
#	Line 4588 \| Line 6286 \| *static PyObject _wrap_BossAdministrator**
6286		try {
6287		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
6288
6289	+	}catch (const BossSchedFailure & e) {
6290	+	PyErr_SetString ( SchedulerError, e.what() );
6291	+	return NULL;
6292		}catch (const std::exception& e) {
6293	<	SWIG_exception(SWIG_RuntimeError, e.what());
6293	>	PyErr_SetString ( BossError, e.what() );
6294	>	return NULL;
6295		}
6296		}
6297		resultobj = PyInt_FromLong((long)result);
#	Line 4622 \| Line 6324 \| *static PyObject _wrap_BossAdministrator**
6324		try {
6325		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
6326
6327	+	}catch (const BossSchedFailure & e) {
6328	+	PyErr_SetString ( SchedulerError, e.what() );
6329	+	return NULL;
6330		}catch (const std::exception& e) {
6331	<	SWIG_exception(SWIG_RuntimeError, e.what());
6331	>	PyErr_SetString ( BossError, e.what() );
6332	>	return NULL;
6333		}
6334		}
6335		resultobj = PyInt_FromLong((long)result);
#	Line 4656 \| Line 6362 \| *static PyObject _wrap_BossAdministrator**
6362		try {
6363		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
6364
6365	+	}catch (const BossSchedFailure & e) {
6366	+	PyErr_SetString ( SchedulerError, e.what() );
6367	+	return NULL;
6368		}catch (const std::exception& e) {
6369	<	SWIG_exception(SWIG_RuntimeError, e.what());
6369	>	PyErr_SetString ( BossError, e.what() );
6370	>	return NULL;
6371		}
6372		}
6373		resultobj = PyInt_FromLong((long)result);
#	Line 4690 \| Line 6400 \| *static PyObject _wrap_BossAdministrator**
6400		try {
6401		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
6402
6403	+	}catch (const BossSchedFailure & e) {
6404	+	PyErr_SetString ( SchedulerError, e.what() );
6405	+	return NULL;
6406		}catch (const std::exception& e) {
6407	<	SWIG_exception(SWIG_RuntimeError, e.what());
6407	>	PyErr_SetString ( BossError, e.what() );
6408	>	return NULL;
6409		}
6410		}
6411		resultobj = PyInt_FromLong((long)result);
#	Line 4756 \| Line 6470 \| *static PyObject _wrap_BossAdministrator**
6470		try {
6471		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
6472
6473	+	}catch (const BossSchedFailure & e) {
6474	+	PyErr_SetString ( SchedulerError, e.what() );
6475	+	return NULL;
6476		}catch (const std::exception& e) {
6477	<	SWIG_exception(SWIG_RuntimeError, e.what());
6477	>	PyErr_SetString ( BossError, e.what() );
6478	>	return NULL;
6479		}
6480		}
6481		resultobj = PyInt_FromLong((long)result);
#	Line 4846 \| Line 6564 \| *static PyObject _wrap_BossAdministrator**
6564		try {
6565		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
6566
6567	+	}catch (const BossSchedFailure & e) {
6568	+	PyErr_SetString ( SchedulerError, e.what() );
6569	+	return NULL;
6570		}catch (const std::exception& e) {
6571	<	SWIG_exception(SWIG_RuntimeError, e.what());
6571	>	PyErr_SetString ( BossError, e.what() );
6572	>	return NULL;
6573		}
6574		}
6575		resultobj = PyInt_FromLong((long)result);
#	Line 4922 \| Line 6644 \| *static PyObject _wrap_BossAdministrator**
6644		try {
6645		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6646
6647	+	}catch (const BossSchedFailure & e) {
6648	+	PyErr_SetString ( SchedulerError, e.what() );
6649	+	return NULL;
6650		}catch (const std::exception& e) {
6651	<	SWIG_exception(SWIG_RuntimeError, e.what());
6651	>	PyErr_SetString ( BossError, e.what() );
6652	>	return NULL;
6653		}
6654		}
6655		resultobj = PyInt_FromLong((long)result);
#	Line 4951 \| Line 6677 \| *static PyObject _wrap_BossAdministrator**
6677		std::string arg13 = (std::string) "" ;
6678		bool arg14 = (bool) false ;
6679		bool arg15 = (bool) false ;
6680	+	bool arg16 = (bool) false ;
6681	+	bool arg17 = (bool) false ;
6682		int result;
6683		std::string temp2 ;
6684		std::string temp11 ;
#	Line 4969 \| Line 6697 \| *static PyObject _wrap_BossAdministrator**
6697		PyObject * obj12 = 0 ;
6698		PyObject * obj13 = 0 ;
6699		PyObject * obj14 = 0 ;
6700	+	PyObject * obj15 = 0 ;
6701	+	PyObject * obj16 = 0 ;
6702
6703	<	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;
6703	>	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;
6704		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
6705		{
6706		if (PyString_Check(obj1)) {
#	Line 5078 \| Line 6808 \| *static PyObject _wrap_BossAdministrator**
6808		arg15 = PyInt_AsLong(obj14) ? true : false;
6809		if (PyErr_Occurred()) SWIG_fail;
6810		}
6811	+	if (obj15) {
6812	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6813	+	if (PyErr_Occurred()) SWIG_fail;
6814	+	}
6815	+	if (obj16) {
6816	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6817	+	if (PyErr_Occurred()) SWIG_fail;
6818	+	}
6819		{
6820		try {
6821	<	result = (int)(arg1)->registerScheduler((std::string const &)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)arg11,arg12,arg13,arg14,arg15);
6821	>	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);
6822
6823	+	}catch (const BossSchedFailure & e) {
6824	+	PyErr_SetString ( SchedulerError, e.what() );
6825	+	return NULL;
6826		}catch (const std::exception& e) {
6827	<	SWIG_exception(SWIG_RuntimeError, e.what());
6827	>	PyErr_SetString ( BossError, e.what() );
6828	>	return NULL;
6829		}
6830		}
6831		resultobj = PyInt_FromLong((long)result);
#	Line 5105 \| Line 6847 \| *static PyObject _wrap_BossAdministrator**
6847		try {
6848		result = (arg1)->help();
6849
6850	+	}catch (const BossSchedFailure & e) {
6851	+	PyErr_SetString ( SchedulerError, e.what() );
6852	+	return NULL;
6853		}catch (const std::exception& e) {
6854	<	SWIG_exception(SWIG_RuntimeError, e.what());
6854	>	PyErr_SetString ( BossError, e.what() );
6855	>	return NULL;
6856		}
6857		}
6858		{
#	Line 5144 \| Line 6890 \| *static PyObject _wrap_BossAdministrator**
6890		try {
6891		result = (arg1)->SQL(arg2,arg3);
6892
6893	+	}catch (const BossSchedFailure & e) {
6894	+	PyErr_SetString ( SchedulerError, e.what() );
6895	+	return NULL;
6896		}catch (const std::exception& e) {
6897	<	SWIG_exception(SWIG_RuntimeError, e.what());
6897	>	PyErr_SetString ( BossError, e.what() );
6898	>	return NULL;
6899		}
6900		}
6901		{
#	Line 5216 \| Line 6966 \| *static PyObject _wrap_BossAdministrator**
6966		try {
6967		result = (int)(arg1)->purge((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5);
6968
6969	+	}catch (const BossSchedFailure & e) {
6970	+	PyErr_SetString ( SchedulerError, e.what() );
6971	+	return NULL;
6972	+	}catch (const std::exception& e) {
6973	+	PyErr_SetString ( BossError, e.what() );
6974	+	return NULL;
6975	+	}
6976	+	}
6977	+	resultobj = PyInt_FromLong((long)result);
6978	+	return resultobj;
6979	+	fail:
6980	+	return NULL;
6981	+	}
6982	+
6983	+
6984	+	static PyObject _wrap_BossAdministratorSession_registerPlugins(PyObject self, PyObject *args) {
6985	+	PyObject *resultobj;
6986	+	BossAdministratorSession arg1 = (BossAdministratorSession ) 0 ;
6987	+	std::string arg2 ;
6988	+	int result;
6989	+	PyObject * obj0 = 0 ;
6990	+	PyObject * obj1 = 0 ;
6991	+
6992	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6993	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
6994	+	{
6995	+	if (PyString_Check(obj1))
6996	+	arg2 = std::string(PyString_AsString(obj1));
6997	+	else
6998	+	SWIG_exception(SWIG_TypeError, "string expected");
6999	+	}
7000	+	{
7001	+	try {
7002	+	result = (int)(arg1)->registerPlugins(arg2);
7003	+
7004	+	}catch (const BossSchedFailure & e) {
7005	+	PyErr_SetString ( SchedulerError, e.what() );
7006	+	return NULL;
7007		}catch (const std::exception& e) {
7008	<	SWIG_exception(SWIG_RuntimeError, e.what());
7008	>	PyErr_SetString ( BossError, e.what() );
7009	>	return NULL;
7010		}
7011		}
7012		resultobj = PyInt_FromLong((long)result);
#	Line 5250 \| Line 7039 \| static PyMethodDef SwigMethods[] = {
7039		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
7040		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
7041		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
7042	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7043	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
7044	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
7045	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
7046	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
7047	<	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
7048	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7042	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
7043	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
7044	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
7045	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
7046	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
7047	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
7048	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
7049	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
7050	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
7051	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
7052	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
7053	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
7054	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
7055	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
7056		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
7057		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
7058	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
7059		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
7060		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
7061		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
7062	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
7063	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
7064	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
7065	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
7066		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
7067		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
7068		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5270 \| Line 7071 \| static PyMethodDef SwigMethods[] = {
7071		{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
7072		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
7073		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
7074	+	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
7075		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7076		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
7077	+	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
7078	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
7079	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
7080	+	{ (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
7081	+	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
7082	+	{ (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
7083	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7084	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7085	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
7086	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
7087	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
7088	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7089	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7090		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5276	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5277	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7091		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
5279	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7092		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7093		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7094	<	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7095	<	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7096	<	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7097	<	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7098	<	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7094	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7095	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7096	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7097	>	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7098	>	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
7099		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
7100		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7101		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7102		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7103	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7104		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
7105	<	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5293	<	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7105	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7106		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
7107		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
5296	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7108		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7109		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7110		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
#	Line 5301 \| Line 7112 \| static PyMethodDef SwigMethods[] = {
7112		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
7113		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
7114		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7115	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7116	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7117	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7118		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7119		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7120		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7121	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7122	+	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7123	+	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7124	+	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7125	+	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7126	+	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7127	+	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7128	+	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7129	+	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7130	+	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7131	+	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7132	+	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7133		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5308	–	{ (char *)"prompt", _wrap_prompt, METH_VARARGS },
7134		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7135		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
7136		{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
#	Line 5321 \| Line 7146 \| static PyMethodDef SwigMethods[] = {
7146		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
7147		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
7148		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
7149	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
7150		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
7151		{ NULL, NULL }
7152		};
#	Line 5328 \| Line 7154 \| static PyMethodDef SwigMethods[] = {
7154
7155		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7156
5331	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7157		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}};
7158	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7159		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}};
7160	+	static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7161	+	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}};
7162	+	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7163		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}};
7164		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7165		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7166		static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7167	<	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7167	>	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7168		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7169	+	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7170		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
7171		static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
7172		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
#	Line 5348 \| Line 7178 \| static swig_type_info _swigt__p_std__vec
7178		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7179
7180		static swig_type_info *swig_types_initial[] = {
5351	–	_swigt__p_XMLDoc,
7181		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
7182	+	_swigt__p_XMLDoc,
7183		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7184	+	_swigt__p_BossProgramExec,
7185	+	_swigt__p_std__vectorTBossTask_p_t,
7186	+	_swigt__p_BossChain,
7187		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
7188		_swigt__p_BossTask,
7189		_swigt__p_BossTaskException,
7190		_swigt__p_std__ostream,
7191	<	_swigt__p_BossAttributeContainer,
7191	>	_swigt__p_BossProgram,
7192		_swigt__p_printOption,
7193	+	_swigt__p_BossAttributeContainer,
7194		_swigt__p_BossJob,
7195		_swigt__p_BossDatabase,
7196		_swigt__p_BossSession,
#	Line 5408 \| Line 7242 \| SWIGEXPORT(void) SWIG_init(void) {
7242		}
7243		SWIG_InstallConstants(d,swig_const_table);
7244
7245	+
7246	+	// define custom exceptions
7247	+	PyObject *e;
7248	+	PyMethodDef tp_methods = {
7249	+	NULL, NULL, 0, NULL
7250	+	};
7251	+	e = Py_InitModule("BossSession", &tp_methods);
7252	+	// generic BOSS exception
7253	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
7254	+	Py_INCREF(BossError);
7255	+	PyModule_AddObject(e, "BossError", BossError);
7256	+	// scheduler interaction BOSS exception
7257	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
7258	+	Py_INCREF(SchedulerError);
7259	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
7260	+
7261		}
7262

Diff Legend

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents): Revision 1.8 by gcodispo, Fri Oct 27 15:24:50 2006 UTC vs. Revision 1.32 by gcodispo, Fri May 18 16:10:19 2007 UTC

Diff Legend

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.8 by gcodispo, Fri Oct 27 15:24:50 2006 UTC vs.
Revision 1.32 by gcodispo, Fri May 18 16:10:19 2007 UTC