ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.4 by gcodispo, Thu Oct 26 13:17:48 2006 UTC vs.
Revision 1.40 by gcodispo, Thu Nov 22 16:46:09 2007 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t swig_types[0]
658	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[1]
659	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[2]
660	<	#define  SWIGTYPE_p_XMLDoc swig_types[3]
661	<	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662	<	#define  SWIGTYPE_p_std__ostream swig_types[5]
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_BossProgramExec swig_types[3]
661	>	#define  SWIGTYPE_p_BossChain swig_types[4]
662	>	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[5]
663		#define  SWIGTYPE_p_BossTask swig_types[6]
664		#define  SWIGTYPE_p_BossTaskException swig_types[7]
665	<	#define  SWIGTYPE_p_std__string swig_types[8]
666	<	#define  SWIGTYPE_p_BossAttributeContainer swig_types[9]
665	>	#define  SWIGTYPE_p_std__ostream swig_types[8]
666	>	#define  SWIGTYPE_p_BossProgram swig_types[9]
667		#define  SWIGTYPE_p_printOption swig_types[10]
668	<	#define  SWIGTYPE_p_BossDatabase swig_types[11]
668	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[11]
669		#define  SWIGTYPE_p_BossJob swig_types[12]
670	<	#define  SWIGTYPE_p_BossSession swig_types[13]
671	<	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[14]
672	<	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[15]
673	<	#define  SWIGTYPE_p_BossAdministratorSession swig_types[16]
674	<	#define  SWIGTYPE_p_jobStates swig_types[17]
675	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[18]
676	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[19]
677	<	static swig_type_info *swig_types[21];
670	>	#define  SWIGTYPE_p_BossDatabase swig_types[13]
671	>	#define  SWIGTYPE_p_BossSession swig_types[14]
672	>	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[15]
673	>	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[16]
674	>	#define  SWIGTYPE_p_BossAdministratorSession swig_types[17]
675	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[18]
676	>	#define  SWIGTYPE_p_BossSession__task_iterator swig_types[19]
677	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[20]
678	>	#define  SWIGTYPE_p_jobStates swig_types[21]
679	>	static swig_type_info *swig_types[23];
680
681		/* -------- TYPES TABLE (END) -------- */
682
#	Line 852 | 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 873 | 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_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){
965	<	self->jobQuery ( filter_opt, taskRange, jobRange, subn,
966	<	type, user, after, before, avoidCheck);
967	<	PyObject * job_dict = PyList_New(0);
968	<	std::vector <std::string>
969	<	taskList = self->selectTasks( taskRange, before, after, user);
970	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
971	<	it!= taskList.end(); ++it ) {
972	<	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
973	<	}
974	<
975	<	//       int size = taskList.size();
976	<	//       PyObject * job_dict = PyList_New(0);
977	<	//       for ( unsigned int i = 0; i < size; ++i ) {
978	<	//      PyList_SetItem(job_dict,i, );
979	<	//      self->makeBossTask( *it );
980	<	//       }
981	<	return  job_dict;
982	<	}
983	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
984	<	std::string tmp;
985	<	BossAttributeContainer::const_iterator it_end = obj.end ();
986	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
915	<	it != it_end; ++it) {
916	<	tmp = (*it).first.name ();
917	<	char * key = new char[ tmp.size() ];
918	<	key = strdup(tmp.c_str());
919	<	tmp = (*it).second.value ();
920	<	PyObject * val = PyString_FromString( tmp.c_str() );
921	<	PyDict_SetItemString( dict, key, val );
922	<	delete [] key;
923	<	}
924	<	return dict;
964	>	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout){
965	>	std::vector<std::string> my_vec = self->listMatch( scheduler,
966	>	schclassad,
967	>	taskid,
968	>	jobid,
969	>	timeout);
970	>	return BossSession_show( self, my_vec );
971	>	}
972	>	void BossSession_schedulerQuery(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,unsigned int timeout,bool avoidCheck){
973	>	self->query ( filter_opt, taskRange, jobRange, subn, type, user, after, before, timeout, avoidCheck );
974	>	return;
975	>	}
976	>	void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
977	>
978	>	BossAttributeContainer::const_iterator it_end = obj.end ();
979	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
980	>	it != it_end; ++it) {
981	>
982	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
983	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
984	>	PyDict_SetItem( dict, key, val);
985	>	Py_DECREF(key);
986	>	Py_DECREF(val);
987		}
988	<	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
988	>	return;
989	>	}
990	>	void BossTask_jobDict(BossTask const *self,BossJob const *jobH,PyObject *job_dict){
991
992	<	PyObject * job_dict = PyDict_New();
992	>	//    PyObject * job_dict = PyDict_New();
993		std::string tmp;
994
995	<	BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
996	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
995	>	BossAttributeContainer obj = jobH->getTableEntries("JOB");
996	>	BossTask_appendToPyDict ( self, job_dict, obj );
997
998	<	std::set<std::string> sch = (*jit)->getSchedulerElements();
998	>	std::set<std::string> sch = jobH->getSchedulerElements();
999		std::set<std::string>::const_iterator sch_end =  sch.end();
1000		for (std::set<std::string>::const_iterator it =sch.begin();
1001		it != sch_end; ++ it ) {
1002	<	tmp = (*it);
1003	<	char * key = new char[ tmp.size() ];
1004	<	key = strdup(tmp.c_str());
941	<	tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1002	>
1003	>	tmp = (*jobH)["JOB_SCHED_INFO."+(*it)];
1004	>	PyObject * key = PyString_FromString( it->c_str() );
1005		PyObject * val = PyString_FromString( tmp.c_str() );
1006	<	PyDict_SetItemString( job_dict, key, val );
1007	<	delete [] key;
1006	>	PyDict_SetItem( job_dict, key, val);
1007	>	Py_DECREF(key);
1008	>	Py_DECREF(val);
1009	>	}
1010	>	return;
1011	>	}
1012	>	PyObject *BossTask_jobsDict(BossTask *self){
1013	>
1014	>	PyObject * job_dict = PyDict_New();
1015	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1016	>	for (BossTask::job_iterator jit = self->job_begin ();
1017	>	jit != self->job_end (); ++jit) {
1018	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1019	>	PyObject * tmp_dict = PyDict_New();
1020	>	BossTask_jobDict( self, *jit, tmp_dict );
1021	>	PyDict_SetItem( job_dict, id, tmp_dict );
1022	>	Py_DECREF(id);
1023	>	Py_DECREF(tmp_dict);
1024		}
1025		return job_dict;
1026		}
1027	<	PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
1027	>	PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1028	>	if ( ! self->jobsInMemory() ) self->load( ALL, jobid );
1029	>	PyObject * job_dict = PyDict_New();
1030	>	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1031	>	return job_dict;
1032	>	}
1033	>	PyObject *BossTask_Chain(BossTask *self,std::string const &jobid){
1034	>
1035	>	PyObject * chain_dict = PyDict_New();
1036	>	BossAttributeContainer obj =
1037	>	self->chain( jobid ).getTableEntries("CHAIN");
1038	>	BossTask_appendToPyDict ( self, chain_dict, obj );
1039	>	return chain_dict;
1040	>	}
1041	>	PyObject *BossTask_jobStates(BossTask *self){
1042
1043		PyObject * job_dict = PyDict_New();
1044	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1045		for (BossTask::job_iterator jit = self->job_begin ();
1046		jit != self->job_end (); ++jit) {
1047	<	std::string id = (*jit)->chainId();
1048	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1049	<	PyObject * myid =  PyString_FromString(id.c_str() );
1050	<	PyDict_SetItem( job_dict, myid,tmp );
1047	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1048	>	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1049	>	PyDict_SetItem( job_dict, id, status );
1050	>	Py_DECREF(id);
1051	>	Py_DECREF(status);
1052	>	}
1053	>	return job_dict;
1054	>	}
1055	>	PyObject *BossTask_joblist(BossTask *self){
1056	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1057	>	PyObject *  job_list = PyList_New( self->jobsInMemory() );
1058	>	unsigned int index = 0;
1059	>	for (BossTask::job_iterator jit = self->job_begin ();
1060	>	jit != self->job_end (); ++jit, ++index) {
1061	>	PyList_SetItem( job_list,
1062	>	index,
1063	>	PyString_FromString( ( (*jit)->chainId() ).c_str() )
1064	>	);
1065	>	}
1066	>	return job_list;
1067	>	}
1068	>	PyObject *BossTask_jobStatistic(BossTask *self){
1069	>
1070	>	PyObject * job_dict = PyDict_New();
1071	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1072	>	std::map< std::string, int > states;
1073	>	for (BossTask::job_iterator jit = self->job_begin ();
1074	>	jit != self->job_end (); ++jit) {
1075	>	++states[(**jit)["JOB.STATUS"]];
1076	>	}
1077	>
1078	>	std::map< std::string, int >::const_iterator end = states.end ();
1079	>	for (std::map< std::string, int >::const_iterator it = states.begin ();
1080	>	it != end; ++it) {
1081	>	PyObject * status = PyString_FromString( (it->first).c_str() );
1082	>	PyObject * jobs = PyString_FromFormat( "%d", it->second );
1083	>	PyDict_SetItem( job_dict, status, jobs );
1084	>	Py_DECREF(jobs);
1085	>	Py_DECREF(status);
1086		}
1087		return job_dict;
1088		}
#	Line 961 | Line 1090 | PyObject *BossTask_progDict(BossTask con
1090
1091		PyObject * job_dict = PyDict_New();
1092
964	–	std::string tmp;
965	–
1093		// PROGRAM
1094		BossAttributeContainer obj =
1095		(programs_it->first).getTableEntries("PROGRAM");
#	Line 998 | Line 1125 | PyObject *BossTask_jobPrograms(BossTask
1125		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1126		++programs_it  ) {
1127		std::string id = (programs_it->first)["PROGRAM.ID"];
1128	<	PyObject * tmp =  BossTask_progDict( self, programs_it );
1128	>	PyObject * tmp_dict =  BossTask_progDict( self, programs_it );
1129		PyObject * myid =  PyString_FromString(id.c_str() );
1130	<	PyDict_SetItem( job_dict, myid,tmp );
1130	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1131	>	Py_DECREF(myid);
1132	>	Py_DECREF(tmp_dict);
1133	>	}
1134	>	return job_dict;
1135	>	}
1136	>	PyObject *BossTask_program(BossTask *self,std::string const &jobid,std::string const &programId){
1137	>
1138	>	PyObject * job_dict = PyDict_New();
1139	>
1140	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1141	>	BossAttributeContainer obj =
1142	>	self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1143	>	BossTask_appendToPyDict ( self, job_dict, obj );
1144	>	return job_dict;
1145	>	}
1146	>	PyObject *BossTask_programExec(BossTask *self,std::string const &jobid,std::string const &programId){
1147	>
1148	>	PyObject * job_dict = PyDict_New();
1149	>
1150	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1151	>
1152	>	// PROGRAM_EXEC
1153	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1154	>	BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1155	>	BossTask_appendToPyDict ( self, job_dict, obj );
1156	>
1157	>	// SPECIFICS
1158	>	std::vector < BossAttributeContainer >::const_iterator it;
1159	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1160	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1161	>	BossTask_appendToPyDict ( self, job_dict, *it );
1162	>	}
1163	>	return job_dict;
1164	>	}
1165	>	PyObject *BossTask_specific(BossTask *self,std::string const &jobid,std::string const &programId){
1166	>
1167	>	PyObject * job_dict = PyDict_New();
1168	>
1169	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1170	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1171	>	BossAttributeContainer obj = programExec.getKeys ();
1172	>	BossTask_appendToPyDict ( self, job_dict, obj );
1173	>
1174	>	std::vector < BossAttributeContainer >::const_iterator it;
1175	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1176	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1177	>	BossTask_appendToPyDict ( self, job_dict, *it );
1178		}
1179		return job_dict;
1180		}
#	Line 1016 | Line 1190 | static PyObject *_wrap_new_objectMap__SW
1190		try {
1191		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1192
1193	+	}catch (const BossSchedFailure & e) {
1194	+	PyErr_SetString ( SchedulerError, e.what() );
1195	+	return NULL;
1196		}catch (const std::exception& e) {
1197	<	SWIG_exception(SWIG_RuntimeError, e.what());
1197	>	PyErr_SetString ( BossError, e.what() );
1198	>	return NULL;
1199		}
1200		}
1201		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1075 | Line 1253 | static PyObject *_wrap_new_objectMap__SW
1253		try {
1254		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1255
1256	+	}catch (const BossSchedFailure & e) {
1257	+	PyErr_SetString ( SchedulerError, e.what() );
1258	+	return NULL;
1259		}catch (const std::exception& e) {
1260	<	SWIG_exception(SWIG_RuntimeError, e.what());
1260	>	PyErr_SetString ( BossError, e.what() );
1261	>	return NULL;
1262		}
1263		}
1264		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1190 | Line 1372 | static PyObject *_wrap_objectMap___len__
1372		try {
1373		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1374
1375	+	}catch (const BossSchedFailure & e) {
1376	+	PyErr_SetString ( SchedulerError, e.what() );
1377	+	return NULL;
1378		}catch (const std::exception& e) {
1379	<	SWIG_exception(SWIG_RuntimeError, e.what());
1379	>	PyErr_SetString ( BossError, e.what() );
1380	>	return NULL;
1381		}
1382		}
1383		resultobj = PyInt_FromLong((long)result);
#	Line 1212 | Line 1398 | static PyObject *_wrap_objectMap_clear(P
1398		try {
1399		(arg1)->clear();
1400
1401	+	}catch (const BossSchedFailure & e) {
1402	+	PyErr_SetString ( SchedulerError, e.what() );
1403	+	return NULL;
1404		}catch (const std::exception& e) {
1405	<	SWIG_exception(SWIG_RuntimeError, e.what());
1405	>	PyErr_SetString ( BossError, e.what() );
1406	>	return NULL;
1407		}
1408		}
1409		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1235 | Line 1425 | static PyObject *_wrap_objectMap___nonze
1425		try {
1426		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1427
1428	+	}catch (const BossSchedFailure & e) {
1429	+	PyErr_SetString ( SchedulerError, e.what() );
1430	+	return NULL;
1431		}catch (const std::exception& e) {
1432	<	SWIG_exception(SWIG_RuntimeError, e.what());
1432	>	PyErr_SetString ( BossError, e.what() );
1433	>	return NULL;
1434		}
1435		}
1436		resultobj = PyInt_FromLong((long)result);
#	Line 1307 | Line 1501 | static PyObject *_wrap_objectMap___setit
1501		try {
1502		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1503
1504	+	}catch (const BossSchedFailure & e) {
1505	+	PyErr_SetString ( SchedulerError, e.what() );
1506	+	return NULL;
1507		}catch (const std::exception& e) {
1508	<	SWIG_exception(SWIG_RuntimeError, e.what());
1508	>	PyErr_SetString ( BossError, e.what() );
1509	>	return NULL;
1510		}
1511		}
1512		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1369 | Line 1567 | static PyObject *_wrap_objectMap_has_key
1567		try {
1568		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1569
1570	+	}catch (const BossSchedFailure & e) {
1571	+	PyErr_SetString ( SchedulerError, e.what() );
1572	+	return NULL;
1573		}catch (const std::exception& e) {
1574	<	SWIG_exception(SWIG_RuntimeError, e.what());
1574	>	PyErr_SetString ( BossError, e.what() );
1575	>	return NULL;
1576		}
1577		}
1578		resultobj = PyInt_FromLong((long)result);
#	Line 1392 | Line 1594 | static PyObject *_wrap_objectMap_keys(Py
1594		try {
1595		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1596
1597	+	}catch (const BossSchedFailure & e) {
1598	+	PyErr_SetString ( SchedulerError, e.what() );
1599	+	return NULL;
1600		}catch (const std::exception& e) {
1601	<	SWIG_exception(SWIG_RuntimeError, e.what());
1601	>	PyErr_SetString ( BossError, e.what() );
1602	>	return NULL;
1603		}
1604		}
1605		resultobj = result;
#	Line 1415 | Line 1621 | static PyObject *_wrap_objectMap_values(
1621		try {
1622		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1623
1624	+	}catch (const BossSchedFailure & e) {
1625	+	PyErr_SetString ( SchedulerError, e.what() );
1626	+	return NULL;
1627		}catch (const std::exception& e) {
1628	<	SWIG_exception(SWIG_RuntimeError, e.what());
1628	>	PyErr_SetString ( BossError, e.what() );
1629	>	return NULL;
1630		}
1631		}
1632		resultobj = result;
#	Line 1438 | Line 1648 | static PyObject *_wrap_objectMap_items(P
1648		try {
1649		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1650
1651	+	}catch (const BossSchedFailure & e) {
1652	+	PyErr_SetString ( SchedulerError, e.what() );
1653	+	return NULL;
1654		}catch (const std::exception& e) {
1655	<	SWIG_exception(SWIG_RuntimeError, e.what());
1655	>	PyErr_SetString ( BossError, e.what() );
1656	>	return NULL;
1657		}
1658		}
1659		resultobj = result;
#	Line 1469 | Line 1683 | static PyObject *_wrap_objectMap___conta
1683		try {
1684		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1685
1686	+	}catch (const BossSchedFailure & e) {
1687	+	PyErr_SetString ( SchedulerError, e.what() );
1688	+	return NULL;
1689		}catch (const std::exception& e) {
1690	<	SWIG_exception(SWIG_RuntimeError, e.what());
1690	>	PyErr_SetString ( BossError, e.what() );
1691	>	return NULL;
1692		}
1693		}
1694		resultobj = PyInt_FromLong((long)result);
#	Line 1515 | Line 1733 | static PyObject *_wrap_delete_objectMap(
1733		try {
1734		delete arg1;
1735
1736	+	}catch (const BossSchedFailure & e) {
1737	+	PyErr_SetString ( SchedulerError, e.what() );
1738	+	return NULL;
1739		}catch (const std::exception& e) {
1740	<	SWIG_exception(SWIG_RuntimeError, e.what());
1740	>	PyErr_SetString ( BossError, e.what() );
1741	>	return NULL;
1742		}
1743		}
1744		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1533 | Line 1755 | static PyObject * objectMap_swigregister
1755		Py_INCREF(obj);
1756		return Py_BuildValue((char *)"");
1757		}
1758	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
1758	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1759		PyObject *resultobj;
1760	<	BossSession *arg1 = (BossSession *) 0 ;
1761	<	std::vector<std::string > *arg2 = 0 ;
1762	<	PyObject *result;
1760	>	unsigned int arg1 = (unsigned int) 0 ;
1761	>	std::vector<std::string > *result;
1762	>	PyObject * obj0 = 0 ;
1763	>
1764	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1765	>	if (obj0) {
1766	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1767	>	if (PyErr_Occurred()) SWIG_fail;
1768	>	}
1769	>	{
1770	>	try {
1771	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1772	>
1773	>	}catch (const BossSchedFailure & e) {
1774	>	PyErr_SetString ( SchedulerError, e.what() );
1775	>	return NULL;
1776	>	}catch (const std::exception& e) {
1777	>	PyErr_SetString ( BossError, e.what() );
1778	>	return NULL;
1779	>	}
1780	>	}
1781	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1782	>	return resultobj;
1783	>	fail:
1784	>	return NULL;
1785	>	}
1786	>
1787	>
1788	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1789	>	PyObject *resultobj;
1790	>	unsigned int arg1 ;
1791	>	std::string *arg2 = 0 ;
1792	>	std::vector<std::string > *result;
1793	>	std::string temp2 ;
1794		PyObject * obj0 = 0 ;
1795		PyObject * obj1 = 0 ;
1796
1797	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
1798	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1799	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1800	<	if (arg2 == NULL) {
1801	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
1797	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1798	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1799	>	if (PyErr_Occurred()) SWIG_fail;
1800	>	{
1801	>	if (PyString_Check(obj1)) {
1802	>	temp2 = std::string(PyString_AsString(obj1));
1803	>	arg2 = &temp2;
1804	>	}else {
1805	>	SWIG_exception(SWIG_TypeError, "string expected");
1806	>	}
1807		}
1808		{
1809		try {
1810	<	result = (PyObject *)BossSession_show(arg1,*arg2);
1810	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1811
1812	+	}catch (const BossSchedFailure & e) {
1813	+	PyErr_SetString ( SchedulerError, e.what() );
1814	+	return NULL;
1815		}catch (const std::exception& e) {
1816	<	SWIG_exception(SWIG_RuntimeError, e.what());
1816	>	PyErr_SetString ( BossError, e.what() );
1817	>	return NULL;
1818		}
1819		}
1820	<	resultobj = result;
1820	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1821		return resultobj;
1822		fail:
1823		return NULL;
1824		}
1825
1826
1827	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_1(PyObject *self, PyObject *args) {
1827	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1828		PyObject *resultobj;
1829	<	BossSession *arg1 = (BossSession *) 0 ;
1830	<	PyObject *result;
1829	>	std::vector<std::string > *arg1 = 0 ;
1830	>	std::vector<std::string > *result;
1831	>	std::vector<std::string > temp1 ;
1832	>	std::vector<std::string > *v1 ;
1833		PyObject * obj0 = 0 ;
1834
1835	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
1836	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1835	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1836	>	{
1837	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1838	>	unsigned int size = (PyTuple_Check(obj0) ?
1839	>	PyTuple_Size(obj0) :
1840	>	PyList_Size(obj0));
1841	>	temp1 = std::vector<std::string >(size);
1842	>	arg1 = &temp1;
1843	>	for (unsigned int i=0; i<size; i++) {
1844	>	PyObject* o = PySequence_GetItem(obj0,i);
1845	>	if (PyString_Check(o)) {
1846	>	temp1[i] = (std::string)(\
1847	>	SwigString_AsString(o));
1848	>	Py_DECREF(o);
1849	>	}else {
1850	>	Py_DECREF(o);
1851	>	PyErr_SetString(PyExc_TypeError,
1852	>	"vector<""std::string""> expected");
1853	>	SWIG_fail;
1854	>	}
1855	>	}
1856	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1857	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1858	>	arg1 = v1;
1859	>	}else {
1860	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1861	>	SWIG_fail;
1862	>	}
1863	>	}
1864		{
1865		try {
1866	<	result = (PyObject *)BossSession_showCHTools__SWIG_1(arg1);
1866	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1867
1868	+	}catch (const BossSchedFailure & e) {
1869	+	PyErr_SetString ( SchedulerError, e.what() );
1870	+	return NULL;
1871		}catch (const std::exception& e) {
1872	<	SWIG_exception(SWIG_RuntimeError, e.what());
1872	>	PyErr_SetString ( BossError, e.what() );
1873	>	return NULL;
1874		}
1875		}
1876	<	resultobj = result;
1876	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1877		return resultobj;
1878		fail:
1879		return NULL;
1880		}
1881
1882
1883	<	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
1883	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1884		int argc;
1885	<	PyObject *argv[2];
1885	>	PyObject *argv[3];
1886		int ii;
1887
1888		argc = PyObject_Length(args);
1889	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1889	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1890		argv[ii] = PyTuple_GetItem(args,ii);
1891		}
1892	+	if ((argc >= 0) && (argc <= 1)) {
1893	+	int _v;
1894	+	if (argc <= 0) {
1895	+	return _wrap_new_vector_string__SWIG_0(self,args);
1896	+	}
1897	+	{
1898	+	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1899	+	}
1900	+	if (_v) {
1901	+	return _wrap_new_vector_string__SWIG_0(self,args);
1902	+	}
1903	+	}
1904		if (argc == 1) {
1905		int _v;
1906		{
1907	<	void *ptr;
1908	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1909	<	_v = 0;
1910	<	PyErr_Clear();
1907	>	/* native sequence? */
1908	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1909	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1910	>	PyTuple_Size(argv[0]) :
1911	>	PyList_Size(argv[0]));
1912	>	if (size == 0) {
1913	>	/* an empty sequence can be of any type */
1914	>	_v = 1;
1915	>	}else {
1916	>	/* check the first element only */
1917	>	PyObject* o = PySequence_GetItem(argv[0],0);
1918	>	if (PyString_Check(o))
1919	>	_v = 1;
1920	>	else
1921	>	_v = 0;
1922	>	Py_DECREF(o);
1923	>	}
1924		}else {
1925	+	/* wrapped vector? */
1926	+	std::vector<std::string >* v;
1927	+	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1928	+	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1929		_v = 1;
1930	+	else
1931	+	_v = 0;
1932		}
1933		}
1934		if (_v) {
1935	<	return _wrap_BossSession_showCHTools__SWIG_1(self,args);
1935	>	return _wrap_new_vector_string__SWIG_2(self,args);
1936	>	}
1937	>	}
1938	>	if (argc == 2) {
1939	>	int _v;
1940	>	{
1941	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1942	>	}
1943	>	if (_v) {
1944	>	{
1945	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1946	>	}
1947	>	if (_v) {
1948	>	return _wrap_new_vector_string__SWIG_1(self,args);
1949	>	}
1950		}
1951		}
1952
1953	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showCHTools'");
1953	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1954		return NULL;
1955		}
1956
1957
1958	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_1(PyObject *self, PyObject *args) {
1958	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1959		PyObject *resultobj;
1960	<	BossSession *arg1 = (BossSession *) 0 ;
1961	<	PyObject *result;
1960	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1961	>	unsigned int result;
1962	>	std::vector<std::string > temp1 ;
1963	>	std::vector<std::string > *v1 ;
1964		PyObject * obj0 = 0 ;
1965
1966	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
1967	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1966	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1967	>	{
1968	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1969	>	unsigned int size = (PyTuple_Check(obj0) ?
1970	>	PyTuple_Size(obj0) :
1971	>	PyList_Size(obj0));
1972	>	temp1 = std::vector<std::string >(size);
1973	>	arg1 = &temp1;
1974	>	for (unsigned int i=0; i<size; i++) {
1975	>	PyObject* o = PySequence_GetItem(obj0,i);
1976	>	if (PyString_Check(o)) {
1977	>	temp1[i] = (std::string)(\
1978	>	SwigString_AsString(o));
1979	>	Py_DECREF(o);
1980	>	}else {
1981	>	Py_DECREF(o);
1982	>	PyErr_SetString(PyExc_TypeError,
1983	>	"vector<""std::string""> expected");
1984	>	SWIG_fail;
1985	>	}
1986	>	}
1987	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1988	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1989	>	arg1 = v1;
1990	>	}else {
1991	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1992	>	SWIG_fail;
1993	>	}
1994	>	}
1995		{
1996		try {
1997	<	result = (PyObject *)BossSession_showProgramTypes__SWIG_1(arg1);
1997	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1998
1999	+	}catch (const BossSchedFailure & e) {
2000	+	PyErr_SetString ( SchedulerError, e.what() );
2001	+	return NULL;
2002		}catch (const std::exception& e) {
2003	<	SWIG_exception(SWIG_RuntimeError, e.what());
2003	>	PyErr_SetString ( BossError, e.what() );
2004	>	return NULL;
2005		}
2006		}
2007	<	resultobj = result;
2007	>	resultobj = PyInt_FromLong((long)result);
2008		return resultobj;
2009		fail:
2010		return NULL;
2011		}
2012
2013
2014	<	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2015	<	int argc;
2016	<	PyObject *argv[2];
2017	<	int ii;
2014	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
2015	>	PyObject *resultobj;
2016	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2017	>	bool result;
2018	>	std::vector<std::string > temp1 ;
2019	>	std::vector<std::string > *v1 ;
2020	>	PyObject * obj0 = 0 ;
2021
2022	<	argc = PyObject_Length(args);
2023	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2024	<	argv[ii] = PyTuple_GetItem(args,ii);
2025	<	}
2026	<	if (argc == 1) {
2027	<	int _v;
2028	<	{
2029	<	void *ptr;
2030	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2031	<	_v = 0;
2032	<	PyErr_Clear();
2033	<	}else {
2034	<	_v = 1;
2022	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
2023	>	{
2024	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
2025	>	unsigned int size = (PyTuple_Check(obj0) ?
2026	>	PyTuple_Size(obj0) :
2027	>	PyList_Size(obj0));
2028	>	temp1 = std::vector<std::string >(size);
2029	>	arg1 = &temp1;
2030	>	for (unsigned int i=0; i<size; i++) {
2031	>	PyObject* o = PySequence_GetItem(obj0,i);
2032	>	if (PyString_Check(o)) {
2033	>	temp1[i] = (std::string)(\
2034	>	SwigString_AsString(o));
2035	>	Py_DECREF(o);
2036	>	}else {
2037	>	Py_DECREF(o);
2038	>	PyErr_SetString(PyExc_TypeError,
2039	>	"vector<""std::string""> expected");
2040	>	SWIG_fail;
2041	>	}
2042		}
2043	+	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
2044	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2045	+	arg1 = v1;
2046	+	}else {
2047	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2048	+	SWIG_fail;
2049		}
2050	<	if (_v) {
2051	<	return _wrap_BossSession_showProgramTypes__SWIG_1(self,args);
2050	>	}
2051	>	{
2052	>	try {
2053	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
2054	>
2055	>	}catch (const BossSchedFailure & e) {
2056	>	PyErr_SetString ( SchedulerError, e.what() );
2057	>	return NULL;
2058	>	}catch (const std::exception& e) {
2059	>	PyErr_SetString ( BossError, e.what() );
2060	>	return NULL;
2061		}
2062		}
2063	<
2064	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showProgramTypes'");
2063	>	resultobj = PyInt_FromLong((long)result);
2064	>	return resultobj;
2065	>	fail:
2066		return NULL;
2067		}
2068
2069
2070	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_1(PyObject *self, PyObject *args) {
2070	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
2071		PyObject *resultobj;
2072	<	BossSession *arg1 = (BossSession *) 0 ;
1674	<	PyObject *result;
2072	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2073		PyObject * obj0 = 0 ;
2074
2075	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2076	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2075	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
2076	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2077		{
2078		try {
2079	<	result = (PyObject *)BossSession_showRTMon__SWIG_1(arg1);
2079	>	(arg1)->clear();
2080
2081	+	}catch (const BossSchedFailure & e) {
2082	+	PyErr_SetString ( SchedulerError, e.what() );
2083	+	return NULL;
2084		}catch (const std::exception& e) {
2085	<	SWIG_exception(SWIG_RuntimeError, e.what());
2085	>	PyErr_SetString ( BossError, e.what() );
2086	>	return NULL;
2087		}
2088		}
2089	<	resultobj = result;
2089	>	Py_INCREF(Py_None); resultobj = Py_None;
2090		return resultobj;
2091		fail:
2092		return NULL;
2093		}
2094
2095
2096	<	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2097	<	int argc;
2098	<	PyObject *argv[2];
2099	<	int ii;
2096	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
2097	>	PyObject *resultobj;
2098	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2099	>	std::string arg2 ;
2100	>	PyObject * obj0 = 0 ;
2101	>	PyObject * obj1 = 0 ;
2102
2103	<	argc = PyObject_Length(args);
2104	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2105	<	argv[ii] = PyTuple_GetItem(args,ii);
2103	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
2104	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2105	>	{
2106	>	if (PyString_Check(obj1))
2107	>	arg2 = std::string(PyString_AsString(obj1));
2108	>	else
2109	>	SWIG_exception(SWIG_TypeError, "string expected");
2110		}
2111	<	if (argc == 1) {
2112	<	int _v;
2113	<	{
2114	<	void *ptr;
2115	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2116	<	_v = 0;
2117	<	PyErr_Clear();
2118	<	}else {
2119	<	_v = 1;
2120	<	}
2111	>	{
2112	>	try {
2113	>	(arg1)->push_back(arg2);
2114	>
2115	>	}catch (const BossSchedFailure & e) {
2116	>	PyErr_SetString ( SchedulerError, e.what() );
2117	>	return NULL;
2118	>	}catch (const std::exception& e) {
2119	>	PyErr_SetString ( BossError, e.what() );
2120	>	return NULL;
2121		}
2122	<	if (_v) {
2123	<	return _wrap_BossSession_showRTMon__SWIG_1(self,args);
2122	>	}
2123	>	Py_INCREF(Py_None); resultobj = Py_None;
2124	>	return resultobj;
2125	>	fail:
2126	>	return NULL;
2127	>	}
2128	>
2129	>
2130	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
2131	>	PyObject *resultobj;
2132	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2133	>	std::string result;
2134	>	PyObject * obj0 = 0 ;
2135	>
2136	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
2137	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2138	>	{
2139	>	try {
2140	>	result = std_vectorlstd_string_g_pop___(arg1);
2141	>
2142	>	}catch (std::out_of_range& e) {
2143	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2144		}
2145		}
2146	+	{
2147	+	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2148	+	}
2149	+	return resultobj;
2150	+	fail:
2151	+	return NULL;
2152	+	}
2153	+
2154	+
2155	+	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
2156	+	PyObject *resultobj;
2157	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2158	+	int arg2 ;
2159	+	std::string result;
2160	+	PyObject * obj0 = 0 ;
2161
2162	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showRTMon'");
2162	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2163	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2164	>	{
2165	>	try {
2166	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2167	>
2168	>	}catch (std::out_of_range& e) {
2169	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2170	>	}
2171	>	}
2172	>	{
2173	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2174	>	}
2175	>	return resultobj;
2176	>	fail:
2177		return NULL;
2178		}
2179
2180
2181	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_1(PyObject *self, PyObject *args) {
2181	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2182		PyObject *resultobj;
2183	<	BossSession *arg1 = (BossSession *) 0 ;
2184	<	PyObject *result;
2183	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2184	>	int arg2 ;
2185	>	int arg3 ;
2186	>	std::vector<std::string > result;
2187		PyObject * obj0 = 0 ;
2188
2189	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2190	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2189	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2190	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2191		{
2192		try {
2193	<	result = (PyObject *)BossSession_showSchedulers__SWIG_1(arg1);
2193	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2194
2195	+	}catch (const BossSchedFailure & e) {
2196	+	PyErr_SetString ( SchedulerError, e.what() );
2197	+	return NULL;
2198		}catch (const std::exception& e) {
2199	<	SWIG_exception(SWIG_RuntimeError, e.what());
2199	>	PyErr_SetString ( BossError, e.what() );
2200	>	return NULL;
2201		}
2202		}
2203	<	resultobj = result;
2203	>	{
2204	>	resultobj = PyTuple_New((&result)->size());
2205	>	for (unsigned int i=0; i<(&result)->size(); i++)
2206	>	PyTuple_SetItem(resultobj,i,
2207	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2208	>	}
2209		return resultobj;
2210		fail:
2211		return NULL;
2212		}
2213
2214
2215	<	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2216	<	int argc;
2217	<	PyObject *argv[2];
2218	<	int ii;
2215	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2216	>	PyObject *resultobj;
2217	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2218	>	int arg2 ;
2219	>	std::string arg3 ;
2220	>	PyObject * obj0 = 0 ;
2221	>	PyObject * obj2 = 0 ;
2222
2223	<	argc = PyObject_Length(args);
2224	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2225	<	argv[ii] = PyTuple_GetItem(args,ii);
2223	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2224	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2225	>	{
2226	>	if (PyString_Check(obj2))
2227	>	arg3 = std::string(PyString_AsString(obj2));
2228	>	else
2229	>	SWIG_exception(SWIG_TypeError, "string expected");
2230		}
2231	<	if (argc == 1) {
2232	<	int _v;
2233	<	{
2234	<	void *ptr;
2235	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2236	<	_v = 0;
1762	<	PyErr_Clear();
1763	<	}else {
1764	<	_v = 1;
1765	<	}
1766	<	}
1767	<	if (_v) {
1768	<	return _wrap_BossSession_showSchedulers__SWIG_1(self,args);
2231	>	{
2232	>	try {
2233	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2234	>
2235	>	}catch (std::out_of_range& e) {
2236	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2237		}
2238		}
2239	<
2240	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showSchedulers'");
2239	>	Py_INCREF(Py_None); resultobj = Py_None;
2240	>	return resultobj;
2241	>	fail:
2242		return NULL;
2243		}
2244
2245
2246	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2246	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2247		PyObject *resultobj;
2248	<	BossSession *arg1 = (BossSession *) 0 ;
2249	<	int arg2 = (int) SCHEDULED ;
2250	<	std::string const &arg3_defvalue = "all" ;
2251	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
2252	<	std::string const &arg4_defvalue = "all" ;
2253	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
1785	<	std::string const &arg5_defvalue = "" ;
1786	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
1787	<	std::string arg6 = (std::string) "" ;
1788	<	std::string arg7 = (std::string) "" ;
1789	<	std::string arg8 = (std::string) "" ;
1790	<	std::string arg9 = (std::string) "" ;
1791	<	bool arg10 = (bool) false ;
1792	<	PyObject *result;
1793	<	std::string temp3 ;
1794	<	std::string temp4 ;
1795	<	std::string temp5 ;
2248	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2249	>	int arg2 ;
2250	>	int arg3 ;
2251	>	std::vector<std::string > *arg4 = 0 ;
2252	>	std::vector<std::string > temp4 ;
2253	>	std::vector<std::string > *v4 ;
2254		PyObject * obj0 = 0 ;
1797	–	PyObject * obj2 = 0 ;
2255		PyObject * obj3 = 0 ;
1799	–	PyObject * obj4 = 0 ;
1800	–	PyObject * obj5 = 0 ;
1801	–	PyObject * obj6 = 0 ;
1802	–	PyObject * obj7 = 0 ;
1803	–	PyObject * obj8 = 0 ;
1804	–	PyObject * obj9 = 0 ;
2256
2257	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2258	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2259	<	if (obj2) {
2260	<	{
2261	<	if (PyString_Check(obj2)) {
2262	<	temp3 = std::string(PyString_AsString(obj2));
2263	<	arg3 = &temp3;
2264	<	}else {
2265	<	SWIG_exception(SWIG_TypeError, "string expected");
2257	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2258	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2259	>	{
2260	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2261	>	unsigned int size = (PyTuple_Check(obj3) ?
2262	>	PyTuple_Size(obj3) :
2263	>	PyList_Size(obj3));
2264	>	temp4 = std::vector<std::string >(size);
2265	>	arg4 = &temp4;
2266	>	for (unsigned int i=0; i<size; i++) {
2267	>	PyObject* o = PySequence_GetItem(obj3,i);
2268	>	if (PyString_Check(o)) {
2269	>	temp4[i] = (std::string)(\
2270	>	SwigString_AsString(o));
2271	>	Py_DECREF(o);
2272	>	}else {
2273	>	Py_DECREF(o);
2274	>	PyErr_SetString(PyExc_TypeError,
2275	>	"vector<""std::string""> expected");
2276	>	SWIG_fail;
2277	>	}
2278		}
2279	+	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2280	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2281	+	arg4 = v4;
2282	+	}else {
2283	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2284	+	SWIG_fail;
2285		}
2286		}
2287	<	if (obj3) {
2288	<	{
2289	<	if (PyString_Check(obj3)) {
2290	<	temp4 = std::string(PyString_AsString(obj3));
2291	<	arg4 = &temp4;
2292	<	}else {
2293	<	SWIG_exception(SWIG_TypeError, "string expected");
2294	<	}
2287	>	{
2288	>	try {
2289	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2290	>
2291	>	}catch (const BossSchedFailure & e) {
2292	>	PyErr_SetString ( SchedulerError, e.what() );
2293	>	return NULL;
2294	>	}catch (const std::exception& e) {
2295	>	PyErr_SetString ( BossError, e.what() );
2296	>	return NULL;
2297		}
2298		}
2299	<	if (obj4) {
2300	<	{
2301	<	if (PyString_Check(obj4)) {
2302	<	temp5 = std::string(PyString_AsString(obj4));
2303	<	arg5 = &temp5;
2304	<	}else {
2305	<	SWIG_exception(SWIG_TypeError, "string expected");
2306	<	}
2299	>	Py_INCREF(Py_None); resultobj = Py_None;
2300	>	return resultobj;
2301	>	fail:
2302	>	return NULL;
2303	>	}
2304	>
2305	>
2306	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2307	>	PyObject *resultobj;
2308	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2309	>	int arg2 ;
2310	>	PyObject * obj0 = 0 ;
2311	>
2312	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2313	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2314	>	{
2315	>	try {
2316	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2317	>
2318	>	}catch (std::out_of_range& e) {
2319	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2320		}
2321		}
2322	<	if (obj5) {
2322	>	Py_INCREF(Py_None); resultobj = Py_None;
2323	>	return resultobj;
2324	>	fail:
2325	>	return NULL;
2326	>	}
2327	>
2328	>
2329	>	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2330	>	PyObject *resultobj;
2331	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2332	>	int arg2 ;
2333	>	int arg3 ;
2334	>	PyObject * obj0 = 0 ;
2335	>
2336	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2337	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2338	>	{
2339	>	try {
2340	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2341	>
2342	>	}catch (const BossSchedFailure & e) {
2343	>	PyErr_SetString ( SchedulerError, e.what() );
2344	>	return NULL;
2345	>	}catch (const std::exception& e) {
2346	>	PyErr_SetString ( BossError, e.what() );
2347	>	return NULL;
2348	>	}
2349	>	}
2350	>	Py_INCREF(Py_None); resultobj = Py_None;
2351	>	return resultobj;
2352	>	fail:
2353	>	return NULL;
2354	>	}
2355	>
2356	>
2357	>	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2358	>	PyObject *resultobj;
2359	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2360	>	PyObject * obj0 = 0 ;
2361	>
2362	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2363	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2364	>	{
2365	>	try {
2366	>	delete arg1;
2367	>
2368	>	}catch (const BossSchedFailure & e) {
2369	>	PyErr_SetString ( SchedulerError, e.what() );
2370	>	return NULL;
2371	>	}catch (const std::exception& e) {
2372	>	PyErr_SetString ( BossError, e.what() );
2373	>	return NULL;
2374	>	}
2375	>	}
2376	>	Py_INCREF(Py_None); resultobj = Py_None;
2377	>	return resultobj;
2378	>	fail:
2379	>	return NULL;
2380	>	}
2381	>
2382	>
2383	>	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2384	>	PyObject *obj;
2385	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2386	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2387	>	Py_INCREF(obj);
2388	>	return Py_BuildValue((char *)"");
2389	>	}
2390	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2391	>	PyObject *resultobj;
2392	>	std::string arg1 = (std::string) "" ;
2393	>	std::string arg2 = (std::string) "2" ;
2394	>	std::string arg3 = (std::string) "" ;
2395	>	std::string arg4 = (std::string) "" ;
2396	>	BossSession *result;
2397	>	PyObject * obj0 = 0 ;
2398	>	PyObject * obj1 = 0 ;
2399	>	PyObject * obj2 = 0 ;
2400	>	PyObject * obj3 = 0 ;
2401	>
2402	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2403	>	if (obj0) {
2404		{
2405	<	if (PyString_Check(obj5))
2406	<	arg6 = std::string(PyString_AsString(obj5));
2405	>	if (PyString_Check(obj0))
2406	>	arg1 = std::string(PyString_AsString(obj0));
2407		else
2408		SWIG_exception(SWIG_TypeError, "string expected");
2409		}
2410		}
2411	<	if (obj6) {
2411	>	if (obj1) {
2412		{
2413	<	if (PyString_Check(obj6))
2414	<	arg7 = std::string(PyString_AsString(obj6));
2413	>	if (PyString_Check(obj1))
2414	>	arg2 = std::string(PyString_AsString(obj1));
2415		else
2416		SWIG_exception(SWIG_TypeError, "string expected");
2417		}
2418		}
2419	<	if (obj7) {
2419	>	if (obj2) {
2420		{
2421	<	if (PyString_Check(obj7))
2422	<	arg8 = std::string(PyString_AsString(obj7));
2421	>	if (PyString_Check(obj2))
2422	>	arg3 = std::string(PyString_AsString(obj2));
2423		else
2424		SWIG_exception(SWIG_TypeError, "string expected");
2425		}
2426		}
2427	<	if (obj8) {
2427	>	if (obj3) {
2428		{
2429	<	if (PyString_Check(obj8))
2430	<	arg9 = std::string(PyString_AsString(obj8));
2429	>	if (PyString_Check(obj3))
2430	>	arg4 = std::string(PyString_AsString(obj3));
2431		else
2432		SWIG_exception(SWIG_TypeError, "string expected");
2433		}
2434		}
1870	–	if (obj9) {
1871	–	arg10 = PyInt_AsLong(obj9) ? true : false;
1872	–	if (PyErr_Occurred()) SWIG_fail;
1873	–	}
2435		{
2436		try {
2437	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2437	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2438
2439	+	}catch (const BossSchedFailure & e) {
2440	+	PyErr_SetString ( SchedulerError, e.what() );
2441	+	return NULL;
2442		}catch (const std::exception& e) {
2443	<	SWIG_exception(SWIG_RuntimeError, e.what());
2443	>	PyErr_SetString ( BossError, e.what() );
2444	>	return NULL;
2445		}
2446		}
2447	<	resultobj = result;
2447	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2448		return resultobj;
2449		fail:
2450		return NULL;
2451		}
2452
2453
2454	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2454	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2455		PyObject *resultobj;
2456	<	std::string arg1 = (std::string) "" ;
1892	<	BossSession *result;
2456	>	BossSession *arg1 = (BossSession *) 0 ;
2457		PyObject * obj0 = 0 ;
2458
2459	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2460	<	if (obj0) {
2461	<	{
2462	<	if (PyString_Check(obj0))
2463	<	arg1 = std::string(PyString_AsString(obj0));
2464	<	else
2465	<	SWIG_exception(SWIG_TypeError, "string expected");
2459	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2460	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2461	>	{
2462	>	try {
2463	>	delete arg1;
2464	>
2465	>	}catch (const BossSchedFailure & e) {
2466	>	PyErr_SetString ( SchedulerError, e.what() );
2467	>	return NULL;
2468	>	}catch (const std::exception& e) {
2469	>	PyErr_SetString ( BossError, e.what() );
2470	>	return NULL;
2471		}
2472		}
2473	+	Py_INCREF(Py_None); resultobj = Py_None;
2474	+	return resultobj;
2475	+	fail:
2476	+	return NULL;
2477	+	}
2478	+
2479	+
2480	+	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2481	+	PyObject *resultobj;
2482	+	BossSession *arg1 = (BossSession *) 0 ;
2483	+	PyObject * obj0 = 0 ;
2484	+
2485	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2486	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2487		{
2488		try {
2489	<	result = (BossSession *)new BossSession(arg1);
2489	>	(arg1)->resetDB();
2490
2491	+	}catch (const BossSchedFailure & e) {
2492	+	PyErr_SetString ( SchedulerError, e.what() );
2493	+	return NULL;
2494		}catch (const std::exception& e) {
2495	<	SWIG_exception(SWIG_RuntimeError, e.what());
2495	>	PyErr_SetString ( BossError, e.what() );
2496	>	return NULL;
2497		}
2498		}
2499	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2499	>	Py_INCREF(Py_None); resultobj = Py_None;
2500		return resultobj;
2501		fail:
2502		return NULL;
2503		}
2504
2505
2506	<	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2506	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2507		PyObject *resultobj;
2508		BossSession *arg1 = (BossSession *) 0 ;
2509		PyObject * obj0 = 0 ;
2510
2511	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2511	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2512		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2513		{
2514		try {
2515	<	delete arg1;
2515	>	(arg1)->clear();
2516
2517	+	}catch (const BossSchedFailure & e) {
2518	+	PyErr_SetString ( SchedulerError, e.what() );
2519	+	return NULL;
2520		}catch (const std::exception& e) {
2521	<	SWIG_exception(SWIG_RuntimeError, e.what());
2521	>	PyErr_SetString ( BossError, e.what() );
2522	>	return NULL;
2523		}
2524		}
2525		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1938 | Line 2529 | static PyObject *_wrap_delete_BossSessio
2529		}
2530
2531
2532	+	static PyObject *_wrap_BossSession_task_begin(PyObject *self, PyObject *args) {
2533	+	PyObject *resultobj;
2534	+	BossSession *arg1 = (BossSession *) 0 ;
2535	+	BossSession::task_iterator result;
2536	+	PyObject * obj0 = 0 ;
2537	+
2538	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_begin",&obj0)) goto fail;
2539	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2540	+	{
2541	+	try {
2542	+	result = ((BossSession const *)arg1)->task_begin();
2543	+
2544	+	}catch (const BossSchedFailure & e) {
2545	+	PyErr_SetString ( SchedulerError, e.what() );
2546	+	return NULL;
2547	+	}catch (const std::exception& e) {
2548	+	PyErr_SetString ( BossError, e.what() );
2549	+	return NULL;
2550	+	}
2551	+	}
2552	+	{
2553	+	BossSession::task_iterator * resultptr;
2554	+	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2555	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2556	+	}
2557	+	return resultobj;
2558	+	fail:
2559	+	return NULL;
2560	+	}
2561	+
2562	+
2563	+	static PyObject *_wrap_BossSession_task_end(PyObject *self, PyObject *args) {
2564	+	PyObject *resultobj;
2565	+	BossSession *arg1 = (BossSession *) 0 ;
2566	+	BossSession::task_iterator result;
2567	+	PyObject * obj0 = 0 ;
2568	+
2569	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_end",&obj0)) goto fail;
2570	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2571	+	{
2572	+	try {
2573	+	result = ((BossSession const *)arg1)->task_end();
2574	+
2575	+	}catch (const BossSchedFailure & e) {
2576	+	PyErr_SetString ( SchedulerError, e.what() );
2577	+	return NULL;
2578	+	}catch (const std::exception& e) {
2579	+	PyErr_SetString ( BossError, e.what() );
2580	+	return NULL;
2581	+	}
2582	+	}
2583	+	{
2584	+	BossSession::task_iterator * resultptr;
2585	+	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2586	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2587	+	}
2588	+	return resultobj;
2589	+	fail:
2590	+	return NULL;
2591	+	}
2592	+
2593	+
2594	+	static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
2595	+	PyObject *resultobj;
2596	+	BossSession *arg1 = (BossSession *) 0 ;
2597	+	unsigned int result;
2598	+	PyObject * obj0 = 0 ;
2599	+
2600	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
2601	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2602	+	{
2603	+	try {
2604	+	result = (unsigned int)((BossSession const *)arg1)->tasksInMemory();
2605	+
2606	+	}catch (const BossSchedFailure & e) {
2607	+	PyErr_SetString ( SchedulerError, e.what() );
2608	+	return NULL;
2609	+	}catch (const std::exception& e) {
2610	+	PyErr_SetString ( BossError, e.what() );
2611	+	return NULL;
2612	+	}
2613	+	}
2614	+	resultobj = PyInt_FromLong((long)result);
2615	+	return resultobj;
2616	+	fail:
2617	+	return NULL;
2618	+	}
2619	+
2620	+
2621	+	static PyObject *_wrap_BossSession_locate(PyObject *self, PyObject *args) {
2622	+	PyObject *resultobj;
2623	+	BossSession *arg1 = (BossSession *) 0 ;
2624	+	unsigned int arg2 ;
2625	+	BossTask *result;
2626	+	PyObject * obj0 = 0 ;
2627	+	PyObject * obj1 = 0 ;
2628	+
2629	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
2630	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2631	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
2632	+	if (PyErr_Occurred()) SWIG_fail;
2633	+	{
2634	+	try {
2635	+	result = (BossTask *)((BossSession const *)arg1)->locate(arg2);
2636	+
2637	+	}catch (const BossSchedFailure & e) {
2638	+	PyErr_SetString ( SchedulerError, e.what() );
2639	+	return NULL;
2640	+	}catch (const std::exception& e) {
2641	+	PyErr_SetString ( BossError, e.what() );
2642	+	return NULL;
2643	+	}
2644	+	}
2645	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2646	+	return resultobj;
2647	+	fail:
2648	+	return NULL;
2649	+	}
2650	+
2651	+
2652		static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2653		PyObject *resultobj;
2654		BossSession *arg1 = (BossSession *) 0 ;
#	Line 1964 | Line 2675 | static PyObject *_wrap_BossSession_makeB
2675		try {
2676		result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2677
2678	+	}catch (const BossSchedFailure & e) {
2679	+	PyErr_SetString ( SchedulerError, e.what() );
2680	+	return NULL;
2681		}catch (const std::exception& e) {
2682	<	SWIG_exception(SWIG_RuntimeError, e.what());
2682	>	PyErr_SetString ( BossError, e.what() );
2683	>	return NULL;
2684		}
2685		}
2686		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
#	Line 1989 | Line 2704 | static PyObject *_wrap_BossSession_destr
2704		try {
2705		(arg1)->destroyBossTask(arg2);
2706
2707	+	}catch (const BossSchedFailure & e) {
2708	+	PyErr_SetString ( SchedulerError, e.what() );
2709	+	return NULL;
2710		}catch (const std::exception& e) {
2711	<	SWIG_exception(SWIG_RuntimeError, e.what());
2711	>	PyErr_SetString ( BossError, e.what() );
2712	>	return NULL;
2713		}
2714		}
2715		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2000 | Line 2719 | static PyObject *_wrap_BossSession_destr
2719		}
2720
2721
2722	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_0(PyObject *self, PyObject *args) {
2722	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2723		PyObject *resultobj;
2724		BossSession *arg1 = (BossSession *) 0 ;
2725	<	SwigValueWrapper< std::vector<std::string > > result;
2725	>	std::vector<std::string > result;
2726		PyObject * obj0 = 0 ;
2727
2728		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
#	Line 2012 | Line 2731 | static PyObject *_wrap_BossSession_showC
2731		try {
2732		result = (arg1)->showCHTools();
2733
2734	+	}catch (const BossSchedFailure & e) {
2735	+	PyErr_SetString ( SchedulerError, e.what() );
2736	+	return NULL;
2737		}catch (const std::exception& e) {
2738	<	SWIG_exception(SWIG_RuntimeError, e.what());
2738	>	PyErr_SetString ( BossError, e.what() );
2739	>	return NULL;
2740		}
2741		}
2742		{
2743	<	std::vector<std::string > * resultptr;
2744	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2745	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2743	>	resultobj = PyTuple_New((&result)->size());
2744	>	for (unsigned int i=0; i<(&result)->size(); i++)
2745	>	PyTuple_SetItem(resultobj,i,
2746	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2747		}
2748		return resultobj;
2749		fail:
#	Line 2027 | Line 2751 | static PyObject *_wrap_BossSession_showC
2751		}
2752
2753
2754	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_0(PyObject *self, PyObject *args) {
2754	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2755		PyObject *resultobj;
2756		BossSession *arg1 = (BossSession *) 0 ;
2757	<	SwigValueWrapper< std::vector<std::string > > result;
2757	>	std::vector<std::string > result;
2758		PyObject * obj0 = 0 ;
2759
2760		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
#	Line 2039 | Line 2763 | static PyObject *_wrap_BossSession_showP
2763		try {
2764		result = (arg1)->showProgramTypes();
2765
2766	+	}catch (const BossSchedFailure & e) {
2767	+	PyErr_SetString ( SchedulerError, e.what() );
2768	+	return NULL;
2769		}catch (const std::exception& e) {
2770	<	SWIG_exception(SWIG_RuntimeError, e.what());
2770	>	PyErr_SetString ( BossError, e.what() );
2771	>	return NULL;
2772		}
2773		}
2774		{
2775	<	std::vector<std::string > * resultptr;
2776	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2777	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2775	>	resultobj = PyTuple_New((&result)->size());
2776	>	for (unsigned int i=0; i<(&result)->size(); i++)
2777	>	PyTuple_SetItem(resultobj,i,
2778	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2779		}
2780		return resultobj;
2781		fail:
#	Line 2054 | Line 2783 | static PyObject *_wrap_BossSession_showP
2783		}
2784
2785
2786	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_0(PyObject *self, PyObject *args) {
2786	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2787		PyObject *resultobj;
2788		BossSession *arg1 = (BossSession *) 0 ;
2789	<	SwigValueWrapper< std::vector<std::string > > result;
2789	>	std::vector<std::string > result;
2790		PyObject * obj0 = 0 ;
2791
2792		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
#	Line 2066 | Line 2795 | static PyObject *_wrap_BossSession_showR
2795		try {
2796		result = (arg1)->showRTMon();
2797
2798	+	}catch (const BossSchedFailure & e) {
2799	+	PyErr_SetString ( SchedulerError, e.what() );
2800	+	return NULL;
2801		}catch (const std::exception& e) {
2802	<	SWIG_exception(SWIG_RuntimeError, e.what());
2802	>	PyErr_SetString ( BossError, e.what() );
2803	>	return NULL;
2804		}
2805		}
2806		{
2807	<	std::vector<std::string > * resultptr;
2808	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2809	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2807	>	resultobj = PyTuple_New((&result)->size());
2808	>	for (unsigned int i=0; i<(&result)->size(); i++)
2809	>	PyTuple_SetItem(resultobj,i,
2810	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2811		}
2812		return resultobj;
2813		fail:
#	Line 2081 | Line 2815 | static PyObject *_wrap_BossSession_showR
2815		}
2816
2817
2818	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_0(PyObject *self, PyObject *args) {
2818	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2819		PyObject *resultobj;
2820		BossSession *arg1 = (BossSession *) 0 ;
2821	<	SwigValueWrapper< std::vector<std::string > > result;
2821	>	std::vector<std::string > result;
2822		PyObject * obj0 = 0 ;
2823
2824		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
#	Line 2093 | Line 2827 | static PyObject *_wrap_BossSession_showS
2827		try {
2828		result = (arg1)->showSchedulers();
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		{
2839	<	std::vector<std::string > * resultptr;
2840	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2841	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2839	>	resultobj = PyTuple_New((&result)->size());
2840	>	for (unsigned int i=0; i<(&result)->size(); i++)
2841	>	PyTuple_SetItem(resultobj,i,
2842	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2843		}
2844		return resultobj;
2845		fail:
#	Line 2120 | Line 2859 | static PyObject *_wrap_BossSession_defau
2859		try {
2860		result = (arg1)->defaultCHTool();
2861
2862	+	}catch (const BossSchedFailure & e) {
2863	+	PyErr_SetString ( SchedulerError, e.what() );
2864	+	return NULL;
2865		}catch (const std::exception& e) {
2866	<	SWIG_exception(SWIG_RuntimeError, e.what());
2866	>	PyErr_SetString ( BossError, e.what() );
2867	>	return NULL;
2868		}
2869		}
2870		{
#	Line 2145 | Line 2888 | static PyObject *_wrap_BossSession_defau
2888		try {
2889		result = (arg1)->defaultProgramType();
2890
2891	+	}catch (const BossSchedFailure & e) {
2892	+	PyErr_SetString ( SchedulerError, e.what() );
2893	+	return NULL;
2894		}catch (const std::exception& e) {
2895	<	SWIG_exception(SWIG_RuntimeError, e.what());
2895	>	PyErr_SetString ( BossError, e.what() );
2896	>	return NULL;
2897		}
2898		}
2899		{
#	Line 2170 | Line 2917 | static PyObject *_wrap_BossSession_defau
2917		try {
2918		result = (arg1)->defaultRTMon();
2919
2920	+	}catch (const BossSchedFailure & e) {
2921	+	PyErr_SetString ( SchedulerError, e.what() );
2922	+	return NULL;
2923		}catch (const std::exception& e) {
2924	<	SWIG_exception(SWIG_RuntimeError, e.what());
2924	>	PyErr_SetString ( BossError, e.what() );
2925	>	return NULL;
2926		}
2927		}
2928		{
#	Line 2195 | Line 2946 | static PyObject *_wrap_BossSession_defau
2946		try {
2947		result = (arg1)->defaultScheduler();
2948
2949	+	}catch (const BossSchedFailure & e) {
2950	+	PyErr_SetString ( SchedulerError, e.what() );
2951	+	return NULL;
2952		}catch (const std::exception& e) {
2953	<	SWIG_exception(SWIG_RuntimeError, e.what());
2953	>	PyErr_SetString ( BossError, e.what() );
2954	>	return NULL;
2955		}
2956		}
2957		{
#	Line 2220 | Line 2975 | static PyObject *_wrap_BossSession_versi
2975		try {
2976		result = (arg1)->version();
2977
2978	+	}catch (const BossSchedFailure & e) {
2979	+	PyErr_SetString ( SchedulerError, e.what() );
2980	+	return NULL;
2981		}catch (const std::exception& e) {
2982	<	SWIG_exception(SWIG_RuntimeError, e.what());
2982	>	PyErr_SetString ( BossError, e.what() );
2983	>	return NULL;
2984		}
2985		}
2986		{
#	Line 2245 | Line 3004 | static PyObject *_wrap_BossSession_clien
3004		try {
3005		result = (arg1)->clientID();
3006
3007	+	}catch (const BossSchedFailure & e) {
3008	+	PyErr_SetString ( SchedulerError, e.what() );
3009	+	return NULL;
3010		}catch (const std::exception& e) {
3011	<	SWIG_exception(SWIG_RuntimeError, e.what());
3011	>	PyErr_SetString ( BossError, e.what() );
3012	>	return NULL;
3013		}
3014		}
3015		{
#	Line 2276 | Line 3039 | static PyObject *_wrap_BossSession_showC
3039		try {
3040		result = (int)(arg1)->showConfigs(arg2);
3041
3042	+	}catch (const BossSchedFailure & e) {
3043	+	PyErr_SetString ( SchedulerError, e.what() );
3044	+	return NULL;
3045		}catch (const std::exception& e) {
3046	<	SWIG_exception(SWIG_RuntimeError, e.what());
3047	<	}
2282	<	}
2283	<	resultobj = PyInt_FromLong((long)result);
2284	<	return resultobj;
2285	<	fail:
2286	<	return NULL;
2287	<	}
2288	<
2289	<
2290	<	static PyObject *_wrap_BossSession_purgeTasks(PyObject *self, PyObject *args) {
2291	<	PyObject *resultobj;
2292	<	BossSession *arg1 = (BossSession *) 0 ;
2293	<	std::string *arg2 = 0 ;
2294	<	std::string *arg3 = 0 ;
2295	<	std::string *arg4 = 0 ;
2296	<	std::string const &arg5_defvalue = "0" ;
2297	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2298	<	int result;
2299	<	std::string temp2 ;
2300	<	std::string temp3 ;
2301	<	std::string temp4 ;
2302	<	std::string temp5 ;
2303	<	PyObject * obj0 = 0 ;
2304	<	PyObject * obj1 = 0 ;
2305	<	PyObject * obj2 = 0 ;
2306	<	PyObject * obj3 = 0 ;
2307	<	PyObject * obj4 = 0 ;
2308	<
2309	<	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossSession_purgeTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
2310	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2311	<	{
2312	<	if (PyString_Check(obj1)) {
2313	<	temp2 = std::string(PyString_AsString(obj1));
2314	<	arg2 = &temp2;
2315	<	}else {
2316	<	SWIG_exception(SWIG_TypeError, "string expected");
2317	<	}
2318	<	}
2319	<	{
2320	<	if (PyString_Check(obj2)) {
2321	<	temp3 = std::string(PyString_AsString(obj2));
2322	<	arg3 = &temp3;
2323	<	}else {
2324	<	SWIG_exception(SWIG_TypeError, "string expected");
2325	<	}
2326	<	}
2327	<	{
2328	<	if (PyString_Check(obj3)) {
2329	<	temp4 = std::string(PyString_AsString(obj3));
2330	<	arg4 = &temp4;
2331	<	}else {
2332	<	SWIG_exception(SWIG_TypeError, "string expected");
2333	<	}
2334	<	}
2335	<	if (obj4) {
2336	<	{
2337	<	if (PyString_Check(obj4)) {
2338	<	temp5 = std::string(PyString_AsString(obj4));
2339	<	arg5 = &temp5;
2340	<	}else {
2341	<	SWIG_exception(SWIG_TypeError, "string expected");
2342	<	}
2343	<	}
2344	<	}
2345	<	{
2346	<	try {
2347	<	result = (int)(arg1)->purgeTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
2348	<
2349	<	}catch (const std::exception& e) {
2350	<	SWIG_exception(SWIG_RuntimeError, e.what());
3046	>	PyErr_SetString ( BossError, e.what() );
3047	>	return NULL;
3048		}
3049		}
3050		resultobj = PyInt_FromLong((long)result);
#	Line 2399 | Line 3096 | static PyObject *_wrap_BossSession_RTupd
3096		try {
3097		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
3098
3099	+	}catch (const BossSchedFailure & e) {
3100	+	PyErr_SetString ( SchedulerError, e.what() );
3101	+	return NULL;
3102		}catch (const std::exception& e) {
3103	<	SWIG_exception(SWIG_RuntimeError, e.what());
3103	>	PyErr_SetString ( BossError, e.what() );
3104	>	return NULL;
3105		}
3106		}
3107		resultobj = PyInt_FromLong((long)result);
#	Line 2415 | Line 3116 | static PyObject *_wrap_BossSession_listM
3116		BossSession *arg1 = (BossSession *) 0 ;
3117		std::string *arg2 = 0 ;
3118		std::string *arg3 = 0 ;
3119	<	bool arg4 = (bool) false ;
3119	>	std::string const &arg4_defvalue = "" ;
3120	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3121		std::string const &arg5_defvalue = "" ;
3122		std::string *arg5 = (std::string *) &arg5_defvalue ;
3123	<	std::string const &arg6_defvalue = "" ;
3124	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
2423	<	std::string result;
3123	>	unsigned int arg6 = (unsigned int) 0 ;
3124	>	std::vector<std::string > result;
3125		std::string temp2 ;
3126		std::string temp3 ;
3127	+	std::string temp4 ;
3128		std::string temp5 ;
2427	–	std::string temp6 ;
3129		PyObject * obj0 = 0 ;
3130		PyObject * obj1 = 0 ;
3131		PyObject * obj2 = 0 ;
#	Line 2451 | Line 3152 | static PyObject *_wrap_BossSession_listM
3152		}
3153		}
3154		if (obj3) {
3155	<	arg4 = PyInt_AsLong(obj3) ? true : false;
3156	<	if (PyErr_Occurred()) SWIG_fail;
3155	>	{
3156	>	if (PyString_Check(obj3)) {
3157	>	temp4 = std::string(PyString_AsString(obj3));
3158	>	arg4 = &temp4;
3159	>	}else {
3160	>	SWIG_exception(SWIG_TypeError, "string expected");
3161	>	}
3162	>	}
3163		}
3164		if (obj4) {
3165		{
#	Line 2465 | Line 3172 | static PyObject *_wrap_BossSession_listM
3172		}
3173		}
3174		if (obj5) {
3175	<	{
3176	<	if (PyString_Check(obj5)) {
2470	<	temp6 = std::string(PyString_AsString(obj5));
2471	<	arg6 = &temp6;
2472	<	}else {
2473	<	SWIG_exception(SWIG_TypeError, "string expected");
2474	<	}
2475	<	}
3175	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3176	>	if (PyErr_Occurred()) SWIG_fail;
3177		}
3178		{
3179		try {
3180	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
3180	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3181
3182	+	}catch (const BossSchedFailure & e) {
3183	+	PyErr_SetString ( SchedulerError, e.what() );
3184	+	return NULL;
3185		}catch (const std::exception& e) {
3186	<	SWIG_exception(SWIG_RuntimeError, e.what());
3186	>	PyErr_SetString ( BossError, e.what() );
3187	>	return NULL;
3188		}
3189		}
3190		{
3191	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3191	>	resultobj = PyTuple_New((&result)->size());
3192	>	for (unsigned int i=0; i<(&result)->size(); i++)
3193	>	PyTuple_SetItem(resultobj,i,
3194	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3195		}
3196		return resultobj;
3197		fail:
#	Line 2491 | Line 3199 | static PyObject *_wrap_BossSession_listM
3199		}
3200
3201
3202	<	static PyObject *_wrap_BossSession_jobQuery(PyObject *self, PyObject *args) {
3202	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3203		PyObject *resultobj;
3204		BossSession *arg1 = (BossSession *) 0 ;
3205		int arg2 = (int) SCHEDULED ;
#	Line 2505 | Line 3213 | static PyObject *_wrap_BossSession_jobQu
3213		std::string arg7 = (std::string) "" ;
3214		std::string arg8 = (std::string) "" ;
3215		std::string arg9 = (std::string) "" ;
3216	<	bool arg10 = (bool) false ;
3217	<	SwigValueWrapper< std::vector<BossJob * > > result;
3216	>	unsigned int arg10 = (unsigned int) 0 ;
3217	>	bool arg11 = (bool) false ;
3218		std::string temp3 ;
3219		std::string temp4 ;
3220		std::string temp5 ;
#	Line 2519 | Line 3227 | static PyObject *_wrap_BossSession_jobQu
3227		PyObject * obj7 = 0 ;
3228		PyObject * obj8 = 0 ;
3229		PyObject * obj9 = 0 ;
3230	+	PyObject * obj10 = 0 ;
3231
3232	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_jobQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3232	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3233		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3234		if (obj2) {
3235		{
#	Line 2585 | Line 3294 | static PyObject *_wrap_BossSession_jobQu
3294		}
3295		}
3296		if (obj9) {
3297	<	arg10 = PyInt_AsLong(obj9) ? true : false;
3297	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3298	>	if (PyErr_Occurred()) SWIG_fail;
3299	>	}
3300	>	if (obj10) {
3301	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3302		if (PyErr_Occurred()) SWIG_fail;
3303		}
3304		{
3305		try {
3306	<	result = (arg1)->jobQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3306	>	(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3307
3308	+	}catch (const BossSchedFailure & e) {
3309	+	PyErr_SetString ( SchedulerError, e.what() );
3310	+	return NULL;
3311		}catch (const std::exception& e) {
3312	<	SWIG_exception(SWIG_RuntimeError, e.what());
3312	>	PyErr_SetString ( BossError, e.what() );
3313	>	return NULL;
3314	>	}
3315	>	}
3316	>	Py_INCREF(Py_None); resultobj = Py_None;
3317	>	return resultobj;
3318	>	fail:
3319	>	return NULL;
3320	>	}
3321	>
3322	>
3323	>	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3324	>	PyObject *resultobj;
3325	>	BossSession *arg1 = (BossSession *) 0 ;
3326	>	std::string *arg2 = 0 ;
3327	>	unsigned int result;
3328	>	std::string temp2 ;
3329	>	PyObject * obj0 = 0 ;
3330	>	PyObject * obj1 = 0 ;
3331	>
3332	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3333	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3334	>	{
3335	>	if (PyString_Check(obj1)) {
3336	>	temp2 = std::string(PyString_AsString(obj1));
3337	>	arg2 = &temp2;
3338	>	}else {
3339	>	SWIG_exception(SWIG_TypeError, "string expected");
3340		}
3341		}
3342		{
3343	<	std::vector<BossJob * > * resultptr;
3344	<	resultptr = new std::vector<BossJob * >((std::vector<BossJob * > &) result);
3345	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossJob_p_t, 1);
3343	>	try {
3344	>	result = (unsigned int)(arg1)->getTasksByName((std::string const &)*arg2);
3345	>
3346	>	}catch (const BossSchedFailure & e) {
3347	>	PyErr_SetString ( SchedulerError, e.what() );
3348	>	return NULL;
3349	>	}catch (const std::exception& e) {
3350	>	PyErr_SetString ( BossError, e.what() );
3351	>	return NULL;
3352	>	}
3353		}
3354	+	resultobj = PyInt_FromLong((long)result);
3355		return resultobj;
3356		fail:
3357		return NULL;
3358		}
3359
3360
3361	<	static PyObject *_wrap_BossSession_queryPrint(PyObject *self, PyObject *args) {
3361	>	static PyObject *_wrap_BossSession_getTasksByTaskInfo(PyObject *self, PyObject *args) {
3362		PyObject *resultobj;
3363		BossSession *arg1 = (BossSession *) 0 ;
3364	<	SwigValueWrapper< std::vector<BossJob * > > arg2 ;
3365	<	std::ostream &arg3_defvalue = std::cout ;
3366	<	std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
2616	<	jobStates const &arg4_defvalue = SCHEDULED ;
2617	<	jobStates *arg4 = (jobStates *) &arg4_defvalue ;
2618	<	printOption const &arg5_defvalue = NORMAL ;
2619	<	printOption *arg5 = (printOption *) &arg5_defvalue ;
2620	<	std::string const &arg6_defvalue = "" ;
2621	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
2622	<	std::vector<BossJob * > *argp2 ;
2623	<	std::string temp6 ;
3364	>	std::string *arg2 = 0 ;
3365	>	unsigned int result;
3366	>	std::string temp2 ;
3367		PyObject * obj0 = 0 ;
3368		PyObject * obj1 = 0 ;
2626	–	PyObject * obj2 = 0 ;
2627	–	PyObject * obj3 = 0 ;
2628	–	PyObject * obj4 = 0 ;
2629	–	PyObject * obj5 = 0 ;
3369
3370	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossSession_queryPrint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3370	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByTaskInfo",&obj0,&obj1)) goto fail;
3371		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3372	<	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3373	<	arg2 = *argp2;
3374	<	if (obj2) {
3375	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3376	<	if (arg3 == NULL) {
3377	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3372	>	{
3373	>	if (PyString_Check(obj1)) {
3374	>	temp2 = std::string(PyString_AsString(obj1));
3375	>	arg2 = &temp2;
3376	>	}else {
3377	>	SWIG_exception(SWIG_TypeError, "string expected");
3378		}
3379		}
3380	<	if (obj3) {
3381	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3382	<	if (arg4 == NULL) {
3383	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3380	>	{
3381	>	try {
3382	>	result = (unsigned int)(arg1)->getTasksByTaskInfo((std::string const &)*arg2);
3383	>
3384	>	}catch (const BossSchedFailure & e) {
3385	>	PyErr_SetString ( SchedulerError, e.what() );
3386	>	return NULL;
3387	>	}catch (const std::exception& e) {
3388	>	PyErr_SetString ( BossError, e.what() );
3389	>	return NULL;
3390		}
3391		}
3392	<	if (obj4) {
3393	<	if ((SWIG_ConvertPtr(obj4,(void **) &arg5, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3394	<	if (arg5 == NULL) {
3395	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3392	>	resultobj = PyInt_FromLong((long)result);
3393	>	return resultobj;
3394	>	fail:
3395	>	return NULL;
3396	>	}
3397	>
3398	>
3399	>	static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3400	>	PyObject *resultobj;
3401	>	BossSession *arg1 = (BossSession *) 0 ;
3402	>	std::string *arg2 = 0 ;
3403	>	unsigned int result;
3404	>	std::string temp2 ;
3405	>	PyObject * obj0 = 0 ;
3406	>	PyObject * obj1 = 0 ;
3407	>
3408	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3409	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3410	>	{
3411	>	if (PyString_Check(obj1)) {
3412	>	temp2 = std::string(PyString_AsString(obj1));
3413	>	arg2 = &temp2;
3414	>	}else {
3415	>	SWIG_exception(SWIG_TypeError, "string expected");
3416		}
3417		}
3418	<	if (obj5) {
3419	<	{
3420	<	if (PyString_Check(obj5)) {
3421	<	temp6 = std::string(PyString_AsString(obj5));
3422	<	arg6 = &temp6;
3423	<	}else {
3424	<	SWIG_exception(SWIG_TypeError, "string expected");
3425	<	}
3418	>	{
3419	>	try {
3420	>	result = (unsigned int)(arg1)->getTasksByJobName((std::string const &)*arg2);
3421	>
3422	>	}catch (const BossSchedFailure & e) {
3423	>	PyErr_SetString ( SchedulerError, e.what() );
3424	>	return NULL;
3425	>	}catch (const std::exception& e) {
3426	>	PyErr_SetString ( BossError, e.what() );
3427	>	return NULL;
3428	>	}
3429	>	}
3430	>	resultobj = PyInt_FromLong((long)result);
3431	>	return resultobj;
3432	>	fail:
3433	>	return NULL;
3434	>	}
3435	>
3436	>
3437	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3438	>	PyObject *resultobj;
3439	>	BossSession *arg1 = (BossSession *) 0 ;
3440	>	std::vector<std::string > *arg2 = 0 ;
3441	>	PyObject *result;
3442	>	PyObject * obj0 = 0 ;
3443	>	PyObject * obj1 = 0 ;
3444	>
3445	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3446	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3447	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3448	>	if (arg2 == NULL) {
3449	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3450	>	}
3451	>	{
3452	>	try {
3453	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3454	>
3455	>	}catch (const BossSchedFailure & e) {
3456	>	PyErr_SetString ( SchedulerError, e.what() );
3457	>	return NULL;
3458	>	}catch (const std::exception& e) {
3459	>	PyErr_SetString ( BossError, e.what() );
3460	>	return NULL;
3461		}
3462		}
3463	+	resultobj = result;
3464	+	return resultobj;
3465	+	fail:
3466	+	return NULL;
3467	+	}
3468	+
3469	+
3470	+	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3471	+	PyObject *resultobj;
3472	+	BossSession *arg1 = (BossSession *) 0 ;
3473	+	PyObject *result;
3474	+	PyObject * obj0 = 0 ;
3475	+
3476	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3477	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3478		{
3479		try {
3480	<	(arg1)->queryPrint(arg2,*arg3,(jobStates const &)*arg4,(printOption const &)*arg5,(std::string const &)*arg6);
3480	>	result = (PyObject *)BossSession_CHTools(arg1);
3481
3482	+	}catch (const BossSchedFailure & e) {
3483	+	PyErr_SetString ( SchedulerError, e.what() );
3484	+	return NULL;
3485		}catch (const std::exception& e) {
3486	<	SWIG_exception(SWIG_RuntimeError, e.what());
3486	>	PyErr_SetString ( BossError, e.what() );
3487	>	return NULL;
3488		}
3489		}
3490	<	Py_INCREF(Py_None); resultobj = Py_None;
3490	>	resultobj = result;
3491		return resultobj;
3492		fail:
3493		return NULL;
3494		}
3495
3496
3497	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3497	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3498		PyObject *resultobj;
3499		BossSession *arg1 = (BossSession *) 0 ;
3500	<	std::string const &arg2_defvalue = "all" ;
3501	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3502	<	std::string const &arg3_defvalue = "" ;
3503	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3500	>	PyObject *result;
3501	>	PyObject * obj0 = 0 ;
3502	>
3503	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3504	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3505	>	{
3506	>	try {
3507	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3508	>
3509	>	}catch (const BossSchedFailure & e) {
3510	>	PyErr_SetString ( SchedulerError, e.what() );
3511	>	return NULL;
3512	>	}catch (const std::exception& e) {
3513	>	PyErr_SetString ( BossError, e.what() );
3514	>	return NULL;
3515	>	}
3516	>	}
3517	>	resultobj = result;
3518	>	return resultobj;
3519	>	fail:
3520	>	return NULL;
3521	>	}
3522	>
3523	>
3524	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3525	>	PyObject *resultobj;
3526	>	BossSession *arg1 = (BossSession *) 0 ;
3527	>	PyObject *result;
3528	>	PyObject * obj0 = 0 ;
3529	>
3530	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3531	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3532	>	{
3533	>	try {
3534	>	result = (PyObject *)BossSession_RTMons(arg1);
3535	>
3536	>	}catch (const BossSchedFailure & e) {
3537	>	PyErr_SetString ( SchedulerError, e.what() );
3538	>	return NULL;
3539	>	}catch (const std::exception& e) {
3540	>	PyErr_SetString ( BossError, e.what() );
3541	>	return NULL;
3542	>	}
3543	>	}
3544	>	resultobj = result;
3545	>	return resultobj;
3546	>	fail:
3547	>	return NULL;
3548	>	}
3549	>
3550	>
3551	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3552	>	PyObject *resultobj;
3553	>	BossSession *arg1 = (BossSession *) 0 ;
3554	>	PyObject *result;
3555	>	PyObject * obj0 = 0 ;
3556	>
3557	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3558	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3559	>	{
3560	>	try {
3561	>	result = (PyObject *)BossSession_schedulers(arg1);
3562	>
3563	>	}catch (const BossSchedFailure & e) {
3564	>	PyErr_SetString ( SchedulerError, e.what() );
3565	>	return NULL;
3566	>	}catch (const std::exception& e) {
3567	>	PyErr_SetString ( BossError, e.what() );
3568	>	return NULL;
3569	>	}
3570	>	}
3571	>	resultobj = result;
3572	>	return resultobj;
3573	>	fail:
3574	>	return NULL;
3575	>	}
3576	>
3577	>
3578	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3579	>	PyObject *resultobj;
3580	>	BossSession *arg1 = (BossSession *) 0 ;
3581	>	std::string *arg2 = 0 ;
3582	>	std::string *arg3 = 0 ;
3583		std::string const &arg4_defvalue = "" ;
3584		std::string *arg4 = (std::string *) &arg4_defvalue ;
3585		std::string const &arg5_defvalue = "" ;
3586		std::string *arg5 = (std::string *) &arg5_defvalue ;
3587	<	SwigValueWrapper< std::vector<std::string > > result;
3587	>	unsigned int arg6 = (unsigned int) 0 ;
3588	>	PyObject *result;
3589		std::string temp2 ;
3590		std::string temp3 ;
3591		std::string temp4 ;
#	Line 2696 | Line 3595 | static PyObject *_wrap_BossSession_selec
3595		PyObject * obj2 = 0 ;
3596		PyObject * obj3 = 0 ;
3597		PyObject * obj4 = 0 ;
3598	+	PyObject * obj5 = 0 ;
3599
3600	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3600	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3601		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3602	<	if (obj1) {
3602	>	{
3603	>	if (PyString_Check(obj1)) {
3604	>	temp2 = std::string(PyString_AsString(obj1));
3605	>	arg2 = &temp2;
3606	>	}else {
3607	>	SWIG_exception(SWIG_TypeError, "string expected");
3608	>	}
3609	>	}
3610	>	{
3611	>	if (PyString_Check(obj2)) {
3612	>	temp3 = std::string(PyString_AsString(obj2));
3613	>	arg3 = &temp3;
3614	>	}else {
3615	>	SWIG_exception(SWIG_TypeError, "string expected");
3616	>	}
3617	>	}
3618	>	if (obj3) {
3619		{
3620	<	if (PyString_Check(obj1)) {
3621	<	temp2 = std::string(PyString_AsString(obj1));
3622	<	arg2 = &temp2;
3620	>	if (PyString_Check(obj3)) {
3621	>	temp4 = std::string(PyString_AsString(obj3));
3622	>	arg4 = &temp4;
3623		}else {
3624		SWIG_exception(SWIG_TypeError, "string expected");
3625		}
3626		}
3627		}
3628	+	if (obj4) {
3629	+	{
3630	+	if (PyString_Check(obj4)) {
3631	+	temp5 = std::string(PyString_AsString(obj4));
3632	+	arg5 = &temp5;
3633	+	}else {
3634	+	SWIG_exception(SWIG_TypeError, "string expected");
3635	+	}
3636	+	}
3637	+	}
3638	+	if (obj5) {
3639	+	arg6 = (unsigned int) PyInt_AsLong(obj5);
3640	+	if (PyErr_Occurred()) SWIG_fail;
3641	+	}
3642	+	{
3643	+	try {
3644	+	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3645	+
3646	+	}catch (const BossSchedFailure & e) {
3647	+	PyErr_SetString ( SchedulerError, e.what() );
3648	+	return NULL;
3649	+	}catch (const std::exception& e) {
3650	+	PyErr_SetString ( BossError, e.what() );
3651	+	return NULL;
3652	+	}
3653	+	}
3654	+	resultobj = result;
3655	+	return resultobj;
3656	+	fail:
3657	+	return NULL;
3658	+	}
3659	+
3660	+
3661	+	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3662	+	PyObject *resultobj;
3663	+	BossSession *arg1 = (BossSession *) 0 ;
3664	+	int arg2 = (int) SCHEDULED ;
3665	+	std::string const &arg3_defvalue = "all" ;
3666	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
3667	+	std::string const &arg4_defvalue = "all" ;
3668	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
3669	+	std::string const &arg5_defvalue = "" ;
3670	+	std::string *arg5 = (std::string *) &arg5_defvalue ;
3671	+	std::string arg6 = (std::string) "" ;
3672	+	std::string arg7 = (std::string) "" ;
3673	+	std::string arg8 = (std::string) "" ;
3674	+	std::string arg9 = (std::string) "" ;
3675	+	unsigned int arg10 = (unsigned int) 0 ;
3676	+	bool arg11 = (bool) false ;
3677	+	std::string temp3 ;
3678	+	std::string temp4 ;
3679	+	std::string temp5 ;
3680	+	PyObject * obj0 = 0 ;
3681	+	PyObject * obj2 = 0 ;
3682	+	PyObject * obj3 = 0 ;
3683	+	PyObject * obj4 = 0 ;
3684	+	PyObject * obj5 = 0 ;
3685	+	PyObject * obj6 = 0 ;
3686	+	PyObject * obj7 = 0 ;
3687	+	PyObject * obj8 = 0 ;
3688	+	PyObject * obj9 = 0 ;
3689	+	PyObject * obj10 = 0 ;
3690	+
3691	+	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3692	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3693		if (obj2) {
3694		{
3695		if (PyString_Check(obj2)) {
#	Line 2739 | Line 3720 | static PyObject *_wrap_BossSession_selec
3720		}
3721		}
3722		}
3723	+	if (obj5) {
3724	+	{
3725	+	if (PyString_Check(obj5))
3726	+	arg6 = std::string(PyString_AsString(obj5));
3727	+	else
3728	+	SWIG_exception(SWIG_TypeError, "string expected");
3729	+	}
3730	+	}
3731	+	if (obj6) {
3732	+	{
3733	+	if (PyString_Check(obj6))
3734	+	arg7 = std::string(PyString_AsString(obj6));
3735	+	else
3736	+	SWIG_exception(SWIG_TypeError, "string expected");
3737	+	}
3738	+	}
3739	+	if (obj7) {
3740	+	{
3741	+	if (PyString_Check(obj7))
3742	+	arg8 = std::string(PyString_AsString(obj7));
3743	+	else
3744	+	SWIG_exception(SWIG_TypeError, "string expected");
3745	+	}
3746	+	}
3747	+	if (obj8) {
3748	+	{
3749	+	if (PyString_Check(obj8))
3750	+	arg9 = std::string(PyString_AsString(obj8));
3751	+	else
3752	+	SWIG_exception(SWIG_TypeError, "string expected");
3753	+	}
3754	+	}
3755	+	if (obj9) {
3756	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3757	+	if (PyErr_Occurred()) SWIG_fail;
3758	+	}
3759	+	if (obj10) {
3760	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3761	+	if (PyErr_Occurred()) SWIG_fail;
3762	+	}
3763		{
3764		try {
3765	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3765	>	BossSession_schedulerQuery(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3766
3767	+	}catch (const BossSchedFailure & e) {
3768	+	PyErr_SetString ( SchedulerError, e.what() );
3769	+	return NULL;
3770		}catch (const std::exception& e) {
3771	<	SWIG_exception(SWIG_RuntimeError, e.what());
3771	>	PyErr_SetString ( BossError, e.what() );
3772	>	return NULL;
3773		}
3774		}
3775	<	{
2751	<	std::vector<std::string > * resultptr;
2752	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2753	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2754	<	}
3775	>	Py_INCREF(Py_None); resultobj = Py_None;
3776		return resultobj;
3777		fail:
3778		return NULL;
#	Line 2765 | Line 3786 | static PyObject * BossSession_swigregist
3786		Py_INCREF(obj);
3787		return Py_BuildValue((char *)"");
3788		}
2768	–	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
2769	–	PyObject *resultobj;
2770	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
2771	–	char *arg2 ;
2772	–	PyObject * obj0 = 0 ;
2773	–
2774	–	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
2775	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2776	–	{
2777	–	if (arg2) {
2778	–	arg1->key = (char const *) (new char[strlen(arg2)+1]);
2779	–	strcpy((char *) arg1->key,arg2);
2780	–	}else {
2781	–	arg1->key = 0;
2782	–	}
2783	–	}
2784	–	Py_INCREF(Py_None); resultobj = Py_None;
2785	–	return resultobj;
2786	–	fail:
2787	–	return NULL;
2788	–	}
2789	–
2790	–
2791	–	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
2792	–	PyObject *resultobj;
2793	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
2794	–	char *result;
2795	–	PyObject * obj0 = 0 ;
2796	–
2797	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
2798	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2799	–	result = (char *) ((arg1)->key);
2800	–
2801	–	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
2802	–	return resultobj;
2803	–	fail:
2804	–	return NULL;
2805	–	}
2806	–
2807	–
3789		static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3790		PyObject *resultobj;
3791		char *arg1 ;
#	Line 2815 | Line 3796 | static PyObject *_wrap_new_BossTaskExcep
3796		try {
3797		result = (BossTaskException *)new BossTaskException((char const *)arg1);
3798
3799	+	}catch (const BossSchedFailure & e) {
3800	+	PyErr_SetString ( SchedulerError, e.what() );
3801	+	return NULL;
3802		}catch (const std::exception& e) {
3803	<	SWIG_exception(SWIG_RuntimeError, e.what());
3803	>	PyErr_SetString ( BossError, e.what() );
3804	>	return NULL;
3805		}
3806		}
3807		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
#	Line 2826 | Line 3811 | static PyObject *_wrap_new_BossTaskExcep
3811		}
3812
3813
2829	–	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
2830	–	PyObject *resultobj;
2831	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
2832	–	char *result;
2833	–	PyObject * obj0 = 0 ;
2834	–
2835	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
2836	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2837	–	{
2838	–	try {
2839	–	result = (char *)((BossTaskException const *)arg1)->what();
2840	–
2841	–	}catch (const std::exception& e) {
2842	–	SWIG_exception(SWIG_RuntimeError, e.what());
2843	–	}
2844	–	}
2845	–	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
2846	–	return resultobj;
2847	–	fail:
2848	–	return NULL;
2849	–	}
2850	–
2851	–
3814		static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3815		PyObject *resultobj;
3816		BossTaskException *arg1 = (BossTaskException *) 0 ;
#	Line 2860 | Line 3822 | static PyObject *_wrap_delete_BossTaskEx
3822		try {
3823		delete arg1;
3824
3825	+	}catch (const BossSchedFailure & e) {
3826	+	PyErr_SetString ( SchedulerError, e.what() );
3827	+	return NULL;
3828		}catch (const std::exception& e) {
3829	<	SWIG_exception(SWIG_RuntimeError, e.what());
3829	>	PyErr_SetString ( BossError, e.what() );
3830	>	return NULL;
3831		}
3832		}
3833		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2878 | Line 3844 | static PyObject * BossTaskException_swig
3844		Py_INCREF(obj);
3845		return Py_BuildValue((char *)"");
3846		}
3847	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3847	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3848		PyObject *resultobj;
3849		BossTask *arg1 = (BossTask *) 0 ;
3850	<	PyObject *arg2 = (PyObject *) 0 ;
2885	<	BossAttributeContainer *arg3 = 0 ;
2886	<	PyObject *result;
3850	>	BossTask::job_iterator result;
3851		PyObject * obj0 = 0 ;
2888	–	PyObject * obj1 = 0 ;
2889	–	PyObject * obj2 = 0 ;
3852
3853	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3853	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3854		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2893	–	arg2 = obj1;
2894	–	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2895	–	if (arg3 == NULL) {
2896	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2897	–	}
3855		{
3856		try {
3857	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3857	>	result = ((BossTask const *)arg1)->job_begin();
3858
3859	+	}catch (const BossSchedFailure & e) {
3860	+	PyErr_SetString ( SchedulerError, e.what() );
3861	+	return NULL;
3862		}catch (const std::exception& e) {
3863	<	SWIG_exception(SWIG_RuntimeError, e.what());
3863	>	PyErr_SetString ( BossError, e.what() );
3864	>	return NULL;
3865		}
3866		}
3867	<	resultobj = result;
3867	>	{
3868	>	BossTask::job_iterator * resultptr;
3869	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3870	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3871	>	}
3872		return resultobj;
3873		fail:
3874		return NULL;
3875		}
3876
3877
3878	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3878	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3879		PyObject *resultobj;
3880		BossTask *arg1 = (BossTask *) 0 ;
3881	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
2917	<	PyObject *result;
3881	>	BossTask::job_iterator result;
3882		PyObject * obj0 = 0 ;
2919	–	PyObject * obj1 = 0 ;
3883
3884	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3884	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3885		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2923	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2924	–	if (arg2 == NULL) {
2925	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2926	–	}
3886		{
3887		try {
3888	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3888	>	result = ((BossTask const *)arg1)->job_end();
3889
3890	+	}catch (const BossSchedFailure & e) {
3891	+	PyErr_SetString ( SchedulerError, e.what() );
3892	+	return NULL;
3893		}catch (const std::exception& e) {
3894	<	SWIG_exception(SWIG_RuntimeError, e.what());
3894	>	PyErr_SetString ( BossError, e.what() );
3895	>	return NULL;
3896		}
3897		}
3898	<	resultobj = result;
3898	>	{
3899	>	BossTask::job_iterator * resultptr;
3900	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3901	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3902	>	}
3903		return resultobj;
3904		fail:
3905		return NULL;
3906		}
3907
3908
3909	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3909	>	static PyObject *_wrap_BossTask_jobsInMemory(PyObject *self, PyObject *args) {
3910		PyObject *resultobj;
3911		BossTask *arg1 = (BossTask *) 0 ;
3912	<	PyObject *result;
3912	>	unsigned int result;
3913		PyObject * obj0 = 0 ;
3914
3915	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3915	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsInMemory",&obj0)) goto fail;
3916		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3917		{
3918		try {
3919	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3919	>	result = (unsigned int)((BossTask const *)arg1)->jobsInMemory();
3920
3921	+	}catch (const BossSchedFailure & e) {
3922	+	PyErr_SetString ( SchedulerError, e.what() );
3923	+	return NULL;
3924		}catch (const std::exception& e) {
3925	<	SWIG_exception(SWIG_RuntimeError, e.what());
3925	>	PyErr_SetString ( BossError, e.what() );
3926	>	return NULL;
3927		}
3928		}
3929	<	resultobj = result;
3929	>	resultobj = PyInt_FromLong((long)result);
3930		return resultobj;
3931		fail:
3932		return NULL;
3933		}
3934
3935
3936	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3937	<	int argc;
3938	<	PyObject *argv[2];
3939	<	int ii;
3936	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3937	>	PyObject *resultobj;
3938	>	BossTask *arg1 = (BossTask *) 0 ;
3939	>	BossJob *arg2 = (BossJob *) 0 ;
3940	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3941	>	PyObject * obj0 = 0 ;
3942	>	PyObject * obj1 = 0 ;
3943
3944	<	argc = PyObject_Length(args);
3945	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3946	<	argv[ii] = PyTuple_GetItem(args,ii);
3947	<	}
3948	<	if (argc == 1) {
3949	<	int _v;
3950	<	{
3951	<	void *ptr;
3952	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3953	<	_v = 0;
3954	<	PyErr_Clear();
3955	<	}else {
3956	<	_v = 1;
2983	<	}
2984	<	}
2985	<	if (_v) {
2986	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
3944	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3945	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3946	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3947	>	{
3948	>	try {
3949	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
3950	>
3951	>	}catch (const BossSchedFailure & e) {
3952	>	PyErr_SetString ( SchedulerError, e.what() );
3953	>	return NULL;
3954	>	}catch (const std::exception& e) {
3955	>	PyErr_SetString ( BossError, e.what() );
3956	>	return NULL;
3957		}
3958		}
3959	<
3960	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3959	>	{
3960	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3961	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3962	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3963	>	}
3964	>	return resultobj;
3965	>	fail:
3966		return NULL;
3967		}
3968
3969
3970	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3970	>	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
3971		PyObject *resultobj;
3972		BossTask *arg1 = (BossTask *) 0 ;
3973	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3974	<	PyObject *result;
3973	>	BossJob *arg2 = (BossJob *) 0 ;
3974	>	std::string *arg3 = 0 ;
3975	>	BossProgram result;
3976	>	std::string temp3 ;
3977		PyObject * obj0 = 0 ;
3978		PyObject * obj1 = 0 ;
3979	+	PyObject * obj2 = 0 ;
3980
3981	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3981	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
3982		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3983	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3984	<	if (arg2 == NULL) {
3985	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3983	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3984	>	{
3985	>	if (PyString_Check(obj2)) {
3986	>	temp3 = std::string(PyString_AsString(obj2));
3987	>	arg3 = &temp3;
3988	>	}else {
3989	>	SWIG_exception(SWIG_TypeError, "string expected");
3990	>	}
3991		}
3992		{
3993		try {
3994	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3994	>	result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
3995
3996	+	}catch (const BossSchedFailure & e) {
3997	+	PyErr_SetString ( SchedulerError, e.what() );
3998	+	return NULL;
3999		}catch (const std::exception& e) {
4000	<	SWIG_exception(SWIG_RuntimeError, e.what());
4000	>	PyErr_SetString ( BossError, e.what() );
4001	>	return NULL;
4002		}
4003		}
4004	<	resultobj = result;
4004	>	{
4005	>	BossProgram * resultptr;
4006	>	resultptr = new BossProgram((BossProgram &) result);
4007	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4008	>	}
4009		return resultobj;
4010		fail:
4011		return NULL;
4012		}
4013
4014
4015	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
4015	>	static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4016		PyObject *resultobj;
4017		BossTask *arg1 = (BossTask *) 0 ;
4018	<	std::string *arg2 = 0 ;
4019	<	PyObject *result;
4020	<	std::string temp2 ;
4018	>	BossJob *arg2 = (BossJob *) 0 ;
4019	>	std::string *arg3 = 0 ;
4020	>	BossProgramExec result;
4021	>	std::string temp3 ;
4022		PyObject * obj0 = 0 ;
4023		PyObject * obj1 = 0 ;
4024	+	PyObject * obj2 = 0 ;
4025
4026	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
4026	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4027		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4028	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4029		{
4030	<	if (PyString_Check(obj1)) {
4031	<	temp2 = std::string(PyString_AsString(obj1));
4032	<	arg2 = &temp2;
4030	>	if (PyString_Check(obj2)) {
4031	>	temp3 = std::string(PyString_AsString(obj2));
4032	>	arg3 = &temp3;
4033		}else {
4034		SWIG_exception(SWIG_TypeError, "string expected");
4035		}
4036		}
4037		{
4038		try {
4039	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
4039	>	result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4040
4041	+	}catch (const BossSchedFailure & e) {
4042	+	PyErr_SetString ( SchedulerError, e.what() );
4043	+	return NULL;
4044		}catch (const std::exception& e) {
4045	<	SWIG_exception(SWIG_RuntimeError, e.what());
4045	>	PyErr_SetString ( BossError, e.what() );
4046	>	return NULL;
4047		}
4048		}
4049	<	resultobj = result;
4049	>	{
4050	>	BossProgramExec * resultptr;
4051	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4052	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4053	>	}
4054		return resultobj;
4055		fail:
4056		return NULL;
#	Line 3067 | Line 4069 | static PyObject *_wrap_new_BossTask__SWI
4069		try {
4070		result = (BossTask *)new BossTask(arg1);
4071
4072	+	}catch (const BossSchedFailure & e) {
4073	+	PyErr_SetString ( SchedulerError, e.what() );
4074	+	return NULL;
4075		}catch (const std::exception& e) {
4076	<	SWIG_exception(SWIG_RuntimeError, e.what());
4076	>	PyErr_SetString ( BossError, e.what() );
4077	>	return NULL;
4078		}
4079		}
4080		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3101 | Line 4107 | static PyObject *_wrap_new_BossTask__SWI
4107		try {
4108		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
4109
4110	+	}catch (const BossSchedFailure & e) {
4111	+	PyErr_SetString ( SchedulerError, e.what() );
4112	+	return NULL;
4113		}catch (const std::exception& e) {
4114	<	SWIG_exception(SWIG_RuntimeError, e.what());
4114	>	PyErr_SetString ( BossError, e.what() );
4115	>	return NULL;
4116		}
4117		}
4118		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3123 | Line 4133 | static PyObject *_wrap_delete_BossTask(P
4133		try {
4134		delete arg1;
4135
4136	+	}catch (const BossSchedFailure & e) {
4137	+	PyErr_SetString ( SchedulerError, e.what() );
4138	+	return NULL;
4139		}catch (const std::exception& e) {
4140	<	SWIG_exception(SWIG_RuntimeError, e.what());
4140	>	PyErr_SetString ( BossError, e.what() );
4141	>	return NULL;
4142		}
4143		}
4144		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3149 | Line 4163 | static PyObject *_wrap_new_BossTask__SWI
4163		try {
4164		result = (BossTask *)new BossTask((BossTask const &)*arg1);
4165
4166	+	}catch (const BossSchedFailure & e) {
4167	+	PyErr_SetString ( SchedulerError, e.what() );
4168	+	return NULL;
4169		}catch (const std::exception& e) {
4170	<	SWIG_exception(SWIG_RuntimeError, e.what());
4170	>	PyErr_SetString ( BossError, e.what() );
4171	>	return NULL;
4172		}
4173		}
4174		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3240 | Line 4258 | static PyObject *_wrap_BossTask_id(PyObj
4258		result = (std::string *) &_result_ref;
4259		}
4260
4261	+	}catch (const BossSchedFailure & e) {
4262	+	PyErr_SetString ( SchedulerError, e.what() );
4263	+	return NULL;
4264		}catch (const std::exception& e) {
4265	<	SWIG_exception(SWIG_RuntimeError, e.what());
4265	>	PyErr_SetString ( BossError, e.what() );
4266	>	return NULL;
4267		}
4268		}
4269		{
#	Line 3268 | Line 4290 | static PyObject *_wrap_BossTask_name(PyO
4290		result = (std::string *) &_result_ref;
4291		}
4292
4293	+	}catch (const BossSchedFailure & e) {
4294	+	PyErr_SetString ( SchedulerError, e.what() );
4295	+	return NULL;
4296		}catch (const std::exception& e) {
4297	<	SWIG_exception(SWIG_RuntimeError, e.what());
4297	>	PyErr_SetString ( BossError, e.what() );
4298	>	return NULL;
4299		}
4300		}
4301		{
#	Line 3281 | Line 4307 | static PyObject *_wrap_BossTask_name(PyO
4307		}
4308
4309
4310	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
4310	>	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4311		PyObject *resultobj;
4312		BossTask *arg1 = (BossTask *) 0 ;
4313	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4313	>	std::string *arg2 = 0 ;
4314	>	BossChain result;
4315	>	std::string temp2 ;
4316		PyObject * obj0 = 0 ;
4317	+	PyObject * obj1 = 0 ;
4318
4319	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4319	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4320		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4321		{
4322	+	if (PyString_Check(obj1)) {
4323	+	temp2 = std::string(PyString_AsString(obj1));
4324	+	arg2 = &temp2;
4325	+	}else {
4326	+	SWIG_exception(SWIG_TypeError, "string expected");
4327	+	}
4328	+	}
4329	+	{
4330		try {
4331	<	result = ((BossTask const *)arg1)->jobsMap();
4331	>	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4332
4333	+	}catch (const BossSchedFailure & e) {
4334	+	PyErr_SetString ( SchedulerError, e.what() );
4335	+	return NULL;
4336		}catch (const std::exception& e) {
4337	<	SWIG_exception(SWIG_RuntimeError, e.what());
4337	>	PyErr_SetString ( BossError, e.what() );
4338	>	return NULL;
4339		}
4340		}
4341		{
4342	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4343	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4344	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4342	>	BossChain * resultptr;
4343	>	resultptr = new BossChain((BossChain &) result);
4344	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4345		}
4346		return resultobj;
4347		fail:
#	Line 3308 | Line 4349 | static PyObject *_wrap_BossTask_jobsMap_
4349		}
4350
4351
4352	<	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4352	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4353		PyObject *resultobj;
4354		BossTask *arg1 = (BossTask *) 0 ;
3314	–	unsigned int arg2 ;
4355		std::map<std::string,std::string > result;
4356		PyObject * obj0 = 0 ;
3317	–	PyObject * obj1 = 0 ;
4357
4358	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4358	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4359		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3321	–	arg2 = (unsigned int) PyInt_AsLong(obj1);
3322	–	if (PyErr_Occurred()) SWIG_fail;
4360		{
4361		try {
4362	<	result = ((BossTask const *)arg1)->jobMap(arg2);
4362	>	result = ((BossTask const *)arg1)->taskMap();
4363
4364	+	}catch (const BossSchedFailure & e) {
4365	+	PyErr_SetString ( SchedulerError, e.what() );
4366	+	return NULL;
4367		}catch (const std::exception& e) {
4368	<	SWIG_exception(SWIG_RuntimeError, e.what());
4368	>	PyErr_SetString ( BossError, e.what() );
4369	>	return NULL;
4370		}
4371		}
4372		{
#	Line 3342 | Line 4383 | static PyObject *_wrap_BossTask_jobMap__
4383		}
4384
4385
4386	<	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4386	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4387	>	PyObject *resultobj;
4388	>	BossTask *arg1 = (BossTask *) 0 ;
4389	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4390	>	PyObject * obj0 = 0 ;
4391	>
4392	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4393	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4394	>	{
4395	>	try {
4396	>	result = ((BossTask const *)arg1)->jobsMap();
4397	>
4398	>	}catch (const BossSchedFailure & e) {
4399	>	PyErr_SetString ( SchedulerError, e.what() );
4400	>	return NULL;
4401	>	}catch (const std::exception& e) {
4402	>	PyErr_SetString ( BossError, e.what() );
4403	>	return NULL;
4404	>	}
4405	>	}
4406	>	{
4407	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4408	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4409	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4410	>	}
4411	>	return resultobj;
4412	>	fail:
4413	>	return NULL;
4414	>	}
4415	>
4416	>
4417	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4418		PyObject *resultobj;
4419		BossTask *arg1 = (BossTask *) 0 ;
4420		SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
#	Line 3365 | Line 4437 | static PyObject *_wrap_BossTask_jobMap__
4437		try {
4438		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4439
4440	+	}catch (const BossSchedFailure & e) {
4441	+	PyErr_SetString ( SchedulerError, e.what() );
4442	+	return NULL;
4443		}catch (const std::exception& e) {
4444	<	SWIG_exception(SWIG_RuntimeError, e.what());
4444	>	PyErr_SetString ( BossError, e.what() );
4445	>	return NULL;
4446		}
4447		}
4448		{
#	Line 3378 | Line 4454 | static PyObject *_wrap_BossTask_jobMap__
4454		}
4455
4456
4457	+	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4458	+	PyObject *resultobj;
4459	+	BossTask *arg1 = (BossTask *) 0 ;
4460	+	unsigned int arg2 ;
4461	+	std::map<std::string,std::string > result;
4462	+	PyObject * obj0 = 0 ;
4463	+	PyObject * obj1 = 0 ;
4464	+
4465	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4466	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4467	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
4468	+	if (PyErr_Occurred()) SWIG_fail;
4469	+	{
4470	+	try {
4471	+	result = ((BossTask const *)arg1)->jobMap(arg2);
4472	+
4473	+	}catch (const BossSchedFailure & e) {
4474	+	PyErr_SetString ( SchedulerError, e.what() );
4475	+	return NULL;
4476	+	}catch (const std::exception& e) {
4477	+	PyErr_SetString ( BossError, e.what() );
4478	+	return NULL;
4479	+	}
4480	+	}
4481	+	{
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:
4491	+	return NULL;
4492	+	}
4493	+
4494	+
4495		static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4496		int argc;
4497		PyObject *argv[4];
#	Line 3403 | Line 4517 | static PyObject *_wrap_BossTask_jobMap(P
4517		_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4518		}
4519		if (_v) {
4520	<	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4520	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4521		}
4522		}
4523		}
#	Line 3439 | Line 4553 | static PyObject *_wrap_BossTask_jobMap(P
4553		}
4554		}
4555		if (_v) {
4556	<	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4556	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4557		}
4558		}
4559		}
#	Line 3450 | Line 4564 | static PyObject *_wrap_BossTask_jobMap(P
4564		}
4565
4566
3453	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3454	–	PyObject *resultobj;
3455	–	BossTask *arg1 = (BossTask *) 0 ;
3456	–	BossTask::job_iterator result;
3457	–	PyObject * obj0 = 0 ;
3458	–
3459	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3460	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3461	–	{
3462	–	try {
3463	–	result = ((BossTask const *)arg1)->job_begin();
3464	–
3465	–	}catch (const std::exception& e) {
3466	–	SWIG_exception(SWIG_RuntimeError, e.what());
3467	–	}
3468	–	}
3469	–	{
3470	–	BossTask::job_iterator * resultptr;
3471	–	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3472	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3473	–	}
3474	–	return resultobj;
3475	–	fail:
3476	–	return NULL;
3477	–	}
3478	–
3479	–
3480	–	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3481	–	PyObject *resultobj;
3482	–	BossTask *arg1 = (BossTask *) 0 ;
3483	–	BossTask::job_iterator result;
3484	–	PyObject * obj0 = 0 ;
3485	–
3486	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3487	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3488	–	{
3489	–	try {
3490	–	result = ((BossTask const *)arg1)->job_end();
3491	–
3492	–	}catch (const std::exception& e) {
3493	–	SWIG_exception(SWIG_RuntimeError, e.what());
3494	–	}
3495	–	}
3496	–	{
3497	–	BossTask::job_iterator * resultptr;
3498	–	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3499	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3500	–	}
3501	–	return resultobj;
3502	–	fail:
3503	–	return NULL;
3504	–	}
3505	–
3506	–
3507	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3508	–	PyObject *resultobj;
3509	–	BossTask *arg1 = (BossTask *) 0 ;
3510	–	BossJob *arg2 = (BossJob *) 0 ;
3511	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3512	–	PyObject * obj0 = 0 ;
3513	–	PyObject * obj1 = 0 ;
3514	–
3515	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3516	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3517	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3518	–	{
3519	–	try {
3520	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
3521	–
3522	–	}catch (const std::exception& e) {
3523	–	SWIG_exception(SWIG_RuntimeError, e.what());
3524	–	}
3525	–	}
3526	–	{
3527	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3528	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3529	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3530	–	}
3531	–	return resultobj;
3532	–	fail:
3533	–	return NULL;
3534	–	}
3535	–
3536	–
4567		static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4568		PyObject *resultobj;
4569		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3549 | Line 4579 | static PyObject *_wrap_BossTask_programs
4579		try {
4580		result = ((BossTask const *)arg1)->programsMap((BossJob const *)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 3600 | Line 4634 | static PyObject *_wrap_BossTask_declare_
4634		try {
4635		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4636
4637	+	}catch (const BossSchedFailure & e) {
4638	+	PyErr_SetString ( SchedulerError, e.what() );
4639	+	return NULL;
4640		}catch (const std::exception& e) {
4641	<	SWIG_exception(SWIG_RuntimeError, e.what());
4641	>	PyErr_SetString ( BossError, e.what() );
4642	>	return NULL;
4643		}
4644		}
4645		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3639 | Line 4677 | static PyObject *_wrap_BossTask_declare_
4677		try {
4678		(arg1)->declare(arg2,(std::string const &)*arg3);
4679
4680	+	}catch (const BossSchedFailure & e) {
4681	+	PyErr_SetString ( SchedulerError, e.what() );
4682	+	return NULL;
4683		}catch (const std::exception& e) {
4684	<	SWIG_exception(SWIG_RuntimeError, e.what());
4684	>	PyErr_SetString ( BossError, e.what() );
4685	>	return NULL;
4686		}
4687		}
4688		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3730 | Line 4772 | static PyObject *_wrap_BossTask_declare(
4772		static PyObject *_wrap_BossTask_remove(PyObject *self, PyObject *args) {
4773		PyObject *resultobj;
4774		BossTask *arg1 = (BossTask *) 0 ;
4775	+	bool arg2 = (bool) false ;
4776		PyObject * obj0 = 0 ;
4777	+	PyObject * obj1 = 0 ;
4778
4779	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_remove",&obj0)) goto fail;
4779	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossTask_remove",&obj0,&obj1)) goto fail;
4780		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4781	+	if (obj1) {
4782	+	arg2 = PyInt_AsLong(obj1) ? true : false;
4783	+	if (PyErr_Occurred()) SWIG_fail;
4784	+	}
4785		{
4786		try {
4787	<	(arg1)->remove();
4787	>	(arg1)->remove(arg2);
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 3754 | Line 4806 | static PyObject *_wrap_BossTask_archive(
4806		BossTask *arg1 = (BossTask *) 0 ;
4807		std::string const &arg2_defvalue = "all" ;
4808		std::string *arg2 = (std::string *) &arg2_defvalue ;
4809	+	bool arg3 = (bool) false ;
4810		std::string temp2 ;
4811		PyObject * obj0 = 0 ;
4812		PyObject * obj1 = 0 ;
4813	+	PyObject * obj2 = 0 ;
4814
4815	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossTask_archive",&obj0,&obj1)) goto fail;
4815	>	if(!PyArg_ParseTuple(args,(char *)"O|OO:BossTask_archive",&obj0,&obj1,&obj2)) goto fail;
4816		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4817		if (obj1) {
4818		{
#	Line 3770 | Line 4824 | static PyObject *_wrap_BossTask_archive(
4824		}
4825		}
4826		}
4827	<	{
4828	<	try {
4829	<	(arg1)->archive((std::string const &)*arg2);
3776	<
3777	<	}catch (const std::exception& e) {
3778	<	SWIG_exception(SWIG_RuntimeError, e.what());
3779	<	}
4827	>	if (obj2) {
4828	>	arg3 = PyInt_AsLong(obj2) ? true : false;
4829	>	if (PyErr_Occurred()) SWIG_fail;
4830		}
3781	–	Py_INCREF(Py_None); resultobj = Py_None;
3782	–	return resultobj;
3783	–	fail:
3784	–	return NULL;
3785	–	}
3786	–
3787	–
3788	–	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3789	–	PyObject *resultobj;
3790	–	BossTask *arg1 = (BossTask *) 0 ;
3791	–	std::map<std::string,std::string > result;
3792	–	PyObject * obj0 = 0 ;
3793	–
3794	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3795	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4831		{
4832		try {
4833	<	result = ((BossTask const *)arg1)->taskMap();
4833	>	(arg1)->archive((std::string const &)*arg2,arg3);
4834
4835	+	}catch (const BossSchedFailure & e) {
4836	+	PyErr_SetString ( SchedulerError, e.what() );
4837	+	return NULL;
4838		}catch (const std::exception& e) {
4839	<	SWIG_exception(SWIG_RuntimeError, e.what());
4840	<	}
3803	<	}
3804	<	{
3805	<	resultobj = PyDict_New();
3806	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3807	<	PyDict_SetItem(resultobj,
3808	<	SwigString_FromString(i->first),
3809	<	SwigString_FromString(i->second));
4839	>	PyErr_SetString ( BossError, e.what() );
4840	>	return NULL;
4841		}
4842		}
4843	+	Py_INCREF(Py_None); resultobj = Py_None;
4844		return resultobj;
4845		fail:
4846		return NULL;
#	Line 3828 | Line 4860 | static PyObject *_wrap_BossTask_submit(P
4860		std::string *arg5 = (std::string *) &arg5_defvalue ;
4861		std::string const &arg6_defvalue = "" ;
4862		std::string *arg6 = (std::string *) &arg6_defvalue ;
4863	<	bool arg7 = (bool) false ;
4863	>	unsigned int arg7 = (unsigned int) 0 ;
4864	>	bool arg8 = (bool) false ;
4865		int result;
4866		std::string temp2 ;
4867		std::string temp3 ;
#	Line 3842 | Line 4875 | static PyObject *_wrap_BossTask_submit(P
4875		PyObject * obj4 = 0 ;
4876		PyObject * obj5 = 0 ;
4877		PyObject * obj6 = 0 ;
4878	+	PyObject * obj7 = 0 ;
4879
4880	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4880	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4881		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4882		if (obj1) {
4883		{
#	Line 3896 | Line 4930 | static PyObject *_wrap_BossTask_submit(P
4930		}
4931		}
4932		if (obj6) {
4933	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4933	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4934	>	if (PyErr_Occurred()) SWIG_fail;
4935	>	}
4936	>	if (obj7) {
4937	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4938		if (PyErr_Occurred()) SWIG_fail;
4939		}
4940		{
4941		try {
4942	<	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);
4942	>	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);
4943
4944	+	}catch (const BossSchedFailure & e) {
4945	+	PyErr_SetString ( SchedulerError, e.what() );
4946	+	return NULL;
4947		}catch (const std::exception& e) {
4948	<	SWIG_exception(SWIG_RuntimeError, e.what());
4948	>	PyErr_SetString ( BossError, e.what() );
4949	>	return NULL;
4950		}
4951		}
4952		resultobj = PyInt_FromLong((long)result);
#	Line 3943 | Line 4985 | static PyObject *_wrap_BossTask_reSubmit
4985		try {
4986		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4987
4988	+	}catch (const BossSchedFailure & e) {
4989	+	PyErr_SetString ( SchedulerError, e.what() );
4990	+	return NULL;
4991		}catch (const std::exception& e) {
4992	<	SWIG_exception(SWIG_RuntimeError, e.what());
4992	>	PyErr_SetString ( BossError, e.what() );
4993	>	return NULL;
4994		}
4995		}
4996		resultobj = PyInt_FromLong((long)result);
#	Line 3958 | Line 5004 | static PyObject *_wrap_BossTask_kill(PyO
5004		PyObject *resultobj;
5005		BossTask *arg1 = (BossTask *) 0 ;
5006		std::string *arg2 = 0 ;
5007	<	bool arg3 = (bool) false ;
5007	>	unsigned int arg3 = (unsigned int) 0 ;
5008	>	bool arg4 = (bool) false ;
5009		int result;
5010		std::string temp2 ;
5011		PyObject * obj0 = 0 ;
5012		PyObject * obj1 = 0 ;
5013		PyObject * obj2 = 0 ;
5014	+	PyObject * obj3 = 0 ;
5015
5016	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
5016	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
5017		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5018		{
5019		if (PyString_Check(obj1)) {
#	Line 3976 | Line 5024 | static PyObject *_wrap_BossTask_kill(PyO
5024		}
5025		}
5026		if (obj2) {
5027	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5027	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
5028	>	if (PyErr_Occurred()) SWIG_fail;
5029	>	}
5030	>	if (obj3) {
5031	>	arg4 = PyInt_AsLong(obj3) ? true : false;
5032		if (PyErr_Occurred()) SWIG_fail;
5033		}
5034		{
5035		try {
5036	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
5036	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
5037
5038	+	}catch (const BossSchedFailure & e) {
5039	+	PyErr_SetString ( SchedulerError, e.what() );
5040	+	return NULL;
5041		}catch (const std::exception& e) {
5042	<	SWIG_exception(SWIG_RuntimeError, e.what());
5042	>	PyErr_SetString ( BossError, e.what() );
5043	>	return NULL;
5044		}
5045		}
5046		resultobj = PyInt_FromLong((long)result);
#	Line 3994 | Line 5050 | static PyObject *_wrap_BossTask_kill(PyO
5050		}
5051
5052
5053	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
5053	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
5054		PyObject *resultobj;
5055		BossTask *arg1 = (BossTask *) 0 ;
5056		std::string const &arg2_defvalue = "all" ;
5057		std::string *arg2 = (std::string *) &arg2_defvalue ;
5058		std::string const &arg3_defvalue = "" ;
5059		std::string *arg3 = (std::string *) &arg3_defvalue ;
5060	<	bool arg4 = (bool) false ;
5060	>	unsigned int arg4 = (unsigned int) 0 ;
5061		bool arg5 = (bool) false ;
5062	+	bool arg6 = (bool) false ;
5063		int result;
5064		std::string temp2 ;
5065		std::string temp3 ;
#	Line 4011 | Line 5068 | static PyObject *_wrap_BossTask_getOutpu
5068		PyObject * obj2 = 0 ;
5069		PyObject * obj3 = 0 ;
5070		PyObject * obj4 = 0 ;
5071	+	PyObject * obj5 = 0 ;
5072
5073	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5073	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5074		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5075		if (obj1) {
5076		{
#	Line 4035 | Line 5093 | static PyObject *_wrap_BossTask_getOutpu
5093		}
5094		}
5095		if (obj3) {
5096	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5096	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
5097		if (PyErr_Occurred()) SWIG_fail;
5098		}
5099		if (obj4) {
5100		arg5 = PyInt_AsLong(obj4) ? true : false;
5101		if (PyErr_Occurred()) SWIG_fail;
5102		}
5103	+	if (obj5) {
5104	+	arg6 = PyInt_AsLong(obj5) ? true : false;
5105	+	if (PyErr_Occurred()) SWIG_fail;
5106	+	}
5107		{
5108		try {
5109	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
5109	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
5110
5111	+	}catch (const BossSchedFailure & e) {
5112	+	PyErr_SetString ( SchedulerError, e.what() );
5113	+	return NULL;
5114		}catch (const std::exception& e) {
5115	<	SWIG_exception(SWIG_RuntimeError, e.what());
5115	>	PyErr_SetString ( BossError, e.what() );
5116	>	return NULL;
5117		}
5118		}
5119		resultobj = PyInt_FromLong((long)result);
#	Line 4057 | Line 5123 | static PyObject *_wrap_BossTask_getOutpu
5123		}
5124
5125
5126	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
5126	>	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
5127		PyObject *resultobj;
5128		BossTask *arg1 = (BossTask *) 0 ;
5129	<	std::string const &arg2_defvalue = "" ;
4064	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
4065	<	bool arg3 = (bool) false ;
4066	<	bool arg4 = (bool) false ;
5129	>	std::string *arg2 = 0 ;
5130		int result;
5131		std::string temp2 ;
5132		PyObject * obj0 = 0 ;
5133		PyObject * obj1 = 0 ;
5134	+
5135	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5136	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5137	+	{
5138	+	if (PyString_Check(obj1)) {
5139	+	temp2 = std::string(PyString_AsString(obj1));
5140	+	arg2 = &temp2;
5141	+	}else {
5142	+	SWIG_exception(SWIG_TypeError, "string expected");
5143	+	}
5144	+	}
5145	+	{
5146	+	try {
5147	+	result = (int)(arg1)->loadByName((std::string const &)*arg2);
5148	+
5149	+	}catch (const BossSchedFailure & e) {
5150	+	PyErr_SetString ( SchedulerError, e.what() );
5151	+	return NULL;
5152	+	}catch (const std::exception& e) {
5153	+	PyErr_SetString ( BossError, e.what() );
5154	+	return NULL;
5155	+	}
5156	+	}
5157	+	resultobj = PyInt_FromLong((long)result);
5158	+	return resultobj;
5159	+	fail:
5160	+	return NULL;
5161	+	}
5162	+
5163	+
5164	+	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
5165	+	PyObject *resultobj;
5166	+	BossTask *arg1 = (BossTask *) 0 ;
5167	+	int arg2 = (int) SCHEDULED ;
5168	+	std::string const &arg3_defvalue = "all" ;
5169	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
5170	+	std::string const &arg4_defvalue = "" ;
5171	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
5172	+	std::string arg5 = (std::string) "" ;
5173	+	std::string arg6 = (std::string) "" ;
5174	+	std::string arg7 = (std::string) "" ;
5175	+	std::string arg8 = (std::string) "" ;
5176	+	int result;
5177	+	std::string temp3 ;
5178	+	std::string temp4 ;
5179	+	PyObject * obj0 = 0 ;
5180		PyObject * obj2 = 0 ;
5181		PyObject * obj3 = 0 ;
5182	+	PyObject * obj4 = 0 ;
5183	+	PyObject * obj5 = 0 ;
5184	+	PyObject * obj6 = 0 ;
5185	+	PyObject * obj7 = 0 ;
5186
5187	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
5187	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5188		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5189	<	if (obj1) {
5189	>	if (obj2) {
5190		{
5191	<	if (PyString_Check(obj1)) {
5192	<	temp2 = std::string(PyString_AsString(obj1));
5193	<	arg2 = &temp2;
5191	>	if (PyString_Check(obj2)) {
5192	>	temp3 = std::string(PyString_AsString(obj2));
5193	>	arg3 = &temp3;
5194		}else {
5195		SWIG_exception(SWIG_TypeError, "string expected");
5196		}
5197		}
5198		}
4086	–	if (obj2) {
4087	–	arg3 = PyInt_AsLong(obj2) ? true : false;
4088	–	if (PyErr_Occurred()) SWIG_fail;
4089	–	}
5199		if (obj3) {
5200	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5201	<	if (PyErr_Occurred()) SWIG_fail;
5200	>	{
5201	>	if (PyString_Check(obj3)) {
5202	>	temp4 = std::string(PyString_AsString(obj3));
5203	>	arg4 = &temp4;
5204	>	}else {
5205	>	SWIG_exception(SWIG_TypeError, "string expected");
5206	>	}
5207	>	}
5208	>	}
5209	>	if (obj4) {
5210	>	{
5211	>	if (PyString_Check(obj4))
5212	>	arg5 = std::string(PyString_AsString(obj4));
5213	>	else
5214	>	SWIG_exception(SWIG_TypeError, "string expected");
5215	>	}
5216	>	}
5217	>	if (obj5) {
5218	>	{
5219	>	if (PyString_Check(obj5))
5220	>	arg6 = std::string(PyString_AsString(obj5));
5221	>	else
5222	>	SWIG_exception(SWIG_TypeError, "string expected");
5223	>	}
5224	>	}
5225	>	if (obj6) {
5226	>	{
5227	>	if (PyString_Check(obj6))
5228	>	arg7 = std::string(PyString_AsString(obj6));
5229	>	else
5230	>	SWIG_exception(SWIG_TypeError, "string expected");
5231	>	}
5232	>	}
5233	>	if (obj7) {
5234	>	{
5235	>	if (PyString_Check(obj7))
5236	>	arg8 = std::string(PyString_AsString(obj7));
5237	>	else
5238	>	SWIG_exception(SWIG_TypeError, "string expected");
5239	>	}
5240		}
5241		{
5242		try {
5243	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
5243	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
5244
5245	+	}catch (const BossSchedFailure & e) {
5246	+	PyErr_SetString ( SchedulerError, e.what() );
5247	+	return NULL;
5248		}catch (const std::exception& e) {
5249	<	SWIG_exception(SWIG_RuntimeError, e.what());
5249	>	PyErr_SetString ( BossError, e.what() );
5250	>	return NULL;
5251		}
5252		}
5253		resultobj = PyInt_FromLong((long)result);
#	Line 4106 | Line 5257 | static PyObject *_wrap_BossTask_getOutpu
5257		}
5258
5259
5260	<	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
5261	<	int argc;
5262	<	PyObject *argv[6];
5263	<	int ii;
5260	>	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5261	>	PyObject *resultobj;
5262	>	BossTask *arg1 = (BossTask *) 0 ;
5263	>	int arg2 = (int) SCHEDULED ;
5264	>	std::string const &arg3_defvalue = "all" ;
5265	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
5266	>	std::string const &arg4_defvalue = "" ;
5267	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
5268	>	std::string arg5 = (std::string) "" ;
5269	>	std::string arg6 = (std::string) "" ;
5270	>	std::string arg7 = (std::string) "" ;
5271	>	std::string arg8 = (std::string) "" ;
5272	>	unsigned int arg9 = (unsigned int) 0 ;
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	>	PyObject * obj8 = 0 ;
5284
5285	<	argc = PyObject_Length(args);
5286	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
5287	<	argv[ii] = PyTuple_GetItem(args,ii);
4117	<	}
4118	<	if ((argc >= 1) && (argc <= 5)) {
4119	<	int _v;
5285	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5286	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5287	>	if (obj2) {
5288		{
5289	<	void *ptr;
5290	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5291	<	_v = 0;
4124	<	PyErr_Clear();
5289	>	if (PyString_Check(obj2)) {
5290	>	temp3 = std::string(PyString_AsString(obj2));
5291	>	arg3 = &temp3;
5292		}else {
5293	<	_v = 1;
4127	<	}
4128	<	}
4129	<	if (_v) {
4130	<	if (argc <= 1) {
4131	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4132	<	}
4133	<	{
4134	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4135	<	}
4136	<	if (_v) {
4137	<	if (argc <= 2) {
4138	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4139	<	}
4140	<	{
4141	<	_v = PyString_Check(argv[2]) ? 1 : 0;
4142	<	}
4143	<	if (_v) {
4144	<	if (argc <= 3) {
4145	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4146	<	}
4147	<	{
4148	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4149	<	}
4150	<	if (_v) {
4151	<	if (argc <= 4) {
4152	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4153	<	}
4154	<	{
4155	<	_v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
4156	<	}
4157	<	if (_v) {
4158	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4159	<	}
4160	<	}
4161	<	}
5293	>	SWIG_exception(SWIG_TypeError, "string expected");
5294		}
5295		}
5296		}
5297	<	if ((argc >= 1) && (argc <= 4)) {
4166	<	int _v;
5297	>	if (obj3) {
5298		{
5299	<	void *ptr;
5300	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5301	<	_v = 0;
4171	<	PyErr_Clear();
5299	>	if (PyString_Check(obj3)) {
5300	>	temp4 = std::string(PyString_AsString(obj3));
5301	>	arg4 = &temp4;
5302		}else {
5303	<	_v = 1;
5303	>	SWIG_exception(SWIG_TypeError, "string expected");
5304		}
5305		}
5306	<	if (_v) {
5307	<	if (argc <= 1) {
5308	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
5309	<	}
5310	<	{
5311	<	_v = PyString_Check(argv[1]) ? 1 : 0;
5312	<	}
4183	<	if (_v) {
4184	<	if (argc <= 2) {
4185	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4186	<	}
4187	<	{
4188	<	_v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
4189	<	}
4190	<	if (_v) {
4191	<	if (argc <= 3) {
4192	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4193	<	}
4194	<	{
4195	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4196	<	}
4197	<	if (_v) {
4198	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4199	<	}
4200	<	}
4201	<	}
5306	>	}
5307	>	if (obj4) {
5308	>	{
5309	>	if (PyString_Check(obj4))
5310	>	arg5 = std::string(PyString_AsString(obj4));
5311	>	else
5312	>	SWIG_exception(SWIG_TypeError, "string expected");
5313		}
5314		}
5315	<
5316	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
5315	>	if (obj5) {
5316	>	{
5317	>	if (PyString_Check(obj5))
5318	>	arg6 = std::string(PyString_AsString(obj5));
5319	>	else
5320	>	SWIG_exception(SWIG_TypeError, "string expected");
5321	>	}
5322	>	}
5323	>	if (obj6) {
5324	>	{
5325	>	if (PyString_Check(obj6))
5326	>	arg7 = std::string(PyString_AsString(obj6));
5327	>	else
5328	>	SWIG_exception(SWIG_TypeError, "string expected");
5329	>	}
5330	>	}
5331	>	if (obj7) {
5332	>	{
5333	>	if (PyString_Check(obj7))
5334	>	arg8 = std::string(PyString_AsString(obj7));
5335	>	else
5336	>	SWIG_exception(SWIG_TypeError, "string expected");
5337	>	}
5338	>	}
5339	>	if (obj8) {
5340	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5341	>	if (PyErr_Occurred()) SWIG_fail;
5342	>	}
5343	>	{
5344	>	try {
5345	>	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5346	>
5347	>	}catch (const BossSchedFailure & e) {
5348	>	PyErr_SetString ( SchedulerError, e.what() );
5349	>	return NULL;
5350	>	}catch (const std::exception& e) {
5351	>	PyErr_SetString ( BossError, e.what() );
5352	>	return NULL;
5353	>	}
5354	>	}
5355	>	resultobj = PyInt_FromLong((long)result);
5356	>	return resultobj;
5357	>	fail:
5358		return NULL;
5359		}
5360
#	Line 4219 | Line 5371 | static PyObject *_wrap_BossTask_query(Py
5371		std::string arg6 = (std::string) "" ;
5372		std::string arg7 = (std::string) "" ;
5373		std::string arg8 = (std::string) "" ;
5374	<	bool arg9 = (bool) false ;
5374	>	unsigned int arg9 = (unsigned int) 0 ;
5375	>	bool arg10 = (bool) false ;
5376		int result;
5377		std::string temp3 ;
5378		std::string temp4 ;
#	Line 4231 | Line 5384 | static PyObject *_wrap_BossTask_query(Py
5384		PyObject * obj6 = 0 ;
5385		PyObject * obj7 = 0 ;
5386		PyObject * obj8 = 0 ;
5387	+	PyObject * obj9 = 0 ;
5388
5389	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5389	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5390		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5391		if (obj2) {
5392		{
#	Line 4287 | Line 5441 | static PyObject *_wrap_BossTask_query(Py
5441		}
5442		}
5443		if (obj8) {
5444	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5444	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5445	>	if (PyErr_Occurred()) SWIG_fail;
5446	>	}
5447	>	if (obj9) {
5448	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5449		if (PyErr_Occurred()) SWIG_fail;
5450		}
5451		{
5452		try {
5453	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5453	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5454
5455	+	}catch (const BossSchedFailure & e) {
5456	+	PyErr_SetString ( SchedulerError, e.what() );
5457	+	return NULL;
5458		}catch (const std::exception& e) {
5459	<	SWIG_exception(SWIG_RuntimeError, e.what());
5459	>	PyErr_SetString ( BossError, e.what() );
5460	>	return NULL;
5461		}
5462		}
5463		resultobj = PyInt_FromLong((long)result);
#	Line 4353 | Line 5515 | static PyObject *_wrap_BossTask_query_ou
5515		try {
5516		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5517
5518	+	}catch (const BossSchedFailure & e) {
5519	+	PyErr_SetString ( SchedulerError, e.what() );
5520	+	return NULL;
5521		}catch (const std::exception& e) {
5522	<	SWIG_exception(SWIG_RuntimeError, e.what());
5522	>	PyErr_SetString ( BossError, e.what() );
5523	>	return NULL;
5524		}
5525		}
5526		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4375 | Line 5541 | static PyObject *_wrap_BossTask_clear(Py
5541		try {
5542		(arg1)->clear();
5543
5544	+	}catch (const BossSchedFailure & e) {
5545	+	PyErr_SetString ( SchedulerError, e.what() );
5546	+	return NULL;
5547		}catch (const std::exception& e) {
5548	<	SWIG_exception(SWIG_RuntimeError, e.what());
5548	>	PyErr_SetString ( BossError, e.what() );
5549	>	return NULL;
5550		}
5551		}
5552		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4386 | Line 5556 | static PyObject *_wrap_BossTask_clear(Py
5556		}
5557
5558
5559	<	static PyObject *_wrap_BossTask_prompt(PyObject *self, PyObject *args) {
5559	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5560	>	PyObject *resultobj;
5561	>	BossTask *arg1 = (BossTask *) 0 ;
5562	>	PyObject *arg2 = (PyObject *) 0 ;
5563	>	BossAttributeContainer *arg3 = 0 ;
5564	>	PyObject * obj0 = 0 ;
5565	>	PyObject * obj1 = 0 ;
5566	>	PyObject * obj2 = 0 ;
5567	>
5568	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5569	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5570	>	arg2 = obj1;
5571	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5572	>	if (arg3 == NULL) {
5573	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5574	>	}
5575	>	{
5576	>	try {
5577	>	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5578	>
5579	>	}catch (const BossSchedFailure & e) {
5580	>	PyErr_SetString ( SchedulerError, e.what() );
5581	>	return NULL;
5582	>	}catch (const std::exception& e) {
5583	>	PyErr_SetString ( BossError, e.what() );
5584	>	return NULL;
5585	>	}
5586	>	}
5587	>	Py_INCREF(Py_None); resultobj = Py_None;
5588	>	return resultobj;
5589	>	fail:
5590	>	return NULL;
5591	>	}
5592	>
5593	>
5594	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5595	>	PyObject *resultobj;
5596	>	BossTask *arg1 = (BossTask *) 0 ;
5597	>	BossJob *arg2 = (BossJob *) 0 ;
5598	>	PyObject *arg3 = (PyObject *) 0 ;
5599	>	PyObject * obj0 = 0 ;
5600	>	PyObject * obj1 = 0 ;
5601	>	PyObject * obj2 = 0 ;
5602	>
5603	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5604	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5605	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5606	>	arg3 = obj2;
5607	>	{
5608	>	try {
5609	>	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5610	>
5611	>	}catch (const BossSchedFailure & e) {
5612	>	PyErr_SetString ( SchedulerError, e.what() );
5613	>	return NULL;
5614	>	}catch (const std::exception& e) {
5615	>	PyErr_SetString ( BossError, e.what() );
5616	>	return NULL;
5617	>	}
5618	>	}
5619	>	Py_INCREF(Py_None); resultobj = Py_None;
5620	>	return resultobj;
5621	>	fail:
5622	>	return NULL;
5623	>	}
5624	>
5625	>
5626	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5627	>	PyObject *resultobj;
5628	>	BossTask *arg1 = (BossTask *) 0 ;
5629	>	PyObject *result;
5630	>	PyObject * obj0 = 0 ;
5631	>
5632	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5633	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5634	>	{
5635	>	try {
5636	>	result = (PyObject *)BossTask_jobsDict(arg1);
5637	>
5638	>	}catch (const BossSchedFailure & e) {
5639	>	PyErr_SetString ( SchedulerError, e.what() );
5640	>	return NULL;
5641	>	}catch (const std::exception& e) {
5642	>	PyErr_SetString ( BossError, e.what() );
5643	>	return NULL;
5644	>	}
5645	>	}
5646	>	resultobj = result;
5647	>	return resultobj;
5648	>	fail:
5649	>	return NULL;
5650	>	}
5651	>
5652	>
5653	>	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5654		PyObject *resultobj;
5655		BossTask *arg1 = (BossTask *) 0 ;
5656		std::string *arg2 = 0 ;
5657	<	bool result;
5657	>	PyObject *result;
5658		std::string temp2 ;
5659		PyObject * obj0 = 0 ;
5660		PyObject * obj1 = 0 ;
5661
5662	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_prompt",&obj0,&obj1)) goto fail;
5662	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5663		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5664		{
5665		if (PyString_Check(obj1)) {
#	Line 4407 | Line 5671 | static PyObject *_wrap_BossTask_prompt(P
5671		}
5672		{
5673		try {
5674	<	result = (bool)(arg1)->prompt((std::string const &)*arg2);
5674	>	result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5675
5676	+	}catch (const BossSchedFailure & e) {
5677	+	PyErr_SetString ( SchedulerError, e.what() );
5678	+	return NULL;
5679		}catch (const std::exception& e) {
5680	<	SWIG_exception(SWIG_RuntimeError, e.what());
5680	>	PyErr_SetString ( BossError, e.what() );
5681	>	return NULL;
5682		}
5683		}
5684	<	resultobj = PyInt_FromLong((long)result);
5684	>	resultobj = result;
5685	>	return resultobj;
5686	>	fail:
5687	>	return NULL;
5688	>	}
5689	>
5690	>
5691	>	static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
5692	>	PyObject *resultobj;
5693	>	BossTask *arg1 = (BossTask *) 0 ;
5694	>	std::string *arg2 = 0 ;
5695	>	PyObject *result;
5696	>	std::string temp2 ;
5697	>	PyObject * obj0 = 0 ;
5698	>	PyObject * obj1 = 0 ;
5699	>
5700	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5701	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5702	>	{
5703	>	if (PyString_Check(obj1)) {
5704	>	temp2 = std::string(PyString_AsString(obj1));
5705	>	arg2 = &temp2;
5706	>	}else {
5707	>	SWIG_exception(SWIG_TypeError, "string expected");
5708	>	}
5709	>	}
5710	>	{
5711	>	try {
5712	>	result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
5713	>
5714	>	}catch (const BossSchedFailure & e) {
5715	>	PyErr_SetString ( SchedulerError, e.what() );
5716	>	return NULL;
5717	>	}catch (const std::exception& e) {
5718	>	PyErr_SetString ( BossError, e.what() );
5719	>	return NULL;
5720	>	}
5721	>	}
5722	>	resultobj = result;
5723	>	return resultobj;
5724	>	fail:
5725	>	return NULL;
5726	>	}
5727	>
5728	>
5729	>	static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5730	>	PyObject *resultobj;
5731	>	BossTask *arg1 = (BossTask *) 0 ;
5732	>	PyObject *result;
5733	>	PyObject * obj0 = 0 ;
5734	>
5735	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5736	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5737	>	{
5738	>	try {
5739	>	result = (PyObject *)BossTask_jobStates(arg1);
5740	>
5741	>	}catch (const BossSchedFailure & e) {
5742	>	PyErr_SetString ( SchedulerError, e.what() );
5743	>	return NULL;
5744	>	}catch (const std::exception& e) {
5745	>	PyErr_SetString ( BossError, e.what() );
5746	>	return NULL;
5747	>	}
5748	>	}
5749	>	resultobj = result;
5750	>	return resultobj;
5751	>	fail:
5752	>	return NULL;
5753	>	}
5754	>
5755	>
5756	>	static PyObject *_wrap_BossTask_joblist(PyObject *self, PyObject *args) {
5757	>	PyObject *resultobj;
5758	>	BossTask *arg1 = (BossTask *) 0 ;
5759	>	PyObject *result;
5760	>	PyObject * obj0 = 0 ;
5761	>
5762	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_joblist",&obj0)) goto fail;
5763	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5764	>	{
5765	>	try {
5766	>	result = (PyObject *)BossTask_joblist(arg1);
5767	>
5768	>	}catch (const BossSchedFailure & e) {
5769	>	PyErr_SetString ( SchedulerError, e.what() );
5770	>	return NULL;
5771	>	}catch (const std::exception& e) {
5772	>	PyErr_SetString ( BossError, e.what() );
5773	>	return NULL;
5774	>	}
5775	>	}
5776	>	resultobj = result;
5777	>	return resultobj;
5778	>	fail:
5779	>	return NULL;
5780	>	}
5781	>
5782	>
5783	>	static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5784	>	PyObject *resultobj;
5785	>	BossTask *arg1 = (BossTask *) 0 ;
5786	>	PyObject *result;
5787	>	PyObject * obj0 = 0 ;
5788	>
5789	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5790	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5791	>	{
5792	>	try {
5793	>	result = (PyObject *)BossTask_jobStatistic(arg1);
5794	>
5795	>	}catch (const BossSchedFailure & e) {
5796	>	PyErr_SetString ( SchedulerError, e.what() );
5797	>	return NULL;
5798	>	}catch (const std::exception& e) {
5799	>	PyErr_SetString ( BossError, e.what() );
5800	>	return NULL;
5801	>	}
5802	>	}
5803	>	resultobj = result;
5804	>	return resultobj;
5805	>	fail:
5806	>	return NULL;
5807	>	}
5808	>
5809	>
5810	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5811	>	PyObject *resultobj;
5812	>	BossTask *arg1 = (BossTask *) 0 ;
5813	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5814	>	PyObject *result;
5815	>	PyObject * obj0 = 0 ;
5816	>	PyObject * obj1 = 0 ;
5817	>
5818	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5819	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5820	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5821	>	if (arg2 == NULL) {
5822	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5823	>	}
5824	>	{
5825	>	try {
5826	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5827	>
5828	>	}catch (const BossSchedFailure & e) {
5829	>	PyErr_SetString ( SchedulerError, e.what() );
5830	>	return NULL;
5831	>	}catch (const std::exception& e) {
5832	>	PyErr_SetString ( BossError, e.what() );
5833	>	return NULL;
5834	>	}
5835	>	}
5836	>	resultobj = result;
5837	>	return resultobj;
5838	>	fail:
5839	>	return NULL;
5840	>	}
5841	>
5842	>
5843	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5844	>	PyObject *resultobj;
5845	>	BossTask *arg1 = (BossTask *) 0 ;
5846	>	std::string *arg2 = 0 ;
5847	>	PyObject *result;
5848	>	std::string temp2 ;
5849	>	PyObject * obj0 = 0 ;
5850	>	PyObject * obj1 = 0 ;
5851	>
5852	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5853	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5854	>	{
5855	>	if (PyString_Check(obj1)) {
5856	>	temp2 = std::string(PyString_AsString(obj1));
5857	>	arg2 = &temp2;
5858	>	}else {
5859	>	SWIG_exception(SWIG_TypeError, "string expected");
5860	>	}
5861	>	}
5862	>	{
5863	>	try {
5864	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5865	>
5866	>	}catch (const BossSchedFailure & e) {
5867	>	PyErr_SetString ( SchedulerError, e.what() );
5868	>	return NULL;
5869	>	}catch (const std::exception& e) {
5870	>	PyErr_SetString ( BossError, e.what() );
5871	>	return NULL;
5872	>	}
5873	>	}
5874	>	resultobj = result;
5875	>	return resultobj;
5876	>	fail:
5877	>	return NULL;
5878	>	}
5879	>
5880	>
5881	>	static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5882	>	PyObject *resultobj;
5883	>	BossTask *arg1 = (BossTask *) 0 ;
5884	>	std::string *arg2 = 0 ;
5885	>	std::string *arg3 = 0 ;
5886	>	PyObject *result;
5887	>	std::string temp2 ;
5888	>	std::string temp3 ;
5889	>	PyObject * obj0 = 0 ;
5890	>	PyObject * obj1 = 0 ;
5891	>	PyObject * obj2 = 0 ;
5892	>
5893	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5894	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5895	>	{
5896	>	if (PyString_Check(obj1)) {
5897	>	temp2 = std::string(PyString_AsString(obj1));
5898	>	arg2 = &temp2;
5899	>	}else {
5900	>	SWIG_exception(SWIG_TypeError, "string expected");
5901	>	}
5902	>	}
5903	>	{
5904	>	if (PyString_Check(obj2)) {
5905	>	temp3 = std::string(PyString_AsString(obj2));
5906	>	arg3 = &temp3;
5907	>	}else {
5908	>	SWIG_exception(SWIG_TypeError, "string expected");
5909	>	}
5910	>	}
5911	>	{
5912	>	try {
5913	>	result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5914	>
5915	>	}catch (const BossSchedFailure & e) {
5916	>	PyErr_SetString ( SchedulerError, e.what() );
5917	>	return NULL;
5918	>	}catch (const std::exception& e) {
5919	>	PyErr_SetString ( BossError, e.what() );
5920	>	return NULL;
5921	>	}
5922	>	}
5923	>	resultobj = result;
5924	>	return resultobj;
5925	>	fail:
5926	>	return NULL;
5927	>	}
5928	>
5929	>
5930	>	static PyObject *_wrap_BossTask_programExec(PyObject *self, PyObject *args) {
5931	>	PyObject *resultobj;
5932	>	BossTask *arg1 = (BossTask *) 0 ;
5933	>	std::string *arg2 = 0 ;
5934	>	std::string *arg3 = 0 ;
5935	>	PyObject *result;
5936	>	std::string temp2 ;
5937	>	std::string temp3 ;
5938	>	PyObject * obj0 = 0 ;
5939	>	PyObject * obj1 = 0 ;
5940	>	PyObject * obj2 = 0 ;
5941	>
5942	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
5943	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5944	>	{
5945	>	if (PyString_Check(obj1)) {
5946	>	temp2 = std::string(PyString_AsString(obj1));
5947	>	arg2 = &temp2;
5948	>	}else {
5949	>	SWIG_exception(SWIG_TypeError, "string expected");
5950	>	}
5951	>	}
5952	>	{
5953	>	if (PyString_Check(obj2)) {
5954	>	temp3 = std::string(PyString_AsString(obj2));
5955	>	arg3 = &temp3;
5956	>	}else {
5957	>	SWIG_exception(SWIG_TypeError, "string expected");
5958	>	}
5959	>	}
5960	>	{
5961	>	try {
5962	>	result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5963	>
5964	>	}catch (const BossSchedFailure & e) {
5965	>	PyErr_SetString ( SchedulerError, e.what() );
5966	>	return NULL;
5967	>	}catch (const std::exception& e) {
5968	>	PyErr_SetString ( BossError, e.what() );
5969	>	return NULL;
5970	>	}
5971	>	}
5972	>	resultobj = result;
5973	>	return resultobj;
5974	>	fail:
5975	>	return NULL;
5976	>	}
5977	>
5978	>
5979	>	static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
5980	>	PyObject *resultobj;
5981	>	BossTask *arg1 = (BossTask *) 0 ;
5982	>	std::string *arg2 = 0 ;
5983	>	std::string *arg3 = 0 ;
5984	>	PyObject *result;
5985	>	std::string temp2 ;
5986	>	std::string temp3 ;
5987	>	PyObject * obj0 = 0 ;
5988	>	PyObject * obj1 = 0 ;
5989	>	PyObject * obj2 = 0 ;
5990	>
5991	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
5992	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5993	>	{
5994	>	if (PyString_Check(obj1)) {
5995	>	temp2 = std::string(PyString_AsString(obj1));
5996	>	arg2 = &temp2;
5997	>	}else {
5998	>	SWIG_exception(SWIG_TypeError, "string expected");
5999	>	}
6000	>	}
6001	>	{
6002	>	if (PyString_Check(obj2)) {
6003	>	temp3 = std::string(PyString_AsString(obj2));
6004	>	arg3 = &temp3;
6005	>	}else {
6006	>	SWIG_exception(SWIG_TypeError, "string expected");
6007	>	}
6008	>	}
6009	>	{
6010	>	try {
6011	>	result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
6012	>
6013	>	}catch (const BossSchedFailure & e) {
6014	>	PyErr_SetString ( SchedulerError, e.what() );
6015	>	return NULL;
6016	>	}catch (const std::exception& e) {
6017	>	PyErr_SetString ( BossError, e.what() );
6018	>	return NULL;
6019	>	}
6020	>	}
6021	>	resultobj = result;
6022		return resultobj;
6023		fail:
6024		return NULL;
#	Line 4430 | Line 6035 | static PyObject * BossTask_swigregister(
6035		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
6036		PyObject *resultobj;
6037		std::string arg1 = (std::string) "" ;
6038	<	bool arg2 = (bool) false ;
6038	>	std::string arg2 = (std::string) "2" ;
6039	>	std::string arg3 = (std::string) "" ;
6040	>	std::string arg4 = (std::string) "" ;
6041	>	bool arg5 = (bool) false ;
6042		BossAdministratorSession *result;
6043		PyObject * obj0 = 0 ;
6044		PyObject * obj1 = 0 ;
6045	+	PyObject * obj2 = 0 ;
6046	+	PyObject * obj3 = 0 ;
6047	+	PyObject * obj4 = 0 ;
6048
6049	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
6049	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6050		if (obj0) {
6051		{
6052		if (PyString_Check(obj0))
#	Line 4445 | Line 6056 | static PyObject *_wrap_new_BossAdministr
6056		}
6057		}
6058		if (obj1) {
6059	<	arg2 = PyInt_AsLong(obj1) ? true : false;
6059	>	{
6060	>	if (PyString_Check(obj1))
6061	>	arg2 = std::string(PyString_AsString(obj1));
6062	>	else
6063	>	SWIG_exception(SWIG_TypeError, "string expected");
6064	>	}
6065	>	}
6066	>	if (obj2) {
6067	>	{
6068	>	if (PyString_Check(obj2))
6069	>	arg3 = std::string(PyString_AsString(obj2));
6070	>	else
6071	>	SWIG_exception(SWIG_TypeError, "string expected");
6072	>	}
6073	>	}
6074	>	if (obj3) {
6075	>	{
6076	>	if (PyString_Check(obj3))
6077	>	arg4 = std::string(PyString_AsString(obj3));
6078	>	else
6079	>	SWIG_exception(SWIG_TypeError, "string expected");
6080	>	}
6081	>	}
6082	>	if (obj4) {
6083	>	arg5 = PyInt_AsLong(obj4) ? true : false;
6084		if (PyErr_Occurred()) SWIG_fail;
6085		}
6086		{
6087		try {
6088	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
6088	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
6089
6090	+	}catch (const BossSchedFailure & e) {
6091	+	PyErr_SetString ( SchedulerError, e.what() );
6092	+	return NULL;
6093		}catch (const std::exception& e) {
6094	<	SWIG_exception(SWIG_RuntimeError, e.what());
6094	>	PyErr_SetString ( BossError, e.what() );
6095	>	return NULL;
6096		}
6097		}
6098		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4474 | Line 6113 | static PyObject *_wrap_delete_BossAdmini
6113		try {
6114		delete arg1;
6115
6116	+	}catch (const BossSchedFailure & e) {
6117	+	PyErr_SetString ( SchedulerError, e.what() );
6118	+	return NULL;
6119		}catch (const std::exception& e) {
6120	<	SWIG_exception(SWIG_RuntimeError, e.what());
6120	>	PyErr_SetString ( BossError, e.what() );
6121	>	return NULL;
6122		}
6123		}
6124		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4485 | Line 6128 | static PyObject *_wrap_delete_BossAdmini
6128		}
6129
6130
6131	+	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
6132	+	PyObject *resultobj;
6133	+	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6134	+	int result;
6135	+	PyObject * obj0 = 0 ;
6136	+
6137	+	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
6138	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6139	+	{
6140	+	try {
6141	+	result = (int)(arg1)->configureDB();
6142	+
6143	+	}catch (const BossSchedFailure & e) {
6144	+	PyErr_SetString ( SchedulerError, e.what() );
6145	+	return NULL;
6146	+	}catch (const std::exception& e) {
6147	+	PyErr_SetString ( BossError, e.what() );
6148	+	return NULL;
6149	+	}
6150	+	}
6151	+	resultobj = PyInt_FromLong((long)result);
6152	+	return resultobj;
6153	+	fail:
6154	+	return NULL;
6155	+	}
6156	+
6157	+
6158		static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
6159		PyObject *resultobj;
6160		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
#	Line 4508 | Line 6178 | static PyObject *_wrap_BossAdministrator
6178		try {
6179		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
6180
6181	+	}catch (const BossSchedFailure & e) {
6182	+	PyErr_SetString ( SchedulerError, e.what() );
6183	+	return NULL;
6184		}catch (const std::exception& e) {
6185	<	SWIG_exception(SWIG_RuntimeError, e.what());
6185	>	PyErr_SetString ( BossError, e.what() );
6186	>	return NULL;
6187		}
6188		}
6189		resultobj = PyInt_FromLong((long)result);
#	Line 4542 | Line 6216 | static PyObject *_wrap_BossAdministrator
6216		try {
6217		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
6218
6219	+	}catch (const BossSchedFailure & e) {
6220	+	PyErr_SetString ( SchedulerError, e.what() );
6221	+	return NULL;
6222		}catch (const std::exception& e) {
6223	<	SWIG_exception(SWIG_RuntimeError, e.what());
6223	>	PyErr_SetString ( BossError, e.what() );
6224	>	return NULL;
6225		}
6226		}
6227		resultobj = PyInt_FromLong((long)result);
#	Line 4576 | Line 6254 | static PyObject *_wrap_BossAdministrator
6254		try {
6255		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
6256
6257	+	}catch (const BossSchedFailure & e) {
6258	+	PyErr_SetString ( SchedulerError, e.what() );
6259	+	return NULL;
6260		}catch (const std::exception& e) {
6261	<	SWIG_exception(SWIG_RuntimeError, e.what());
6261	>	PyErr_SetString ( BossError, e.what() );
6262	>	return NULL;
6263		}
6264		}
6265		resultobj = PyInt_FromLong((long)result);
#	Line 4610 | Line 6292 | static PyObject *_wrap_BossAdministrator
6292		try {
6293		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
6294
6295	+	}catch (const BossSchedFailure & e) {
6296	+	PyErr_SetString ( SchedulerError, e.what() );
6297	+	return NULL;
6298		}catch (const std::exception& e) {
6299	<	SWIG_exception(SWIG_RuntimeError, e.what());
6299	>	PyErr_SetString ( BossError, e.what() );
6300	>	return NULL;
6301		}
6302		}
6303		resultobj = PyInt_FromLong((long)result);
#	Line 4644 | Line 6330 | static PyObject *_wrap_BossAdministrator
6330		try {
6331		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
6332
6333	+	}catch (const BossSchedFailure & e) {
6334	+	PyErr_SetString ( SchedulerError, e.what() );
6335	+	return NULL;
6336		}catch (const std::exception& e) {
6337	<	SWIG_exception(SWIG_RuntimeError, e.what());
6337	>	PyErr_SetString ( BossError, e.what() );
6338	>	return NULL;
6339		}
6340		}
6341		resultobj = PyInt_FromLong((long)result);
#	Line 4710 | Line 6400 | static PyObject *_wrap_BossAdministrator
6400		try {
6401		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
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 4800 | Line 6494 | static PyObject *_wrap_BossAdministrator
6494		try {
6495		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
6496
6497	+	}catch (const BossSchedFailure & e) {
6498	+	PyErr_SetString ( SchedulerError, e.what() );
6499	+	return NULL;
6500		}catch (const std::exception& e) {
6501	<	SWIG_exception(SWIG_RuntimeError, e.what());
6501	>	PyErr_SetString ( BossError, e.what() );
6502	>	return NULL;
6503		}
6504		}
6505		resultobj = PyInt_FromLong((long)result);
#	Line 4876 | Line 6574 | static PyObject *_wrap_BossAdministrator
6574		try {
6575		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6576
6577	+	}catch (const BossSchedFailure & e) {
6578	+	PyErr_SetString ( SchedulerError, e.what() );
6579	+	return NULL;
6580		}catch (const std::exception& e) {
6581	<	SWIG_exception(SWIG_RuntimeError, e.what());
6581	>	PyErr_SetString ( BossError, e.what() );
6582	>	return NULL;
6583		}
6584		}
6585		resultobj = PyInt_FromLong((long)result);
#	Line 4905 | Line 6607 | static PyObject *_wrap_BossAdministrator
6607		std::string arg13 = (std::string) "" ;
6608		bool arg14 = (bool) false ;
6609		bool arg15 = (bool) false ;
6610	+	bool arg16 = (bool) false ;
6611	+	bool arg17 = (bool) false ;
6612		int result;
6613		std::string temp2 ;
6614		std::string temp11 ;
#	Line 4923 | Line 6627 | static PyObject *_wrap_BossAdministrator
6627		PyObject * obj12 = 0 ;
6628		PyObject * obj13 = 0 ;
6629		PyObject * obj14 = 0 ;
6630	+	PyObject * obj15 = 0 ;
6631	+	PyObject * obj16 = 0 ;
6632
6633	<	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;
6633	>	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;
6634		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6635		{
6636		if (PyString_Check(obj1)) {
#	Line 5032 | Line 6738 | static PyObject *_wrap_BossAdministrator
6738		arg15 = PyInt_AsLong(obj14) ? true : false;
6739		if (PyErr_Occurred()) SWIG_fail;
6740		}
6741	+	if (obj15) {
6742	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6743	+	if (PyErr_Occurred()) SWIG_fail;
6744	+	}
6745	+	if (obj16) {
6746	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6747	+	if (PyErr_Occurred()) SWIG_fail;
6748	+	}
6749		{
6750		try {
6751	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
6751	>	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);
6752
6753	+	}catch (const BossSchedFailure & e) {
6754	+	PyErr_SetString ( SchedulerError, e.what() );
6755	+	return NULL;
6756		}catch (const std::exception& e) {
6757	<	SWIG_exception(SWIG_RuntimeError, e.what());
6757	>	PyErr_SetString ( BossError, e.what() );
6758	>	return NULL;
6759		}
6760		}
6761		resultobj = PyInt_FromLong((long)result);
#	Line 5059 | Line 6777 | static PyObject *_wrap_BossAdministrator
6777		try {
6778		result = (arg1)->help();
6779
6780	+	}catch (const BossSchedFailure & e) {
6781	+	PyErr_SetString ( SchedulerError, e.what() );
6782	+	return NULL;
6783		}catch (const std::exception& e) {
6784	<	SWIG_exception(SWIG_RuntimeError, e.what());
6784	>	PyErr_SetString ( BossError, e.what() );
6785	>	return NULL;
6786		}
6787		}
6788		{
#	Line 5072 | Line 6794 | static PyObject *_wrap_BossAdministrator
6794		}
6795
6796
6797	<	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
6797	>	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6798		PyObject *resultobj;
6799		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6800	<	std::string *arg2 = 0 ;
6800	>	std::string arg2 ;
6801	>	bool arg3 = (bool) false ;
6802		std::string result;
6803		PyObject * obj0 = 0 ;
6804		PyObject * obj1 = 0 ;
6805	+	PyObject * obj2 = 0 ;
6806
6807	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureDB",&obj0,&obj1)) goto fail;
6807	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
6808		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6809	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6810	<	if (arg2 == NULL) {
6811	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6809	>	{
6810	>	if (PyString_Check(obj1))
6811	>	arg2 = std::string(PyString_AsString(obj1));
6812	>	else
6813	>	SWIG_exception(SWIG_TypeError, "string expected");
6814	>	}
6815	>	if (obj2) {
6816	>	arg3 = PyInt_AsLong(obj2) ? true : false;
6817	>	if (PyErr_Occurred()) SWIG_fail;
6818		}
6819		{
6820		try {
6821	<	result = (arg1)->configureDB(*arg2);
6821	>	result = (arg1)->SQL(arg2,arg3);
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		{
#	Line 5103 | Line 6837 | static PyObject *_wrap_BossAdministrator
6837		}
6838
6839
6840	<	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6840	>	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
6841		PyObject *resultobj;
6842		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6843		std::string *arg2 = 0 ;
6844	<	bool arg3 = (bool) false ;
6845	<	std::string result;
6844	>	std::string *arg3 = 0 ;
6845	>	std::string *arg4 = 0 ;
6846	>	std::string const &arg5_defvalue = "0" ;
6847	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
6848	>	int result;
6849	>	std::string temp2 ;
6850	>	std::string temp3 ;
6851	>	std::string temp4 ;
6852	>	std::string temp5 ;
6853		PyObject * obj0 = 0 ;
6854		PyObject * obj1 = 0 ;
6855		PyObject * obj2 = 0 ;
6856	+	PyObject * obj3 = 0 ;
6857	+	PyObject * obj4 = 0 ;
6858
6859	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
6859	>	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6860		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6861	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6862	<	if (arg2 == NULL) {
6863	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6861	>	{
6862	>	if (PyString_Check(obj1)) {
6863	>	temp2 = std::string(PyString_AsString(obj1));
6864	>	arg2 = &temp2;
6865	>	}else {
6866	>	SWIG_exception(SWIG_TypeError, "string expected");
6867	>	}
6868		}
6869	<	if (obj2) {
6870	<	arg3 = PyInt_AsLong(obj2) ? true : false;
6871	<	if (PyErr_Occurred()) SWIG_fail;
6869	>	{
6870	>	if (PyString_Check(obj2)) {
6871	>	temp3 = std::string(PyString_AsString(obj2));
6872	>	arg3 = &temp3;
6873	>	}else {
6874	>	SWIG_exception(SWIG_TypeError, "string expected");
6875	>	}
6876	>	}
6877	>	{
6878	>	if (PyString_Check(obj3)) {
6879	>	temp4 = std::string(PyString_AsString(obj3));
6880	>	arg4 = &temp4;
6881	>	}else {
6882	>	SWIG_exception(SWIG_TypeError, "string expected");
6883	>	}
6884	>	}
6885	>	if (obj4) {
6886	>	{
6887	>	if (PyString_Check(obj4)) {
6888	>	temp5 = std::string(PyString_AsString(obj4));
6889	>	arg5 = &temp5;
6890	>	}else {
6891	>	SWIG_exception(SWIG_TypeError, "string expected");
6892	>	}
6893	>	}
6894		}
6895		{
6896		try {
6897	<	result = (arg1)->SQL(*arg2,arg3);
6897	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6898
6899	+	}catch (const BossSchedFailure & e) {
6900	+	PyErr_SetString ( SchedulerError, e.what() );
6901	+	return NULL;
6902		}catch (const std::exception& e) {
6903	<	SWIG_exception(SWIG_RuntimeError, e.what());
6903	>	PyErr_SetString ( BossError, e.what() );
6904	>	return NULL;
6905		}
6906		}
6907	<	{
5135	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5136	<	}
6907	>	resultobj = PyInt_FromLong((long)result);
6908		return resultobj;
6909		fail:
6910		return NULL;
6911		}
6912
6913
6914	<	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
6914	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
6915		PyObject *resultobj;
6916		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6917	<	std::string *arg2 = 0 ;
6918	<	std::string result;
6917	>	std::string arg2 ;
6918	>	int result;
6919		PyObject * obj0 = 0 ;
6920		PyObject * obj1 = 0 ;
6921
6922	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_purge",&obj0,&obj1)) goto fail;
6922	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6923		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6924	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6925	<	if (arg2 == NULL) {
6926	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6924	>	{
6925	>	if (PyString_Check(obj1))
6926	>	arg2 = std::string(PyString_AsString(obj1));
6927	>	else
6928	>	SWIG_exception(SWIG_TypeError, "string expected");
6929		}
6930		{
6931		try {
6932	<	result = (arg1)->purge(*arg2);
6932	>	result = (int)(arg1)->registerPlugins(arg2);
6933
6934	+	}catch (const BossSchedFailure & e) {
6935	+	PyErr_SetString ( SchedulerError, e.what() );
6936	+	return NULL;
6937		}catch (const std::exception& e) {
6938	<	SWIG_exception(SWIG_RuntimeError, e.what());
6938	>	PyErr_SetString ( BossError, e.what() );
6939	>	return NULL;
6940		}
6941		}
6942	<	{
5166	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5167	<	}
6942	>	resultobj = PyInt_FromLong((long)result);
6943		return resultobj;
6944		fail:
6945		return NULL;
#	Line 5194 | Line 6969 | static PyMethodDef SwigMethods[] = {
6969		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6970		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6971		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6972	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6973	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6974	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6975	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6976	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6977	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6972	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6973	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6974	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6975	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6976	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6977	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6978	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6979	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6980	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6981	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6982	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6983	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6984	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6985	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6986		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6987		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6988	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6989	+	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6990	+	{ (char *)"BossSession_task_begin", _wrap_BossSession_task_begin, METH_VARARGS },
6991	+	{ (char *)"BossSession_task_end", _wrap_BossSession_task_end, METH_VARARGS },
6992	+	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
6993	+	{ (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
6994		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6995		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6996	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6997	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6998	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6999	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
7000		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
7001		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
7002		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5211 | Line 7004 | static PyMethodDef SwigMethods[] = {
7004		{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
7005		{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
7006		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5214	–	{ (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
7007		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
7008		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
7009	<	{ (char *)"BossSession_jobQuery", _wrap_BossSession_jobQuery, METH_VARARGS },
7010	<	{ (char *)"BossSession_queryPrint", _wrap_BossSession_queryPrint, METH_VARARGS },
7011	<	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
7009	>	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
7010	>	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
7011	>	{ (char *)"BossSession_getTasksByTaskInfo", _wrap_BossSession_getTasksByTaskInfo, METH_VARARGS },
7012	>	{ (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
7013	>	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7014	>	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7015	>	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
7016	>	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
7017	>	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
7018	>	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7019	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7020		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5221	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5222	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7021		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
5224	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7022		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7023		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7024	<	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7025	<	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7026	<	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7027	<	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7028	<	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7024	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7025	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7026	>	{ (char *)"BossTask_jobsInMemory", _wrap_BossTask_jobsInMemory, METH_VARARGS },
7027	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7028	>	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7029	>	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
7030		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
7031		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7032		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7033		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7034	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7035	+	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
7036	+	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7037		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5237	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5238	–	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
5239	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7038		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
7039		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7040		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7041		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
5244	–	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
7042		{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
7043		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
7044		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
7045		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7046	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7047	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7048	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7049		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7050		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7051		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7052	<	{ (char *)"BossTask_prompt", _wrap_BossTask_prompt, METH_VARARGS },
7052	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7053	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7054	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7055	>	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7056	>	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7057	>	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7058	>	{ (char *)"BossTask_joblist", _wrap_BossTask_joblist, METH_VARARGS },
7059	>	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7060	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7061	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7062	>	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7063	>	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7064	>	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7065		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
7066		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7067		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
7068	+	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
7069		{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
7070		{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
7071		{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
#	Line 5263 | Line 7076 | static PyMethodDef SwigMethods[] = {
7076		{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
7077		{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
7078		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
5266	–	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
7079		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
7080		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
7081	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
7082		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
7083		{ NULL, NULL }
7084		};
#	Line 5273 | Line 7086 | static PyMethodDef SwigMethods[] = {
7086
7087		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7088
5276	–	static swig_type_info _swigt__p_std__vectorTBossJob_p_t[] = {{"_p_std__vectorTBossJob_p_t", 0, "std::vector<BossJob * > *", 0},{"_p_std__vectorTBossJob_p_t"},{0}};
5277	–	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}};
7089		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}};
7090		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7091	+	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}};
7092	+	static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7093	+	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7094		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}};
5281	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7095		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7096		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7097	<	static swig_type_info _swigt__p_std__string[] = {{"_p_std__string", 0, "std::string *", 0},{"_p_std__string"},{0}};
7098	<	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7097	>	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7098	>	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7099		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7100	<	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
7100	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7101		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
7102	+	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
7103		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
7104		static swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0},{"_p_std__vectorTstd__string_t"},{0}};
7105		static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
7106		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5293	–	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
5294	–	static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
7107		static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
7108	+	static swig_type_info _swigt__p_BossSession__task_iterator[] = {{"_p_BossSession__task_iterator", 0, "BossSession::task_iterator const *", 0},{"_p_BossSession__task_iterator"},{0}};
7109	+	static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
7110	+	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7111
7112		static swig_type_info *swig_types_initial[] = {
5298	–	_swigt__p_std__vectorTBossJob_p_t,
5299	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7113		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
7114		_swigt__p_XMLDoc,
7115	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7116	+	_swigt__p_BossProgramExec,
7117	+	_swigt__p_BossChain,
7118		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
5303	–	_swigt__p_std__ostream,
7119		_swigt__p_BossTask,
7120		_swigt__p_BossTaskException,
7121	<	_swigt__p_std__string,
7122	<	_swigt__p_BossAttributeContainer,
7121	>	_swigt__p_std__ostream,
7122	>	_swigt__p_BossProgram,
7123		_swigt__p_printOption,
7124	<	_swigt__p_BossDatabase,
7124	>	_swigt__p_BossAttributeContainer,
7125		_swigt__p_BossJob,
7126	+	_swigt__p_BossDatabase,
7127		_swigt__p_BossSession,
7128		_swigt__p_std__vectorTstd__string_t,
7129		_swigt__p_std__mapTstd__string_std__string_t,
7130		_swigt__p_BossAdministratorSession,
5315	–	_swigt__p_jobStates,
5316	–	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7131		_swigt__p_BossTask__job_iterator,
7132	+	_swigt__p_BossSession__task_iterator,
7133	+	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7134	+	_swigt__p_jobStates,
7135		0
7136		};
7137
#	Line 5357 | Line 7174 | SWIGEXPORT(void) SWIG_init(void) {
7174		}
7175		SWIG_InstallConstants(d,swig_const_table);
7176
7177	+
7178	+	// define custom exceptions
7179	+	PyObject *e;
7180	+	PyMethodDef tp_methods = {
7181	+	NULL, NULL, 0, NULL
7182	+	};
7183	+	e = Py_InitModule("BossSession", &tp_methods);
7184	+	// generic BOSS exception
7185	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
7186	+	Py_INCREF(BossError);
7187	+	PyModule_AddObject(e, "BossError", BossError);
7188	+	// scheduler interaction BOSS exception
7189	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
7190	+	Py_INCREF(SchedulerError);
7191	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
7192	+
7193		}
7194

Diff Legend

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