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.6 by gcodispo, Fri Oct 27 12:45:31 2006 UTC vs.
Revision 1.36 by gcodispo, Wed Jul 18 08:59:17 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_BossAttributeContainer swig_types[8]
666	<	#define  SWIGTYPE_p_printOption swig_types[9]
667	<	#define  SWIGTYPE_p_BossDatabase swig_types[10]
668	<	#define  SWIGTYPE_p_BossJob swig_types[11]
669	<	#define  SWIGTYPE_p_BossSession swig_types[12]
670	<	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671	<	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672	<	#define  SWIGTYPE_p_BossAdministratorSession swig_types[15]
673	<	#define  SWIGTYPE_p_jobStates swig_types[16]
674	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[17]
665	>	#define  SWIGTYPE_p_std__ostream swig_types[8]
666	>	#define  SWIGTYPE_p_BossProgram swig_types[9]
667	>	#define  SWIGTYPE_p_printOption swig_types[10]
668	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[11]
669	>	#define  SWIGTYPE_p_BossJob swig_types[12]
670	>	#define  SWIGTYPE_p_BossDatabase swig_types[13]
671	>	#define  SWIGTYPE_p_BossSession swig_types[14]
672	>	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[15]
673	>	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[16]
674	>	#define  SWIGTYPE_p_BossAdministratorSession swig_types[17]
675		#define  SWIGTYPE_p_BossTask__job_iterator swig_types[18]
676	<	static swig_type_info *swig_types[20];
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 851 | 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 872 | 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	<	if ( !avoidCheck ) {
966	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
967	<	type, user, after, before);
968	<	}
969	<	PyObject * job_dict = PyList_New(0);
970	<	std::vector <std::string>
971	<	taskList = self->selectTasks( taskRange, before, after, user);
972	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
973	<	it!= taskList.end(); ++it ) {
974	<	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
975	<	}
976	<
977	<	//       int size = taskList.size();
978	<	//       PyObject * job_dict = PyList_New(0);
979	<	//       for ( unsigned int i = 0; i < size; ++i ) {
980	<	//      PyList_SetItem(job_dict,i, );
981	<	//      self->makeBossTask( *it );
982	<	//       }
983	<	return  job_dict;
984	<	}
985	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
986	<	std::string tmp;
914	<	BossAttributeContainer::const_iterator it_end = obj.end ();
915	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
916	<	it != it_end; ++it) {
917	<	tmp = (*it).first.name ();
918	<	char * key = new char[ tmp.size() ];
919	<	key = strdup(tmp.c_str());
920	<	tmp = (*it).second.value ();
921	<	PyObject * val = PyString_FromString( tmp.c_str() );
922	<	PyDict_SetItemString( dict, key, val );
923	<	delete [] key;
924	<	}
925	<	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	>	std::string tmp;
978	>	BossAttributeContainer::const_iterator it_end = obj.end ();
979	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
980	>	it != it_end; ++it) {
981	>
982	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
983	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
984	>	PyDict_SetItem( dict, key, val);
985	>	Py_DECREF(key);
986	>	Py_DECREF(val);
987		}
988	<	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());
942	<	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	>	PyObject * job_dict = PyDict_New();
1029	>	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1030	>	return job_dict;
1031	>	}
1032	>	PyObject *BossTask_Chain(BossTask *self,std::string const &jobid){
1033	>
1034	>	PyObject * chain_dict = PyDict_New();
1035	>	BossAttributeContainer obj =
1036	>	self->chain( jobid ).getTableEntries("CHAIN");
1037	>	BossTask_appendToPyDict ( self, chain_dict, obj );
1038	>	return chain_dict;
1039	>	}
1040	>	PyObject *BossTask_jobStates(BossTask *self){
1041
1042		PyObject * job_dict = PyDict_New();
1043	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1044		for (BossTask::job_iterator jit = self->job_begin ();
1045		jit != self->job_end (); ++jit) {
1046	<	std::string id = (*jit)->chainId();
1047	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1048	<	PyObject * myid =  PyString_FromString(id.c_str() );
1049	<	PyDict_SetItem( job_dict, myid,tmp );
1046	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1047	>	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1048	>	PyDict_SetItem( job_dict, id, status );
1049	>	Py_DECREF(id);
1050	>	Py_DECREF(status);
1051	>	}
1052	>	return job_dict;
1053	>	}
1054	>	PyObject *BossTask_joblist(BossTask *self){
1055	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1056	>	PyObject *  job_list = PyList_New( self->jobsInMemory() );
1057	>	unsigned int index = 0;
1058	>	for (BossTask::job_iterator jit = self->job_begin ();
1059	>	jit != self->job_end (); ++jit, ++index) {
1060	>	PyList_SetItem( job_list,
1061	>	index,
1062	>	PyString_FromString( ( (*jit)->chainId() ).c_str() )
1063	>	);
1064	>	}
1065	>	return job_list;
1066	>	}
1067	>	PyObject *BossTask_jobStatistic(BossTask *self){
1068	>
1069	>	PyObject * job_dict = PyDict_New();
1070	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1071	>	std::map< std::string, int > states;
1072	>	for (BossTask::job_iterator jit = self->job_begin ();
1073	>	jit != self->job_end (); ++jit) {
1074	>	++states[(**jit)["JOB.STATUS"]];
1075	>	}
1076	>
1077	>	std::map< std::string, int >::const_iterator end = states.end ();
1078	>	for (std::map< std::string, int >::const_iterator it = states.begin ();
1079	>	it != end; ++it) {
1080	>	PyObject * status = PyString_FromString( (it->first).c_str() );
1081	>	PyObject * jobs = PyString_FromFormat( "%d", it->second );
1082	>	PyDict_SetItem( job_dict, status, jobs );
1083	>	Py_DECREF(jobs);
1084	>	Py_DECREF(status);
1085		}
1086		return job_dict;
1087		}
#	Line 999 | Line 1126 | PyObject *BossTask_jobPrograms(BossTask
1126		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1127		++programs_it  ) {
1128		std::string id = (programs_it->first)["PROGRAM.ID"];
1129	<	PyObject * tmp =  BossTask_progDict( self, programs_it );
1129	>	PyObject * tmp_dict =  BossTask_progDict( self, programs_it );
1130		PyObject * myid =  PyString_FromString(id.c_str() );
1131	<	PyDict_SetItem( job_dict, myid,tmp );
1131	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1132	>	Py_DECREF(myid);
1133	>	Py_DECREF(tmp_dict);
1134	>	}
1135	>	return job_dict;
1136	>	}
1137	>	PyObject *BossTask_program(BossTask *self,std::string const &jobid,std::string const &programId){
1138	>
1139	>	PyObject * job_dict = PyDict_New();
1140	>
1141	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1142	>	BossAttributeContainer obj =
1143	>	self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1144	>	BossTask_appendToPyDict ( self, job_dict, obj );
1145	>	return job_dict;
1146	>	}
1147	>	PyObject *BossTask_programExec(BossTask *self,std::string const &jobid,std::string const &programId){
1148	>
1149	>	PyObject * job_dict = PyDict_New();
1150	>
1151	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1152	>
1153	>	// PROGRAM_EXEC
1154	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1155	>	BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1156	>	BossTask_appendToPyDict ( self, job_dict, obj );
1157	>
1158	>	// SPECIFICS
1159	>	std::vector < BossAttributeContainer >::const_iterator it;
1160	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1161	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1162	>	BossTask_appendToPyDict ( self, job_dict, *it );
1163	>	}
1164	>	return job_dict;
1165	>	}
1166	>	PyObject *BossTask_specific(BossTask *self,std::string const &jobid,std::string const &programId){
1167	>
1168	>	PyObject * job_dict = PyDict_New();
1169	>
1170	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1171	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1172	>	BossAttributeContainer obj = programExec.getKeys ();
1173	>	BossTask_appendToPyDict ( self, job_dict, obj );
1174	>
1175	>	std::vector < BossAttributeContainer >::const_iterator it;
1176	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1177	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1178	>	BossTask_appendToPyDict ( self, job_dict, *it );
1179		}
1180		return job_dict;
1181		}
#	Line 1017 | Line 1191 | static PyObject *_wrap_new_objectMap__SW
1191		try {
1192		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1193
1194	+	}catch (const BossSchedFailure & e) {
1195	+	PyErr_SetString ( SchedulerError, e.what() );
1196	+	return NULL;
1197		}catch (const std::exception& e) {
1198	<	SWIG_exception(SWIG_RuntimeError, e.what());
1198	>	PyErr_SetString ( BossError, e.what() );
1199	>	return NULL;
1200		}
1201		}
1202		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1076 | Line 1254 | static PyObject *_wrap_new_objectMap__SW
1254		try {
1255		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1256
1257	+	}catch (const BossSchedFailure & e) {
1258	+	PyErr_SetString ( SchedulerError, e.what() );
1259	+	return NULL;
1260		}catch (const std::exception& e) {
1261	<	SWIG_exception(SWIG_RuntimeError, e.what());
1261	>	PyErr_SetString ( BossError, e.what() );
1262	>	return NULL;
1263		}
1264		}
1265		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1191 | Line 1373 | static PyObject *_wrap_objectMap___len__
1373		try {
1374		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1375
1376	+	}catch (const BossSchedFailure & e) {
1377	+	PyErr_SetString ( SchedulerError, e.what() );
1378	+	return NULL;
1379		}catch (const std::exception& e) {
1380	<	SWIG_exception(SWIG_RuntimeError, e.what());
1380	>	PyErr_SetString ( BossError, e.what() );
1381	>	return NULL;
1382		}
1383		}
1384		resultobj = PyInt_FromLong((long)result);
#	Line 1213 | Line 1399 | static PyObject *_wrap_objectMap_clear(P
1399		try {
1400		(arg1)->clear();
1401
1402	+	}catch (const BossSchedFailure & e) {
1403	+	PyErr_SetString ( SchedulerError, e.what() );
1404	+	return NULL;
1405		}catch (const std::exception& e) {
1406	<	SWIG_exception(SWIG_RuntimeError, e.what());
1406	>	PyErr_SetString ( BossError, e.what() );
1407	>	return NULL;
1408		}
1409		}
1410		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1236 | Line 1426 | static PyObject *_wrap_objectMap___nonze
1426		try {
1427		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1428
1429	+	}catch (const BossSchedFailure & e) {
1430	+	PyErr_SetString ( SchedulerError, e.what() );
1431	+	return NULL;
1432		}catch (const std::exception& e) {
1433	<	SWIG_exception(SWIG_RuntimeError, e.what());
1433	>	PyErr_SetString ( BossError, e.what() );
1434	>	return NULL;
1435		}
1436		}
1437		resultobj = PyInt_FromLong((long)result);
#	Line 1308 | Line 1502 | static PyObject *_wrap_objectMap___setit
1502		try {
1503		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1504
1505	+	}catch (const BossSchedFailure & e) {
1506	+	PyErr_SetString ( SchedulerError, e.what() );
1507	+	return NULL;
1508		}catch (const std::exception& e) {
1509	<	SWIG_exception(SWIG_RuntimeError, e.what());
1509	>	PyErr_SetString ( BossError, e.what() );
1510	>	return NULL;
1511		}
1512		}
1513		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1370 | Line 1568 | static PyObject *_wrap_objectMap_has_key
1568		try {
1569		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1570
1571	+	}catch (const BossSchedFailure & e) {
1572	+	PyErr_SetString ( SchedulerError, e.what() );
1573	+	return NULL;
1574		}catch (const std::exception& e) {
1575	<	SWIG_exception(SWIG_RuntimeError, e.what());
1575	>	PyErr_SetString ( BossError, e.what() );
1576	>	return NULL;
1577		}
1578		}
1579		resultobj = PyInt_FromLong((long)result);
#	Line 1393 | Line 1595 | static PyObject *_wrap_objectMap_keys(Py
1595		try {
1596		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1597
1598	+	}catch (const BossSchedFailure & e) {
1599	+	PyErr_SetString ( SchedulerError, e.what() );
1600	+	return NULL;
1601		}catch (const std::exception& e) {
1602	<	SWIG_exception(SWIG_RuntimeError, e.what());
1602	>	PyErr_SetString ( BossError, e.what() );
1603	>	return NULL;
1604		}
1605		}
1606		resultobj = result;
#	Line 1416 | Line 1622 | static PyObject *_wrap_objectMap_values(
1622		try {
1623		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1624
1625	+	}catch (const BossSchedFailure & e) {
1626	+	PyErr_SetString ( SchedulerError, e.what() );
1627	+	return NULL;
1628		}catch (const std::exception& e) {
1629	<	SWIG_exception(SWIG_RuntimeError, e.what());
1629	>	PyErr_SetString ( BossError, e.what() );
1630	>	return NULL;
1631		}
1632		}
1633		resultobj = result;
#	Line 1439 | Line 1649 | static PyObject *_wrap_objectMap_items(P
1649		try {
1650		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1651
1652	+	}catch (const BossSchedFailure & e) {
1653	+	PyErr_SetString ( SchedulerError, e.what() );
1654	+	return NULL;
1655		}catch (const std::exception& e) {
1656	<	SWIG_exception(SWIG_RuntimeError, e.what());
1656	>	PyErr_SetString ( BossError, e.what() );
1657	>	return NULL;
1658		}
1659		}
1660		resultobj = result;
#	Line 1470 | Line 1684 | static PyObject *_wrap_objectMap___conta
1684		try {
1685		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1686
1687	+	}catch (const BossSchedFailure & e) {
1688	+	PyErr_SetString ( SchedulerError, e.what() );
1689	+	return NULL;
1690		}catch (const std::exception& e) {
1691	<	SWIG_exception(SWIG_RuntimeError, e.what());
1691	>	PyErr_SetString ( BossError, e.what() );
1692	>	return NULL;
1693		}
1694		}
1695		resultobj = PyInt_FromLong((long)result);
#	Line 1516 | Line 1734 | static PyObject *_wrap_delete_objectMap(
1734		try {
1735		delete arg1;
1736
1737	+	}catch (const BossSchedFailure & e) {
1738	+	PyErr_SetString ( SchedulerError, e.what() );
1739	+	return NULL;
1740		}catch (const std::exception& e) {
1741	<	SWIG_exception(SWIG_RuntimeError, e.what());
1741	>	PyErr_SetString ( BossError, e.what() );
1742	>	return NULL;
1743		}
1744		}
1745		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1534 | Line 1756 | static PyObject * objectMap_swigregister
1756		Py_INCREF(obj);
1757		return Py_BuildValue((char *)"");
1758		}
1759	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
1759	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1760		PyObject *resultobj;
1761	<	BossSession *arg1 = (BossSession *) 0 ;
1762	<	std::vector<std::string > *arg2 = 0 ;
1763	<	PyObject *result;
1761	>	unsigned int arg1 = (unsigned int) 0 ;
1762	>	std::vector<std::string > *result;
1763	>	PyObject * obj0 = 0 ;
1764	>
1765	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1766	>	if (obj0) {
1767	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1768	>	if (PyErr_Occurred()) SWIG_fail;
1769	>	}
1770	>	{
1771	>	try {
1772	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1773	>
1774	>	}catch (const BossSchedFailure & e) {
1775	>	PyErr_SetString ( SchedulerError, e.what() );
1776	>	return NULL;
1777	>	}catch (const std::exception& e) {
1778	>	PyErr_SetString ( BossError, e.what() );
1779	>	return NULL;
1780	>	}
1781	>	}
1782	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1783	>	return resultobj;
1784	>	fail:
1785	>	return NULL;
1786	>	}
1787	>
1788	>
1789	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1790	>	PyObject *resultobj;
1791	>	unsigned int arg1 ;
1792	>	std::string *arg2 = 0 ;
1793	>	std::vector<std::string > *result;
1794	>	std::string temp2 ;
1795		PyObject * obj0 = 0 ;
1796		PyObject * obj1 = 0 ;
1797
1798	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
1799	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1800	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1801	<	if (arg2 == NULL) {
1802	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
1798	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1799	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1800	>	if (PyErr_Occurred()) SWIG_fail;
1801	>	{
1802	>	if (PyString_Check(obj1)) {
1803	>	temp2 = std::string(PyString_AsString(obj1));
1804	>	arg2 = &temp2;
1805	>	}else {
1806	>	SWIG_exception(SWIG_TypeError, "string expected");
1807	>	}
1808		}
1809		{
1810		try {
1811	<	result = (PyObject *)BossSession_show(arg1,*arg2);
1811	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1812
1813	+	}catch (const BossSchedFailure & e) {
1814	+	PyErr_SetString ( SchedulerError, e.what() );
1815	+	return NULL;
1816		}catch (const std::exception& e) {
1817	<	SWIG_exception(SWIG_RuntimeError, e.what());
1817	>	PyErr_SetString ( BossError, e.what() );
1818	>	return NULL;
1819		}
1820		}
1821	<	resultobj = result;
1821	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1822		return resultobj;
1823		fail:
1824		return NULL;
1825		}
1826
1827
1828	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_1(PyObject *self, PyObject *args) {
1828	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1829		PyObject *resultobj;
1830	<	BossSession *arg1 = (BossSession *) 0 ;
1831	<	PyObject *result;
1830	>	std::vector<std::string > *arg1 = 0 ;
1831	>	std::vector<std::string > *result;
1832	>	std::vector<std::string > temp1 ;
1833	>	std::vector<std::string > *v1 ;
1834		PyObject * obj0 = 0 ;
1835
1836	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
1837	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1836	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1837	>	{
1838	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1839	>	unsigned int size = (PyTuple_Check(obj0) ?
1840	>	PyTuple_Size(obj0) :
1841	>	PyList_Size(obj0));
1842	>	temp1 = std::vector<std::string >(size);
1843	>	arg1 = &temp1;
1844	>	for (unsigned int i=0; i<size; i++) {
1845	>	PyObject* o = PySequence_GetItem(obj0,i);
1846	>	if (PyString_Check(o)) {
1847	>	temp1[i] = (std::string)(\
1848	>	SwigString_AsString(o));
1849	>	Py_DECREF(o);
1850	>	}else {
1851	>	Py_DECREF(o);
1852	>	PyErr_SetString(PyExc_TypeError,
1853	>	"vector<""std::string""> expected");
1854	>	SWIG_fail;
1855	>	}
1856	>	}
1857	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1858	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1859	>	arg1 = v1;
1860	>	}else {
1861	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1862	>	SWIG_fail;
1863	>	}
1864	>	}
1865		{
1866		try {
1867	<	result = (PyObject *)BossSession_showCHTools__SWIG_1(arg1);
1867	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1868
1869	+	}catch (const BossSchedFailure & e) {
1870	+	PyErr_SetString ( SchedulerError, e.what() );
1871	+	return NULL;
1872		}catch (const std::exception& e) {
1873	<	SWIG_exception(SWIG_RuntimeError, e.what());
1873	>	PyErr_SetString ( BossError, e.what() );
1874	>	return NULL;
1875		}
1876		}
1877	<	resultobj = result;
1877	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1878		return resultobj;
1879		fail:
1880		return NULL;
1881		}
1882
1883
1884	<	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
1884	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1885		int argc;
1886	<	PyObject *argv[2];
1886	>	PyObject *argv[3];
1887		int ii;
1888
1889		argc = PyObject_Length(args);
1890	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1890	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1891		argv[ii] = PyTuple_GetItem(args,ii);
1892		}
1893	+	if ((argc >= 0) && (argc <= 1)) {
1894	+	int _v;
1895	+	if (argc <= 0) {
1896	+	return _wrap_new_vector_string__SWIG_0(self,args);
1897	+	}
1898	+	{
1899	+	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1900	+	}
1901	+	if (_v) {
1902	+	return _wrap_new_vector_string__SWIG_0(self,args);
1903	+	}
1904	+	}
1905		if (argc == 1) {
1906		int _v;
1907		{
1908	<	void *ptr;
1909	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1910	<	_v = 0;
1911	<	PyErr_Clear();
1908	>	/* native sequence? */
1909	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1910	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1911	>	PyTuple_Size(argv[0]) :
1912	>	PyList_Size(argv[0]));
1913	>	if (size == 0) {
1914	>	/* an empty sequence can be of any type */
1915	>	_v = 1;
1916	>	}else {
1917	>	/* check the first element only */
1918	>	PyObject* o = PySequence_GetItem(argv[0],0);
1919	>	if (PyString_Check(o))
1920	>	_v = 1;
1921	>	else
1922	>	_v = 0;
1923	>	Py_DECREF(o);
1924	>	}
1925		}else {
1926	+	/* wrapped vector? */
1927	+	std::vector<std::string >* v;
1928	+	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1929	+	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1930		_v = 1;
1931	+	else
1932	+	_v = 0;
1933		}
1934		}
1935		if (_v) {
1936	<	return _wrap_BossSession_showCHTools__SWIG_1(self,args);
1936	>	return _wrap_new_vector_string__SWIG_2(self,args);
1937	>	}
1938	>	}
1939	>	if (argc == 2) {
1940	>	int _v;
1941	>	{
1942	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1943	>	}
1944	>	if (_v) {
1945	>	{
1946	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1947	>	}
1948	>	if (_v) {
1949	>	return _wrap_new_vector_string__SWIG_1(self,args);
1950	>	}
1951		}
1952		}
1953
1954	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showCHTools'");
1954	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1955		return NULL;
1956		}
1957
1958
1959	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_1(PyObject *self, PyObject *args) {
1959	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1960		PyObject *resultobj;
1961	<	BossSession *arg1 = (BossSession *) 0 ;
1962	<	PyObject *result;
1961	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1962	>	unsigned int result;
1963	>	std::vector<std::string > temp1 ;
1964	>	std::vector<std::string > *v1 ;
1965		PyObject * obj0 = 0 ;
1966
1967	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
1968	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1967	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1968	>	{
1969	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1970	>	unsigned int size = (PyTuple_Check(obj0) ?
1971	>	PyTuple_Size(obj0) :
1972	>	PyList_Size(obj0));
1973	>	temp1 = std::vector<std::string >(size);
1974	>	arg1 = &temp1;
1975	>	for (unsigned int i=0; i<size; i++) {
1976	>	PyObject* o = PySequence_GetItem(obj0,i);
1977	>	if (PyString_Check(o)) {
1978	>	temp1[i] = (std::string)(\
1979	>	SwigString_AsString(o));
1980	>	Py_DECREF(o);
1981	>	}else {
1982	>	Py_DECREF(o);
1983	>	PyErr_SetString(PyExc_TypeError,
1984	>	"vector<""std::string""> expected");
1985	>	SWIG_fail;
1986	>	}
1987	>	}
1988	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1989	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1990	>	arg1 = v1;
1991	>	}else {
1992	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1993	>	SWIG_fail;
1994	>	}
1995	>	}
1996		{
1997		try {
1998	<	result = (PyObject *)BossSession_showProgramTypes__SWIG_1(arg1);
1998	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1999
2000	+	}catch (const BossSchedFailure & e) {
2001	+	PyErr_SetString ( SchedulerError, e.what() );
2002	+	return NULL;
2003		}catch (const std::exception& e) {
2004	<	SWIG_exception(SWIG_RuntimeError, e.what());
2004	>	PyErr_SetString ( BossError, e.what() );
2005	>	return NULL;
2006		}
2007		}
2008	<	resultobj = result;
2008	>	resultobj = PyInt_FromLong((long)result);
2009		return resultobj;
2010		fail:
2011		return NULL;
2012		}
2013
2014
2015	<	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2016	<	int argc;
2017	<	PyObject *argv[2];
2018	<	int ii;
2015	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
2016	>	PyObject *resultobj;
2017	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2018	>	bool result;
2019	>	std::vector<std::string > temp1 ;
2020	>	std::vector<std::string > *v1 ;
2021	>	PyObject * obj0 = 0 ;
2022
2023	<	argc = PyObject_Length(args);
2024	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2025	<	argv[ii] = PyTuple_GetItem(args,ii);
2026	<	}
2027	<	if (argc == 1) {
2028	<	int _v;
2029	<	{
2030	<	void *ptr;
2031	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2032	<	_v = 0;
2033	<	PyErr_Clear();
2034	<	}else {
2035	<	_v = 1;
2023	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
2024	>	{
2025	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
2026	>	unsigned int size = (PyTuple_Check(obj0) ?
2027	>	PyTuple_Size(obj0) :
2028	>	PyList_Size(obj0));
2029	>	temp1 = std::vector<std::string >(size);
2030	>	arg1 = &temp1;
2031	>	for (unsigned int i=0; i<size; i++) {
2032	>	PyObject* o = PySequence_GetItem(obj0,i);
2033	>	if (PyString_Check(o)) {
2034	>	temp1[i] = (std::string)(\
2035	>	SwigString_AsString(o));
2036	>	Py_DECREF(o);
2037	>	}else {
2038	>	Py_DECREF(o);
2039	>	PyErr_SetString(PyExc_TypeError,
2040	>	"vector<""std::string""> expected");
2041	>	SWIG_fail;
2042	>	}
2043		}
2044	+	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
2045	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2046	+	arg1 = v1;
2047	+	}else {
2048	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2049	+	SWIG_fail;
2050		}
2051	<	if (_v) {
2052	<	return _wrap_BossSession_showProgramTypes__SWIG_1(self,args);
2051	>	}
2052	>	{
2053	>	try {
2054	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
2055	>
2056	>	}catch (const BossSchedFailure & e) {
2057	>	PyErr_SetString ( SchedulerError, e.what() );
2058	>	return NULL;
2059	>	}catch (const std::exception& e) {
2060	>	PyErr_SetString ( BossError, e.what() );
2061	>	return NULL;
2062		}
2063		}
2064	<
2065	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showProgramTypes'");
2064	>	resultobj = PyInt_FromLong((long)result);
2065	>	return resultobj;
2066	>	fail:
2067		return NULL;
2068		}
2069
2070
2071	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_1(PyObject *self, PyObject *args) {
2071	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
2072		PyObject *resultobj;
2073	<	BossSession *arg1 = (BossSession *) 0 ;
1675	<	PyObject *result;
2073	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2074		PyObject * obj0 = 0 ;
2075
2076	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2077	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2076	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
2077	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2078		{
2079		try {
2080	<	result = (PyObject *)BossSession_showRTMon__SWIG_1(arg1);
2080	>	(arg1)->clear();
2081
2082	+	}catch (const BossSchedFailure & e) {
2083	+	PyErr_SetString ( SchedulerError, e.what() );
2084	+	return NULL;
2085		}catch (const std::exception& e) {
2086	<	SWIG_exception(SWIG_RuntimeError, e.what());
2086	>	PyErr_SetString ( BossError, e.what() );
2087	>	return NULL;
2088		}
2089		}
2090	<	resultobj = result;
2090	>	Py_INCREF(Py_None); resultobj = Py_None;
2091		return resultobj;
2092		fail:
2093		return NULL;
2094		}
2095
2096
2097	<	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2098	<	int argc;
2099	<	PyObject *argv[2];
2100	<	int ii;
2097	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
2098	>	PyObject *resultobj;
2099	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2100	>	std::string arg2 ;
2101	>	PyObject * obj0 = 0 ;
2102	>	PyObject * obj1 = 0 ;
2103
2104	<	argc = PyObject_Length(args);
2105	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2106	<	argv[ii] = PyTuple_GetItem(args,ii);
2104	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
2105	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2106	>	{
2107	>	if (PyString_Check(obj1))
2108	>	arg2 = std::string(PyString_AsString(obj1));
2109	>	else
2110	>	SWIG_exception(SWIG_TypeError, "string expected");
2111		}
2112	<	if (argc == 1) {
2113	<	int _v;
2114	<	{
2115	<	void *ptr;
2116	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2117	<	_v = 0;
2118	<	PyErr_Clear();
2119	<	}else {
2120	<	_v = 1;
2121	<	}
2112	>	{
2113	>	try {
2114	>	(arg1)->push_back(arg2);
2115	>
2116	>	}catch (const BossSchedFailure & e) {
2117	>	PyErr_SetString ( SchedulerError, e.what() );
2118	>	return NULL;
2119	>	}catch (const std::exception& e) {
2120	>	PyErr_SetString ( BossError, e.what() );
2121	>	return NULL;
2122		}
2123	<	if (_v) {
2124	<	return _wrap_BossSession_showRTMon__SWIG_1(self,args);
2123	>	}
2124	>	Py_INCREF(Py_None); resultobj = Py_None;
2125	>	return resultobj;
2126	>	fail:
2127	>	return NULL;
2128	>	}
2129	>
2130	>
2131	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
2132	>	PyObject *resultobj;
2133	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2134	>	std::string result;
2135	>	PyObject * obj0 = 0 ;
2136	>
2137	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
2138	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2139	>	{
2140	>	try {
2141	>	result = std_vectorlstd_string_g_pop___(arg1);
2142	>
2143	>	}catch (std::out_of_range& e) {
2144	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2145		}
2146		}
2147	+	{
2148	+	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2149	+	}
2150	+	return resultobj;
2151	+	fail:
2152	+	return NULL;
2153	+	}
2154	+
2155	+
2156	+	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
2157	+	PyObject *resultobj;
2158	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2159	+	int arg2 ;
2160	+	std::string result;
2161	+	PyObject * obj0 = 0 ;
2162
2163	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showRTMon'");
2163	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2164	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2165	>	{
2166	>	try {
2167	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2168	>
2169	>	}catch (std::out_of_range& e) {
2170	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2171	>	}
2172	>	}
2173	>	{
2174	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2175	>	}
2176	>	return resultobj;
2177	>	fail:
2178		return NULL;
2179		}
2180
2181
2182	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_1(PyObject *self, PyObject *args) {
2182	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2183		PyObject *resultobj;
2184	<	BossSession *arg1 = (BossSession *) 0 ;
2185	<	PyObject *result;
2184	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2185	>	int arg2 ;
2186	>	int arg3 ;
2187	>	std::vector<std::string > result;
2188		PyObject * obj0 = 0 ;
2189
2190	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2191	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2190	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2191	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2192		{
2193		try {
2194	<	result = (PyObject *)BossSession_showSchedulers__SWIG_1(arg1);
2194	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2195
2196	+	}catch (const BossSchedFailure & e) {
2197	+	PyErr_SetString ( SchedulerError, e.what() );
2198	+	return NULL;
2199		}catch (const std::exception& e) {
2200	<	SWIG_exception(SWIG_RuntimeError, e.what());
2200	>	PyErr_SetString ( BossError, e.what() );
2201	>	return NULL;
2202		}
2203		}
2204	<	resultobj = result;
2204	>	{
2205	>	resultobj = PyTuple_New((&result)->size());
2206	>	for (unsigned int i=0; i<(&result)->size(); i++)
2207	>	PyTuple_SetItem(resultobj,i,
2208	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2209	>	}
2210		return resultobj;
2211		fail:
2212		return NULL;
2213		}
2214
2215
2216	<	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2217	<	int argc;
2218	<	PyObject *argv[2];
2219	<	int ii;
2216	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2217	>	PyObject *resultobj;
2218	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2219	>	int arg2 ;
2220	>	std::string arg3 ;
2221	>	PyObject * obj0 = 0 ;
2222	>	PyObject * obj2 = 0 ;
2223
2224	<	argc = PyObject_Length(args);
2225	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2226	<	argv[ii] = PyTuple_GetItem(args,ii);
2224	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2225	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2226	>	{
2227	>	if (PyString_Check(obj2))
2228	>	arg3 = std::string(PyString_AsString(obj2));
2229	>	else
2230	>	SWIG_exception(SWIG_TypeError, "string expected");
2231		}
2232	<	if (argc == 1) {
2233	<	int _v;
2234	<	{
2235	<	void *ptr;
2236	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2237	<	_v = 0;
1763	<	PyErr_Clear();
1764	<	}else {
1765	<	_v = 1;
1766	<	}
1767	<	}
1768	<	if (_v) {
1769	<	return _wrap_BossSession_showSchedulers__SWIG_1(self,args);
2232	>	{
2233	>	try {
2234	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2235	>
2236	>	}catch (std::out_of_range& e) {
2237	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2238		}
2239		}
2240	<
2241	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showSchedulers'");
2240	>	Py_INCREF(Py_None); resultobj = Py_None;
2241	>	return resultobj;
2242	>	fail:
2243		return NULL;
2244		}
2245
2246
2247	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2247	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2248		PyObject *resultobj;
2249	<	BossSession *arg1 = (BossSession *) 0 ;
2250	<	int arg2 = (int) SCHEDULED ;
2251	<	std::string const &arg3_defvalue = "all" ;
2252	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
2253	<	std::string const &arg4_defvalue = "all" ;
2254	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
1786	<	std::string const &arg5_defvalue = "" ;
1787	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
1788	<	std::string arg6 = (std::string) "" ;
1789	<	std::string arg7 = (std::string) "" ;
1790	<	std::string arg8 = (std::string) "" ;
1791	<	std::string arg9 = (std::string) "" ;
1792	<	bool arg10 = (bool) false ;
1793	<	PyObject *result;
1794	<	std::string temp3 ;
1795	<	std::string temp4 ;
1796	<	std::string temp5 ;
2249	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2250	>	int arg2 ;
2251	>	int arg3 ;
2252	>	std::vector<std::string > *arg4 = 0 ;
2253	>	std::vector<std::string > temp4 ;
2254	>	std::vector<std::string > *v4 ;
2255		PyObject * obj0 = 0 ;
1798	–	PyObject * obj2 = 0 ;
2256		PyObject * obj3 = 0 ;
1800	–	PyObject * obj4 = 0 ;
1801	–	PyObject * obj5 = 0 ;
1802	–	PyObject * obj6 = 0 ;
1803	–	PyObject * obj7 = 0 ;
1804	–	PyObject * obj8 = 0 ;
1805	–	PyObject * obj9 = 0 ;
2257
2258	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2259	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2260	<	if (obj2) {
2261	<	{
2262	<	if (PyString_Check(obj2)) {
2263	<	temp3 = std::string(PyString_AsString(obj2));
2264	<	arg3 = &temp3;
2265	<	}else {
2266	<	SWIG_exception(SWIG_TypeError, "string expected");
2258	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2259	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2260	>	{
2261	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2262	>	unsigned int size = (PyTuple_Check(obj3) ?
2263	>	PyTuple_Size(obj3) :
2264	>	PyList_Size(obj3));
2265	>	temp4 = std::vector<std::string >(size);
2266	>	arg4 = &temp4;
2267	>	for (unsigned int i=0; i<size; i++) {
2268	>	PyObject* o = PySequence_GetItem(obj3,i);
2269	>	if (PyString_Check(o)) {
2270	>	temp4[i] = (std::string)(\
2271	>	SwigString_AsString(o));
2272	>	Py_DECREF(o);
2273	>	}else {
2274	>	Py_DECREF(o);
2275	>	PyErr_SetString(PyExc_TypeError,
2276	>	"vector<""std::string""> expected");
2277	>	SWIG_fail;
2278	>	}
2279		}
2280	+	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2281	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2282	+	arg4 = v4;
2283	+	}else {
2284	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2285	+	SWIG_fail;
2286		}
2287		}
2288	<	if (obj3) {
2289	<	{
2290	<	if (PyString_Check(obj3)) {
2291	<	temp4 = std::string(PyString_AsString(obj3));
2292	<	arg4 = &temp4;
2293	<	}else {
2294	<	SWIG_exception(SWIG_TypeError, "string expected");
2295	<	}
2288	>	{
2289	>	try {
2290	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2291	>
2292	>	}catch (const BossSchedFailure & e) {
2293	>	PyErr_SetString ( SchedulerError, e.what() );
2294	>	return NULL;
2295	>	}catch (const std::exception& e) {
2296	>	PyErr_SetString ( BossError, e.what() );
2297	>	return NULL;
2298		}
2299		}
2300	<	if (obj4) {
2301	<	{
2302	<	if (PyString_Check(obj4)) {
2303	<	temp5 = std::string(PyString_AsString(obj4));
2304	<	arg5 = &temp5;
2305	<	}else {
2306	<	SWIG_exception(SWIG_TypeError, "string expected");
2307	<	}
2300	>	Py_INCREF(Py_None); resultobj = Py_None;
2301	>	return resultobj;
2302	>	fail:
2303	>	return NULL;
2304	>	}
2305	>
2306	>
2307	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2308	>	PyObject *resultobj;
2309	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2310	>	int arg2 ;
2311	>	PyObject * obj0 = 0 ;
2312	>
2313	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2314	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2315	>	{
2316	>	try {
2317	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2318	>
2319	>	}catch (std::out_of_range& e) {
2320	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2321		}
2322		}
2323	<	if (obj5) {
2323	>	Py_INCREF(Py_None); resultobj = Py_None;
2324	>	return resultobj;
2325	>	fail:
2326	>	return NULL;
2327	>	}
2328	>
2329	>
2330	>	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2331	>	PyObject *resultobj;
2332	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2333	>	int arg2 ;
2334	>	int arg3 ;
2335	>	PyObject * obj0 = 0 ;
2336	>
2337	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2338	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2339	>	{
2340	>	try {
2341	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2342	>
2343	>	}catch (const BossSchedFailure & e) {
2344	>	PyErr_SetString ( SchedulerError, e.what() );
2345	>	return NULL;
2346	>	}catch (const std::exception& e) {
2347	>	PyErr_SetString ( BossError, e.what() );
2348	>	return NULL;
2349	>	}
2350	>	}
2351	>	Py_INCREF(Py_None); resultobj = Py_None;
2352	>	return resultobj;
2353	>	fail:
2354	>	return NULL;
2355	>	}
2356	>
2357	>
2358	>	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2359	>	PyObject *resultobj;
2360	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2361	>	PyObject * obj0 = 0 ;
2362	>
2363	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2364	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2365	>	{
2366	>	try {
2367	>	delete arg1;
2368	>
2369	>	}catch (const BossSchedFailure & e) {
2370	>	PyErr_SetString ( SchedulerError, e.what() );
2371	>	return NULL;
2372	>	}catch (const std::exception& e) {
2373	>	PyErr_SetString ( BossError, e.what() );
2374	>	return NULL;
2375	>	}
2376	>	}
2377	>	Py_INCREF(Py_None); resultobj = Py_None;
2378	>	return resultobj;
2379	>	fail:
2380	>	return NULL;
2381	>	}
2382	>
2383	>
2384	>	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2385	>	PyObject *obj;
2386	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2387	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2388	>	Py_INCREF(obj);
2389	>	return Py_BuildValue((char *)"");
2390	>	}
2391	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2392	>	PyObject *resultobj;
2393	>	std::string arg1 = (std::string) "" ;
2394	>	std::string arg2 = (std::string) "2" ;
2395	>	std::string arg3 = (std::string) "" ;
2396	>	std::string arg4 = (std::string) "" ;
2397	>	BossSession *result;
2398	>	PyObject * obj0 = 0 ;
2399	>	PyObject * obj1 = 0 ;
2400	>	PyObject * obj2 = 0 ;
2401	>	PyObject * obj3 = 0 ;
2402	>
2403	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2404	>	if (obj0) {
2405		{
2406	<	if (PyString_Check(obj5))
2407	<	arg6 = std::string(PyString_AsString(obj5));
2406	>	if (PyString_Check(obj0))
2407	>	arg1 = std::string(PyString_AsString(obj0));
2408		else
2409		SWIG_exception(SWIG_TypeError, "string expected");
2410		}
2411		}
2412	<	if (obj6) {
2412	>	if (obj1) {
2413		{
2414	<	if (PyString_Check(obj6))
2415	<	arg7 = std::string(PyString_AsString(obj6));
2414	>	if (PyString_Check(obj1))
2415	>	arg2 = std::string(PyString_AsString(obj1));
2416		else
2417		SWIG_exception(SWIG_TypeError, "string expected");
2418		}
2419		}
2420	<	if (obj7) {
2420	>	if (obj2) {
2421		{
2422	<	if (PyString_Check(obj7))
2423	<	arg8 = std::string(PyString_AsString(obj7));
2422	>	if (PyString_Check(obj2))
2423	>	arg3 = std::string(PyString_AsString(obj2));
2424		else
2425		SWIG_exception(SWIG_TypeError, "string expected");
2426		}
2427		}
2428	<	if (obj8) {
2428	>	if (obj3) {
2429		{
2430	<	if (PyString_Check(obj8))
2431	<	arg9 = std::string(PyString_AsString(obj8));
2430	>	if (PyString_Check(obj3))
2431	>	arg4 = std::string(PyString_AsString(obj3));
2432		else
2433		SWIG_exception(SWIG_TypeError, "string expected");
2434		}
2435		}
1871	–	if (obj9) {
1872	–	arg10 = PyInt_AsLong(obj9) ? true : false;
1873	–	if (PyErr_Occurred()) SWIG_fail;
1874	–	}
2436		{
2437		try {
2438	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2438	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2439
2440	+	}catch (const BossSchedFailure & e) {
2441	+	PyErr_SetString ( SchedulerError, e.what() );
2442	+	return NULL;
2443		}catch (const std::exception& e) {
2444	<	SWIG_exception(SWIG_RuntimeError, e.what());
2444	>	PyErr_SetString ( BossError, e.what() );
2445	>	return NULL;
2446		}
2447		}
2448	<	resultobj = result;
2448	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2449		return resultobj;
2450		fail:
2451		return NULL;
2452		}
2453
2454
2455	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2455	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2456		PyObject *resultobj;
2457	<	std::string arg1 = (std::string) "" ;
1893	<	BossSession *result;
2457	>	BossSession *arg1 = (BossSession *) 0 ;
2458		PyObject * obj0 = 0 ;
2459
2460	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2461	<	if (obj0) {
1898	<	{
1899	<	if (PyString_Check(obj0))
1900	<	arg1 = std::string(PyString_AsString(obj0));
1901	<	else
1902	<	SWIG_exception(SWIG_TypeError, "string expected");
1903	<	}
1904	<	}
2460	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2461	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2462		{
2463		try {
2464	<	result = (BossSession *)new BossSession(arg1);
2464	>	delete arg1;
2465
2466	+	}catch (const BossSchedFailure & e) {
2467	+	PyErr_SetString ( SchedulerError, e.what() );
2468	+	return NULL;
2469		}catch (const std::exception& e) {
2470	<	SWIG_exception(SWIG_RuntimeError, e.what());
2470	>	PyErr_SetString ( BossError, e.what() );
2471	>	return NULL;
2472		}
2473		}
2474	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2474	>	Py_INCREF(Py_None); resultobj = Py_None;
2475		return resultobj;
2476		fail:
2477		return NULL;
2478		}
2479
2480
2481	<	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2481	>	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2482		PyObject *resultobj;
2483		BossSession *arg1 = (BossSession *) 0 ;
2484		PyObject * obj0 = 0 ;
2485
2486	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2486	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2487		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2488		{
2489		try {
2490	<	delete arg1;
2490	>	(arg1)->resetDB();
2491
2492	+	}catch (const BossSchedFailure & e) {
2493	+	PyErr_SetString ( SchedulerError, e.what() );
2494	+	return NULL;
2495		}catch (const std::exception& e) {
2496	<	SWIG_exception(SWIG_RuntimeError, e.what());
2496	>	PyErr_SetString ( BossError, e.what() );
2497	>	return NULL;
2498		}
2499		}
2500		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1950 | Line 2515 | static PyObject *_wrap_BossSession_clear
2515		try {
2516		(arg1)->clear();
2517
2518	+	}catch (const BossSchedFailure & e) {
2519	+	PyErr_SetString ( SchedulerError, e.what() );
2520	+	return NULL;
2521		}catch (const std::exception& e) {
2522	<	SWIG_exception(SWIG_RuntimeError, e.what());
2522	>	PyErr_SetString ( BossError, e.what() );
2523	>	return NULL;
2524		}
2525		}
2526		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1961 | Line 2530 | static PyObject *_wrap_BossSession_clear
2530		}
2531
2532
2533	+	static PyObject *_wrap_BossSession_task_begin(PyObject *self, PyObject *args) {
2534	+	PyObject *resultobj;
2535	+	BossSession *arg1 = (BossSession *) 0 ;
2536	+	BossSession::task_iterator result;
2537	+	PyObject * obj0 = 0 ;
2538	+
2539	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_begin",&obj0)) goto fail;
2540	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2541	+	{
2542	+	try {
2543	+	result = ((BossSession const *)arg1)->task_begin();
2544	+
2545	+	}catch (const BossSchedFailure & e) {
2546	+	PyErr_SetString ( SchedulerError, e.what() );
2547	+	return NULL;
2548	+	}catch (const std::exception& e) {
2549	+	PyErr_SetString ( BossError, e.what() );
2550	+	return NULL;
2551	+	}
2552	+	}
2553	+	{
2554	+	BossSession::task_iterator * resultptr;
2555	+	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2556	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2557	+	}
2558	+	return resultobj;
2559	+	fail:
2560	+	return NULL;
2561	+	}
2562	+
2563	+
2564	+	static PyObject *_wrap_BossSession_task_end(PyObject *self, PyObject *args) {
2565	+	PyObject *resultobj;
2566	+	BossSession *arg1 = (BossSession *) 0 ;
2567	+	BossSession::task_iterator result;
2568	+	PyObject * obj0 = 0 ;
2569	+
2570	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_end",&obj0)) goto fail;
2571	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2572	+	{
2573	+	try {
2574	+	result = ((BossSession const *)arg1)->task_end();
2575	+
2576	+	}catch (const BossSchedFailure & e) {
2577	+	PyErr_SetString ( SchedulerError, e.what() );
2578	+	return NULL;
2579	+	}catch (const std::exception& e) {
2580	+	PyErr_SetString ( BossError, e.what() );
2581	+	return NULL;
2582	+	}
2583	+	}
2584	+	{
2585	+	BossSession::task_iterator * resultptr;
2586	+	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2587	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2588	+	}
2589	+	return resultobj;
2590	+	fail:
2591	+	return NULL;
2592	+	}
2593	+
2594	+
2595	+	static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
2596	+	PyObject *resultobj;
2597	+	BossSession *arg1 = (BossSession *) 0 ;
2598	+	unsigned int result;
2599	+	PyObject * obj0 = 0 ;
2600	+
2601	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
2602	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2603	+	{
2604	+	try {
2605	+	result = (unsigned int)((BossSession const *)arg1)->tasksInMemory();
2606	+
2607	+	}catch (const BossSchedFailure & e) {
2608	+	PyErr_SetString ( SchedulerError, e.what() );
2609	+	return NULL;
2610	+	}catch (const std::exception& e) {
2611	+	PyErr_SetString ( BossError, e.what() );
2612	+	return NULL;
2613	+	}
2614	+	}
2615	+	resultobj = PyInt_FromLong((long)result);
2616	+	return resultobj;
2617	+	fail:
2618	+	return NULL;
2619	+	}
2620	+
2621	+
2622	+	static PyObject *_wrap_BossSession_locate(PyObject *self, PyObject *args) {
2623	+	PyObject *resultobj;
2624	+	BossSession *arg1 = (BossSession *) 0 ;
2625	+	unsigned int arg2 ;
2626	+	BossTask *result;
2627	+	PyObject * obj0 = 0 ;
2628	+	PyObject * obj1 = 0 ;
2629	+
2630	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
2631	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2632	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
2633	+	if (PyErr_Occurred()) SWIG_fail;
2634	+	{
2635	+	try {
2636	+	result = (BossTask *)((BossSession const *)arg1)->locate(arg2);
2637	+
2638	+	}catch (const BossSchedFailure & e) {
2639	+	PyErr_SetString ( SchedulerError, e.what() );
2640	+	return NULL;
2641	+	}catch (const std::exception& e) {
2642	+	PyErr_SetString ( BossError, e.what() );
2643	+	return NULL;
2644	+	}
2645	+	}
2646	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2647	+	return resultobj;
2648	+	fail:
2649	+	return NULL;
2650	+	}
2651	+
2652	+
2653		static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2654		PyObject *resultobj;
2655		BossSession *arg1 = (BossSession *) 0 ;
#	Line 1987 | Line 2676 | static PyObject *_wrap_BossSession_makeB
2676		try {
2677		result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2678
2679	+	}catch (const BossSchedFailure & e) {
2680	+	PyErr_SetString ( SchedulerError, e.what() );
2681	+	return NULL;
2682		}catch (const std::exception& e) {
2683	<	SWIG_exception(SWIG_RuntimeError, e.what());
2683	>	PyErr_SetString ( BossError, e.what() );
2684	>	return NULL;
2685		}
2686		}
2687		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
#	Line 2012 | Line 2705 | static PyObject *_wrap_BossSession_destr
2705		try {
2706		(arg1)->destroyBossTask(arg2);
2707
2708	+	}catch (const BossSchedFailure & e) {
2709	+	PyErr_SetString ( SchedulerError, e.what() );
2710	+	return NULL;
2711		}catch (const std::exception& e) {
2712	<	SWIG_exception(SWIG_RuntimeError, e.what());
2712	>	PyErr_SetString ( BossError, e.what() );
2713	>	return NULL;
2714		}
2715		}
2716		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2023 | Line 2720 | static PyObject *_wrap_BossSession_destr
2720		}
2721
2722
2723	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_0(PyObject *self, PyObject *args) {
2723	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2724		PyObject *resultobj;
2725		BossSession *arg1 = (BossSession *) 0 ;
2726	<	SwigValueWrapper< std::vector<std::string > > result;
2726	>	std::vector<std::string > result;
2727		PyObject * obj0 = 0 ;
2728
2729		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
#	Line 2035 | Line 2732 | static PyObject *_wrap_BossSession_showC
2732		try {
2733		result = (arg1)->showCHTools();
2734
2735	+	}catch (const BossSchedFailure & e) {
2736	+	PyErr_SetString ( SchedulerError, e.what() );
2737	+	return NULL;
2738		}catch (const std::exception& e) {
2739	<	SWIG_exception(SWIG_RuntimeError, e.what());
2739	>	PyErr_SetString ( BossError, e.what() );
2740	>	return NULL;
2741		}
2742		}
2743		{
2744	<	std::vector<std::string > * resultptr;
2745	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2746	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2744	>	resultobj = PyTuple_New((&result)->size());
2745	>	for (unsigned int i=0; i<(&result)->size(); i++)
2746	>	PyTuple_SetItem(resultobj,i,
2747	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2748		}
2749		return resultobj;
2750		fail:
#	Line 2050 | Line 2752 | static PyObject *_wrap_BossSession_showC
2752		}
2753
2754
2755	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_0(PyObject *self, PyObject *args) {
2755	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2756		PyObject *resultobj;
2757		BossSession *arg1 = (BossSession *) 0 ;
2758	<	SwigValueWrapper< std::vector<std::string > > result;
2758	>	std::vector<std::string > result;
2759		PyObject * obj0 = 0 ;
2760
2761		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
#	Line 2062 | Line 2764 | static PyObject *_wrap_BossSession_showP
2764		try {
2765		result = (arg1)->showProgramTypes();
2766
2767	+	}catch (const BossSchedFailure & e) {
2768	+	PyErr_SetString ( SchedulerError, e.what() );
2769	+	return NULL;
2770		}catch (const std::exception& e) {
2771	<	SWIG_exception(SWIG_RuntimeError, e.what());
2771	>	PyErr_SetString ( BossError, e.what() );
2772	>	return NULL;
2773		}
2774		}
2775		{
2776	<	std::vector<std::string > * resultptr;
2777	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2778	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2776	>	resultobj = PyTuple_New((&result)->size());
2777	>	for (unsigned int i=0; i<(&result)->size(); i++)
2778	>	PyTuple_SetItem(resultobj,i,
2779	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2780		}
2781		return resultobj;
2782		fail:
#	Line 2077 | Line 2784 | static PyObject *_wrap_BossSession_showP
2784		}
2785
2786
2787	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_0(PyObject *self, PyObject *args) {
2787	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2788		PyObject *resultobj;
2789		BossSession *arg1 = (BossSession *) 0 ;
2790	<	SwigValueWrapper< std::vector<std::string > > result;
2790	>	std::vector<std::string > result;
2791		PyObject * obj0 = 0 ;
2792
2793		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
#	Line 2089 | Line 2796 | static PyObject *_wrap_BossSession_showR
2796		try {
2797		result = (arg1)->showRTMon();
2798
2799	+	}catch (const BossSchedFailure & e) {
2800	+	PyErr_SetString ( SchedulerError, e.what() );
2801	+	return NULL;
2802		}catch (const std::exception& e) {
2803	<	SWIG_exception(SWIG_RuntimeError, e.what());
2803	>	PyErr_SetString ( BossError, e.what() );
2804	>	return NULL;
2805		}
2806		}
2807		{
2808	<	std::vector<std::string > * resultptr;
2809	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2810	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2808	>	resultobj = PyTuple_New((&result)->size());
2809	>	for (unsigned int i=0; i<(&result)->size(); i++)
2810	>	PyTuple_SetItem(resultobj,i,
2811	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2812		}
2813		return resultobj;
2814		fail:
#	Line 2104 | Line 2816 | static PyObject *_wrap_BossSession_showR
2816		}
2817
2818
2819	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_0(PyObject *self, PyObject *args) {
2819	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2820		PyObject *resultobj;
2821		BossSession *arg1 = (BossSession *) 0 ;
2822	<	SwigValueWrapper< std::vector<std::string > > result;
2822	>	std::vector<std::string > result;
2823		PyObject * obj0 = 0 ;
2824
2825		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
#	Line 2116 | Line 2828 | static PyObject *_wrap_BossSession_showS
2828		try {
2829		result = (arg1)->showSchedulers();
2830
2831	+	}catch (const BossSchedFailure & e) {
2832	+	PyErr_SetString ( SchedulerError, e.what() );
2833	+	return NULL;
2834		}catch (const std::exception& e) {
2835	<	SWIG_exception(SWIG_RuntimeError, e.what());
2835	>	PyErr_SetString ( BossError, e.what() );
2836	>	return NULL;
2837		}
2838		}
2839		{
2840	<	std::vector<std::string > * resultptr;
2841	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2842	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2840	>	resultobj = PyTuple_New((&result)->size());
2841	>	for (unsigned int i=0; i<(&result)->size(); i++)
2842	>	PyTuple_SetItem(resultobj,i,
2843	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2844		}
2845		return resultobj;
2846		fail:
#	Line 2143 | Line 2860 | static PyObject *_wrap_BossSession_defau
2860		try {
2861		result = (arg1)->defaultCHTool();
2862
2863	+	}catch (const BossSchedFailure & e) {
2864	+	PyErr_SetString ( SchedulerError, e.what() );
2865	+	return NULL;
2866		}catch (const std::exception& e) {
2867	<	SWIG_exception(SWIG_RuntimeError, e.what());
2867	>	PyErr_SetString ( BossError, e.what() );
2868	>	return NULL;
2869		}
2870		}
2871		{
#	Line 2168 | Line 2889 | static PyObject *_wrap_BossSession_defau
2889		try {
2890		result = (arg1)->defaultProgramType();
2891
2892	+	}catch (const BossSchedFailure & e) {
2893	+	PyErr_SetString ( SchedulerError, e.what() );
2894	+	return NULL;
2895		}catch (const std::exception& e) {
2896	<	SWIG_exception(SWIG_RuntimeError, e.what());
2896	>	PyErr_SetString ( BossError, e.what() );
2897	>	return NULL;
2898		}
2899		}
2900		{
#	Line 2193 | Line 2918 | static PyObject *_wrap_BossSession_defau
2918		try {
2919		result = (arg1)->defaultRTMon();
2920
2921	+	}catch (const BossSchedFailure & e) {
2922	+	PyErr_SetString ( SchedulerError, e.what() );
2923	+	return NULL;
2924		}catch (const std::exception& e) {
2925	<	SWIG_exception(SWIG_RuntimeError, e.what());
2925	>	PyErr_SetString ( BossError, e.what() );
2926	>	return NULL;
2927		}
2928		}
2929		{
#	Line 2218 | Line 2947 | static PyObject *_wrap_BossSession_defau
2947		try {
2948		result = (arg1)->defaultScheduler();
2949
2950	+	}catch (const BossSchedFailure & e) {
2951	+	PyErr_SetString ( SchedulerError, e.what() );
2952	+	return NULL;
2953		}catch (const std::exception& e) {
2954	<	SWIG_exception(SWIG_RuntimeError, e.what());
2954	>	PyErr_SetString ( BossError, e.what() );
2955	>	return NULL;
2956		}
2957		}
2958		{
#	Line 2243 | Line 2976 | static PyObject *_wrap_BossSession_versi
2976		try {
2977		result = (arg1)->version();
2978
2979	+	}catch (const BossSchedFailure & e) {
2980	+	PyErr_SetString ( SchedulerError, e.what() );
2981	+	return NULL;
2982		}catch (const std::exception& e) {
2983	<	SWIG_exception(SWIG_RuntimeError, e.what());
2983	>	PyErr_SetString ( BossError, e.what() );
2984	>	return NULL;
2985		}
2986		}
2987		{
#	Line 2268 | Line 3005 | static PyObject *_wrap_BossSession_clien
3005		try {
3006		result = (arg1)->clientID();
3007
3008	+	}catch (const BossSchedFailure & e) {
3009	+	PyErr_SetString ( SchedulerError, e.what() );
3010	+	return NULL;
3011		}catch (const std::exception& e) {
3012	<	SWIG_exception(SWIG_RuntimeError, e.what());
3012	>	PyErr_SetString ( BossError, e.what() );
3013	>	return NULL;
3014		}
3015		}
3016		{
#	Line 2299 | Line 3040 | static PyObject *_wrap_BossSession_showC
3040		try {
3041		result = (int)(arg1)->showConfigs(arg2);
3042
3043	+	}catch (const BossSchedFailure & e) {
3044	+	PyErr_SetString ( SchedulerError, e.what() );
3045	+	return NULL;
3046		}catch (const std::exception& e) {
3047	<	SWIG_exception(SWIG_RuntimeError, e.what());
3048	<	}
2305	<	}
2306	<	resultobj = PyInt_FromLong((long)result);
2307	<	return resultobj;
2308	<	fail:
2309	<	return NULL;
2310	<	}
2311	<
2312	<
2313	<	static PyObject *_wrap_BossSession_purgeTasks(PyObject *self, PyObject *args) {
2314	<	PyObject *resultobj;
2315	<	BossSession *arg1 = (BossSession *) 0 ;
2316	<	std::string *arg2 = 0 ;
2317	<	std::string *arg3 = 0 ;
2318	<	std::string *arg4 = 0 ;
2319	<	std::string const &arg5_defvalue = "0" ;
2320	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2321	<	int result;
2322	<	std::string temp2 ;
2323	<	std::string temp3 ;
2324	<	std::string temp4 ;
2325	<	std::string temp5 ;
2326	<	PyObject * obj0 = 0 ;
2327	<	PyObject * obj1 = 0 ;
2328	<	PyObject * obj2 = 0 ;
2329	<	PyObject * obj3 = 0 ;
2330	<	PyObject * obj4 = 0 ;
2331	<
2332	<	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossSession_purgeTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
2333	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2334	<	{
2335	<	if (PyString_Check(obj1)) {
2336	<	temp2 = std::string(PyString_AsString(obj1));
2337	<	arg2 = &temp2;
2338	<	}else {
2339	<	SWIG_exception(SWIG_TypeError, "string expected");
2340	<	}
2341	<	}
2342	<	{
2343	<	if (PyString_Check(obj2)) {
2344	<	temp3 = std::string(PyString_AsString(obj2));
2345	<	arg3 = &temp3;
2346	<	}else {
2347	<	SWIG_exception(SWIG_TypeError, "string expected");
2348	<	}
2349	<	}
2350	<	{
2351	<	if (PyString_Check(obj3)) {
2352	<	temp4 = std::string(PyString_AsString(obj3));
2353	<	arg4 = &temp4;
2354	<	}else {
2355	<	SWIG_exception(SWIG_TypeError, "string expected");
2356	<	}
2357	<	}
2358	<	if (obj4) {
2359	<	{
2360	<	if (PyString_Check(obj4)) {
2361	<	temp5 = std::string(PyString_AsString(obj4));
2362	<	arg5 = &temp5;
2363	<	}else {
2364	<	SWIG_exception(SWIG_TypeError, "string expected");
2365	<	}
2366	<	}
2367	<	}
2368	<	{
2369	<	try {
2370	<	result = (int)(arg1)->purgeTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
2371	<
2372	<	}catch (const std::exception& e) {
2373	<	SWIG_exception(SWIG_RuntimeError, e.what());
3047	>	PyErr_SetString ( BossError, e.what() );
3048	>	return NULL;
3049		}
3050		}
3051		resultobj = PyInt_FromLong((long)result);
#	Line 2422 | Line 3097 | static PyObject *_wrap_BossSession_RTupd
3097		try {
3098		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
3099
3100	+	}catch (const BossSchedFailure & e) {
3101	+	PyErr_SetString ( SchedulerError, e.what() );
3102	+	return NULL;
3103		}catch (const std::exception& e) {
3104	<	SWIG_exception(SWIG_RuntimeError, e.what());
3104	>	PyErr_SetString ( BossError, e.what() );
3105	>	return NULL;
3106		}
3107		}
3108		resultobj = PyInt_FromLong((long)result);
#	Line 2438 | Line 3117 | static PyObject *_wrap_BossSession_listM
3117		BossSession *arg1 = (BossSession *) 0 ;
3118		std::string *arg2 = 0 ;
3119		std::string *arg3 = 0 ;
3120	<	bool arg4 = (bool) false ;
3120	>	std::string const &arg4_defvalue = "" ;
3121	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3122		std::string const &arg5_defvalue = "" ;
3123		std::string *arg5 = (std::string *) &arg5_defvalue ;
3124	<	std::string const &arg6_defvalue = "" ;
3125	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
2446	<	std::string result;
3124	>	unsigned int arg6 = (unsigned int) 0 ;
3125	>	std::vector<std::string > result;
3126		std::string temp2 ;
3127		std::string temp3 ;
3128	+	std::string temp4 ;
3129		std::string temp5 ;
2450	–	std::string temp6 ;
3130		PyObject * obj0 = 0 ;
3131		PyObject * obj1 = 0 ;
3132		PyObject * obj2 = 0 ;
#	Line 2474 | Line 3153 | static PyObject *_wrap_BossSession_listM
3153		}
3154		}
3155		if (obj3) {
3156	<	arg4 = PyInt_AsLong(obj3) ? true : false;
3157	<	if (PyErr_Occurred()) SWIG_fail;
3156	>	{
3157	>	if (PyString_Check(obj3)) {
3158	>	temp4 = std::string(PyString_AsString(obj3));
3159	>	arg4 = &temp4;
3160	>	}else {
3161	>	SWIG_exception(SWIG_TypeError, "string expected");
3162	>	}
3163	>	}
3164		}
3165		if (obj4) {
3166		{
#	Line 2488 | Line 3173 | static PyObject *_wrap_BossSession_listM
3173		}
3174		}
3175		if (obj5) {
3176	<	{
3177	<	if (PyString_Check(obj5)) {
2493	<	temp6 = std::string(PyString_AsString(obj5));
2494	<	arg6 = &temp6;
2495	<	}else {
2496	<	SWIG_exception(SWIG_TypeError, "string expected");
2497	<	}
2498	<	}
3176	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3177	>	if (PyErr_Occurred()) SWIG_fail;
3178		}
3179		{
3180		try {
3181	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
3181	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3182
3183	+	}catch (const BossSchedFailure & e) {
3184	+	PyErr_SetString ( SchedulerError, e.what() );
3185	+	return NULL;
3186		}catch (const std::exception& e) {
3187	<	SWIG_exception(SWIG_RuntimeError, e.what());
3187	>	PyErr_SetString ( BossError, e.what() );
3188	>	return NULL;
3189		}
3190		}
3191		{
3192	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3192	>	resultobj = PyTuple_New((&result)->size());
3193	>	for (unsigned int i=0; i<(&result)->size(); i++)
3194	>	PyTuple_SetItem(resultobj,i,
3195	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3196		}
3197		return resultobj;
3198		fail:
#	Line 2514 | Line 3200 | static PyObject *_wrap_BossSession_listM
3200		}
3201
3202
3203	<	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3203	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3204		PyObject *resultobj;
3205		BossSession *arg1 = (BossSession *) 0 ;
3206		int arg2 = (int) SCHEDULED ;
#	Line 2528 | Line 3214 | static PyObject *_wrap_BossSession_sched
3214		std::string arg7 = (std::string) "" ;
3215		std::string arg8 = (std::string) "" ;
3216		std::string arg9 = (std::string) "" ;
3217	+	unsigned int arg10 = (unsigned int) 0 ;
3218	+	bool arg11 = (bool) false ;
3219		std::string temp3 ;
3220		std::string temp4 ;
3221		std::string temp5 ;
#	Line 2539 | Line 3227 | static PyObject *_wrap_BossSession_sched
3227		PyObject * obj6 = 0 ;
3228		PyObject * obj7 = 0 ;
3229		PyObject * obj8 = 0 ;
3230	+	PyObject * obj9 = 0 ;
3231	+	PyObject * obj10 = 0 ;
3232
3233	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3233	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3234		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3235		if (obj2) {
3236		{
#	Line 2604 | Line 3294 | static PyObject *_wrap_BossSession_sched
3294		SWIG_exception(SWIG_TypeError, "string expected");
3295		}
3296		}
3297	+	if (obj9) {
3298	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3299	+	if (PyErr_Occurred()) SWIG_fail;
3300	+	}
3301	+	if (obj10) {
3302	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3303	+	if (PyErr_Occurred()) SWIG_fail;
3304	+	}
3305		{
3306		try {
3307	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3307	>	(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3308
3309	+	}catch (const BossSchedFailure & e) {
3310	+	PyErr_SetString ( SchedulerError, e.what() );
3311	+	return NULL;
3312		}catch (const std::exception& e) {
3313	<	SWIG_exception(SWIG_RuntimeError, e.what());
3313	>	PyErr_SetString ( BossError, e.what() );
3314	>	return NULL;
3315		}
3316		}
3317		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2619 | Line 3321 | static PyObject *_wrap_BossSession_sched
3321		}
3322
3323
3324	<	static PyObject *_wrap_BossSession_queryPrint(PyObject *self, PyObject *args) {
3324	>	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3325		PyObject *resultobj;
3326		BossSession *arg1 = (BossSession *) 0 ;
3327	<	SwigValueWrapper< std::vector<BossJob * > > arg2 ;
3328	<	std::ostream &arg3_defvalue = std::cout ;
3329	<	std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
2628	<	jobStates const &arg4_defvalue = SCHEDULED ;
2629	<	jobStates *arg4 = (jobStates *) &arg4_defvalue ;
2630	<	printOption const &arg5_defvalue = NORMAL ;
2631	<	printOption *arg5 = (printOption *) &arg5_defvalue ;
2632	<	std::string const &arg6_defvalue = "" ;
2633	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
2634	<	std::vector<BossJob * > *argp2 ;
2635	<	std::string temp6 ;
3327	>	std::string *arg2 = 0 ;
3328	>	unsigned int result;
3329	>	std::string temp2 ;
3330		PyObject * obj0 = 0 ;
3331		PyObject * obj1 = 0 ;
2638	–	PyObject * obj2 = 0 ;
2639	–	PyObject * obj3 = 0 ;
2640	–	PyObject * obj4 = 0 ;
2641	–	PyObject * obj5 = 0 ;
3332
3333	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossSession_queryPrint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3333	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3334		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3335	<	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3336	<	arg2 = *argp2;
3337	<	if (obj2) {
3338	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3339	<	if (arg3 == NULL) {
3340	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3335	>	{
3336	>	if (PyString_Check(obj1)) {
3337	>	temp2 = std::string(PyString_AsString(obj1));
3338	>	arg2 = &temp2;
3339	>	}else {
3340	>	SWIG_exception(SWIG_TypeError, "string expected");
3341		}
3342		}
3343	<	if (obj3) {
3344	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3345	<	if (arg4 == NULL) {
3346	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3343	>	{
3344	>	try {
3345	>	result = (unsigned int)(arg1)->getTasksByName((std::string const &)*arg2);
3346	>
3347	>	}catch (const BossSchedFailure & e) {
3348	>	PyErr_SetString ( SchedulerError, e.what() );
3349	>	return NULL;
3350	>	}catch (const std::exception& e) {
3351	>	PyErr_SetString ( BossError, e.what() );
3352	>	return NULL;
3353		}
3354		}
3355	<	if (obj4) {
3356	<	if ((SWIG_ConvertPtr(obj4,(void **) &arg5, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3357	<	if (arg5 == NULL) {
3358	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3355	>	resultobj = PyInt_FromLong((long)result);
3356	>	return resultobj;
3357	>	fail:
3358	>	return NULL;
3359	>	}
3360	>
3361	>
3362	>	static PyObject *_wrap_BossSession_getTasksByTaskInfo(PyObject *self, PyObject *args) {
3363	>	PyObject *resultobj;
3364	>	BossSession *arg1 = (BossSession *) 0 ;
3365	>	std::string *arg2 = 0 ;
3366	>	unsigned int result;
3367	>	std::string temp2 ;
3368	>	PyObject * obj0 = 0 ;
3369	>	PyObject * obj1 = 0 ;
3370	>
3371	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByTaskInfo",&obj0,&obj1)) goto fail;
3372	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3373	>	{
3374	>	if (PyString_Check(obj1)) {
3375	>	temp2 = std::string(PyString_AsString(obj1));
3376	>	arg2 = &temp2;
3377	>	}else {
3378	>	SWIG_exception(SWIG_TypeError, "string expected");
3379		}
3380		}
3381	<	if (obj5) {
3382	<	{
3383	<	if (PyString_Check(obj5)) {
3384	<	temp6 = std::string(PyString_AsString(obj5));
3385	<	arg6 = &temp6;
3386	<	}else {
3387	<	SWIG_exception(SWIG_TypeError, "string expected");
3388	<	}
3381	>	{
3382	>	try {
3383	>	result = (unsigned int)(arg1)->getTasksByTaskInfo((std::string const &)*arg2);
3384	>
3385	>	}catch (const BossSchedFailure & e) {
3386	>	PyErr_SetString ( SchedulerError, e.what() );
3387	>	return NULL;
3388	>	}catch (const std::exception& e) {
3389	>	PyErr_SetString ( BossError, e.what() );
3390	>	return NULL;
3391	>	}
3392	>	}
3393	>	resultobj = PyInt_FromLong((long)result);
3394	>	return resultobj;
3395	>	fail:
3396	>	return NULL;
3397	>	}
3398	>
3399	>
3400	>	static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3401	>	PyObject *resultobj;
3402	>	BossSession *arg1 = (BossSession *) 0 ;
3403	>	std::string *arg2 = 0 ;
3404	>	unsigned int result;
3405	>	std::string temp2 ;
3406	>	PyObject * obj0 = 0 ;
3407	>	PyObject * obj1 = 0 ;
3408	>
3409	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3410	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3411	>	{
3412	>	if (PyString_Check(obj1)) {
3413	>	temp2 = std::string(PyString_AsString(obj1));
3414	>	arg2 = &temp2;
3415	>	}else {
3416	>	SWIG_exception(SWIG_TypeError, "string expected");
3417		}
3418		}
3419		{
3420		try {
3421	<	(arg1)->queryPrint(arg2,*arg3,(jobStates const &)*arg4,(printOption const &)*arg5,(std::string const &)*arg6);
3421	>	result = (unsigned int)(arg1)->getTasksByJobName((std::string const &)*arg2);
3422
3423	+	}catch (const BossSchedFailure & e) {
3424	+	PyErr_SetString ( SchedulerError, e.what() );
3425	+	return NULL;
3426		}catch (const std::exception& e) {
3427	<	SWIG_exception(SWIG_RuntimeError, e.what());
3427	>	PyErr_SetString ( BossError, e.what() );
3428	>	return NULL;
3429		}
3430		}
3431	<	Py_INCREF(Py_None); resultobj = Py_None;
3431	>	resultobj = PyInt_FromLong((long)result);
3432		return resultobj;
3433		fail:
3434		return NULL;
3435		}
3436
3437
3438	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3438	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3439		PyObject *resultobj;
3440		BossSession *arg1 = (BossSession *) 0 ;
3441	<	std::string const &arg2_defvalue = "all" ;
3442	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3443	<	std::string const &arg3_defvalue = "" ;
3444	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3441	>	std::vector<std::string > *arg2 = 0 ;
3442	>	PyObject *result;
3443	>	PyObject * obj0 = 0 ;
3444	>	PyObject * obj1 = 0 ;
3445	>
3446	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3447	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3448	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3449	>	if (arg2 == NULL) {
3450	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3451	>	}
3452	>	{
3453	>	try {
3454	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3455	>
3456	>	}catch (const BossSchedFailure & e) {
3457	>	PyErr_SetString ( SchedulerError, e.what() );
3458	>	return NULL;
3459	>	}catch (const std::exception& e) {
3460	>	PyErr_SetString ( BossError, e.what() );
3461	>	return NULL;
3462	>	}
3463	>	}
3464	>	resultobj = result;
3465	>	return resultobj;
3466	>	fail:
3467	>	return NULL;
3468	>	}
3469	>
3470	>
3471	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3472	>	PyObject *resultobj;
3473	>	BossSession *arg1 = (BossSession *) 0 ;
3474	>	PyObject *result;
3475	>	PyObject * obj0 = 0 ;
3476	>
3477	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3478	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3479	>	{
3480	>	try {
3481	>	result = (PyObject *)BossSession_CHTools(arg1);
3482	>
3483	>	}catch (const BossSchedFailure & e) {
3484	>	PyErr_SetString ( SchedulerError, e.what() );
3485	>	return NULL;
3486	>	}catch (const std::exception& e) {
3487	>	PyErr_SetString ( BossError, e.what() );
3488	>	return NULL;
3489	>	}
3490	>	}
3491	>	resultobj = result;
3492	>	return resultobj;
3493	>	fail:
3494	>	return NULL;
3495	>	}
3496	>
3497	>
3498	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3499	>	PyObject *resultobj;
3500	>	BossSession *arg1 = (BossSession *) 0 ;
3501	>	PyObject *result;
3502	>	PyObject * obj0 = 0 ;
3503	>
3504	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3505	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3506	>	{
3507	>	try {
3508	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3509	>
3510	>	}catch (const BossSchedFailure & e) {
3511	>	PyErr_SetString ( SchedulerError, e.what() );
3512	>	return NULL;
3513	>	}catch (const std::exception& e) {
3514	>	PyErr_SetString ( BossError, e.what() );
3515	>	return NULL;
3516	>	}
3517	>	}
3518	>	resultobj = result;
3519	>	return resultobj;
3520	>	fail:
3521	>	return NULL;
3522	>	}
3523	>
3524	>
3525	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3526	>	PyObject *resultobj;
3527	>	BossSession *arg1 = (BossSession *) 0 ;
3528	>	PyObject *result;
3529	>	PyObject * obj0 = 0 ;
3530	>
3531	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3532	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3533	>	{
3534	>	try {
3535	>	result = (PyObject *)BossSession_RTMons(arg1);
3536	>
3537	>	}catch (const BossSchedFailure & e) {
3538	>	PyErr_SetString ( SchedulerError, e.what() );
3539	>	return NULL;
3540	>	}catch (const std::exception& e) {
3541	>	PyErr_SetString ( BossError, e.what() );
3542	>	return NULL;
3543	>	}
3544	>	}
3545	>	resultobj = result;
3546	>	return resultobj;
3547	>	fail:
3548	>	return NULL;
3549	>	}
3550	>
3551	>
3552	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3553	>	PyObject *resultobj;
3554	>	BossSession *arg1 = (BossSession *) 0 ;
3555	>	PyObject *result;
3556	>	PyObject * obj0 = 0 ;
3557	>
3558	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3559	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3560	>	{
3561	>	try {
3562	>	result = (PyObject *)BossSession_schedulers(arg1);
3563	>
3564	>	}catch (const BossSchedFailure & e) {
3565	>	PyErr_SetString ( SchedulerError, e.what() );
3566	>	return NULL;
3567	>	}catch (const std::exception& e) {
3568	>	PyErr_SetString ( BossError, e.what() );
3569	>	return NULL;
3570	>	}
3571	>	}
3572	>	resultobj = result;
3573	>	return resultobj;
3574	>	fail:
3575	>	return NULL;
3576	>	}
3577	>
3578	>
3579	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3580	>	PyObject *resultobj;
3581	>	BossSession *arg1 = (BossSession *) 0 ;
3582	>	std::string *arg2 = 0 ;
3583	>	std::string *arg3 = 0 ;
3584		std::string const &arg4_defvalue = "" ;
3585		std::string *arg4 = (std::string *) &arg4_defvalue ;
3586		std::string const &arg5_defvalue = "" ;
3587		std::string *arg5 = (std::string *) &arg5_defvalue ;
3588	<	SwigValueWrapper< std::vector<std::string > > result;
3588	>	unsigned int arg6 = (unsigned int) 0 ;
3589	>	PyObject *result;
3590		std::string temp2 ;
3591		std::string temp3 ;
3592		std::string temp4 ;
#	Line 2708 | Line 3596 | static PyObject *_wrap_BossSession_selec
3596		PyObject * obj2 = 0 ;
3597		PyObject * obj3 = 0 ;
3598		PyObject * obj4 = 0 ;
3599	+	PyObject * obj5 = 0 ;
3600
3601	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3601	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3602		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3603	<	if (obj1) {
3603	>	{
3604	>	if (PyString_Check(obj1)) {
3605	>	temp2 = std::string(PyString_AsString(obj1));
3606	>	arg2 = &temp2;
3607	>	}else {
3608	>	SWIG_exception(SWIG_TypeError, "string expected");
3609	>	}
3610	>	}
3611	>	{
3612	>	if (PyString_Check(obj2)) {
3613	>	temp3 = std::string(PyString_AsString(obj2));
3614	>	arg3 = &temp3;
3615	>	}else {
3616	>	SWIG_exception(SWIG_TypeError, "string expected");
3617	>	}
3618	>	}
3619	>	if (obj3) {
3620		{
3621	<	if (PyString_Check(obj1)) {
3622	<	temp2 = std::string(PyString_AsString(obj1));
3623	<	arg2 = &temp2;
3621	>	if (PyString_Check(obj3)) {
3622	>	temp4 = std::string(PyString_AsString(obj3));
3623	>	arg4 = &temp4;
3624	>	}else {
3625	>	SWIG_exception(SWIG_TypeError, "string expected");
3626	>	}
3627	>	}
3628	>	}
3629	>	if (obj4) {
3630	>	{
3631	>	if (PyString_Check(obj4)) {
3632	>	temp5 = std::string(PyString_AsString(obj4));
3633	>	arg5 = &temp5;
3634		}else {
3635		SWIG_exception(SWIG_TypeError, "string expected");
3636		}
3637		}
3638		}
3639	+	if (obj5) {
3640	+	arg6 = (unsigned int) PyInt_AsLong(obj5);
3641	+	if (PyErr_Occurred()) SWIG_fail;
3642	+	}
3643	+	{
3644	+	try {
3645	+	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3646	+
3647	+	}catch (const BossSchedFailure & e) {
3648	+	PyErr_SetString ( SchedulerError, e.what() );
3649	+	return NULL;
3650	+	}catch (const std::exception& e) {
3651	+	PyErr_SetString ( BossError, e.what() );
3652	+	return NULL;
3653	+	}
3654	+	}
3655	+	resultobj = result;
3656	+	return resultobj;
3657	+	fail:
3658	+	return NULL;
3659	+	}
3660	+
3661	+
3662	+	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3663	+	PyObject *resultobj;
3664	+	BossSession *arg1 = (BossSession *) 0 ;
3665	+	int arg2 = (int) SCHEDULED ;
3666	+	std::string const &arg3_defvalue = "all" ;
3667	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
3668	+	std::string const &arg4_defvalue = "all" ;
3669	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
3670	+	std::string const &arg5_defvalue = "" ;
3671	+	std::string *arg5 = (std::string *) &arg5_defvalue ;
3672	+	std::string arg6 = (std::string) "" ;
3673	+	std::string arg7 = (std::string) "" ;
3674	+	std::string arg8 = (std::string) "" ;
3675	+	std::string arg9 = (std::string) "" ;
3676	+	unsigned int arg10 = (unsigned int) 0 ;
3677	+	bool arg11 = (bool) false ;
3678	+	std::string temp3 ;
3679	+	std::string temp4 ;
3680	+	std::string temp5 ;
3681	+	PyObject * obj0 = 0 ;
3682	+	PyObject * obj2 = 0 ;
3683	+	PyObject * obj3 = 0 ;
3684	+	PyObject * obj4 = 0 ;
3685	+	PyObject * obj5 = 0 ;
3686	+	PyObject * obj6 = 0 ;
3687	+	PyObject * obj7 = 0 ;
3688	+	PyObject * obj8 = 0 ;
3689	+	PyObject * obj9 = 0 ;
3690	+	PyObject * obj10 = 0 ;
3691	+
3692	+	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3693	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3694		if (obj2) {
3695		{
3696		if (PyString_Check(obj2)) {
#	Line 2751 | Line 3721 | static PyObject *_wrap_BossSession_selec
3721		}
3722		}
3723		}
3724	+	if (obj5) {
3725	+	{
3726	+	if (PyString_Check(obj5))
3727	+	arg6 = std::string(PyString_AsString(obj5));
3728	+	else
3729	+	SWIG_exception(SWIG_TypeError, "string expected");
3730	+	}
3731	+	}
3732	+	if (obj6) {
3733	+	{
3734	+	if (PyString_Check(obj6))
3735	+	arg7 = std::string(PyString_AsString(obj6));
3736	+	else
3737	+	SWIG_exception(SWIG_TypeError, "string expected");
3738	+	}
3739	+	}
3740	+	if (obj7) {
3741	+	{
3742	+	if (PyString_Check(obj7))
3743	+	arg8 = std::string(PyString_AsString(obj7));
3744	+	else
3745	+	SWIG_exception(SWIG_TypeError, "string expected");
3746	+	}
3747	+	}
3748	+	if (obj8) {
3749	+	{
3750	+	if (PyString_Check(obj8))
3751	+	arg9 = std::string(PyString_AsString(obj8));
3752	+	else
3753	+	SWIG_exception(SWIG_TypeError, "string expected");
3754	+	}
3755	+	}
3756	+	if (obj9) {
3757	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3758	+	if (PyErr_Occurred()) SWIG_fail;
3759	+	}
3760	+	if (obj10) {
3761	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3762	+	if (PyErr_Occurred()) SWIG_fail;
3763	+	}
3764		{
3765		try {
3766	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3766	>	BossSession_schedulerQuery(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3767
3768	+	}catch (const BossSchedFailure & e) {
3769	+	PyErr_SetString ( SchedulerError, e.what() );
3770	+	return NULL;
3771		}catch (const std::exception& e) {
3772	<	SWIG_exception(SWIG_RuntimeError, e.what());
3772	>	PyErr_SetString ( BossError, e.what() );
3773	>	return NULL;
3774		}
3775		}
3776	<	{
2763	<	std::vector<std::string > * resultptr;
2764	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2765	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2766	<	}
3776	>	Py_INCREF(Py_None); resultobj = Py_None;
3777		return resultobj;
3778		fail:
3779		return NULL;
#	Line 2777 | Line 3787 | static PyObject * BossSession_swigregist
3787		Py_INCREF(obj);
3788		return Py_BuildValue((char *)"");
3789		}
2780	–	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
2781	–	PyObject *resultobj;
2782	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
2783	–	char *arg2 ;
2784	–	PyObject * obj0 = 0 ;
2785	–
2786	–	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
2787	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2788	–	{
2789	–	if (arg2) {
2790	–	arg1->key = (char const *) (new char[strlen(arg2)+1]);
2791	–	strcpy((char *) arg1->key,arg2);
2792	–	}else {
2793	–	arg1->key = 0;
2794	–	}
2795	–	}
2796	–	Py_INCREF(Py_None); resultobj = Py_None;
2797	–	return resultobj;
2798	–	fail:
2799	–	return NULL;
2800	–	}
2801	–
2802	–
2803	–	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
2804	–	PyObject *resultobj;
2805	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
2806	–	char *result;
2807	–	PyObject * obj0 = 0 ;
2808	–
2809	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
2810	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2811	–	result = (char *) ((arg1)->key);
2812	–
2813	–	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
2814	–	return resultobj;
2815	–	fail:
2816	–	return NULL;
2817	–	}
2818	–
2819	–
3790		static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3791		PyObject *resultobj;
3792		char *arg1 ;
#	Line 2827 | Line 3797 | static PyObject *_wrap_new_BossTaskExcep
3797		try {
3798		result = (BossTaskException *)new BossTaskException((char const *)arg1);
3799
3800	+	}catch (const BossSchedFailure & e) {
3801	+	PyErr_SetString ( SchedulerError, e.what() );
3802	+	return NULL;
3803		}catch (const std::exception& e) {
3804	<	SWIG_exception(SWIG_RuntimeError, e.what());
3804	>	PyErr_SetString ( BossError, e.what() );
3805	>	return NULL;
3806		}
3807		}
3808		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
#	Line 2838 | Line 3812 | static PyObject *_wrap_new_BossTaskExcep
3812		}
3813
3814
2841	–	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
2842	–	PyObject *resultobj;
2843	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
2844	–	char *result;
2845	–	PyObject * obj0 = 0 ;
2846	–
2847	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
2848	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2849	–	{
2850	–	try {
2851	–	result = (char *)((BossTaskException const *)arg1)->what();
2852	–
2853	–	}catch (const std::exception& e) {
2854	–	SWIG_exception(SWIG_RuntimeError, e.what());
2855	–	}
2856	–	}
2857	–	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
2858	–	return resultobj;
2859	–	fail:
2860	–	return NULL;
2861	–	}
2862	–
2863	–
3815		static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3816		PyObject *resultobj;
3817		BossTaskException *arg1 = (BossTaskException *) 0 ;
#	Line 2872 | Line 3823 | static PyObject *_wrap_delete_BossTaskEx
3823		try {
3824		delete arg1;
3825
3826	+	}catch (const BossSchedFailure & e) {
3827	+	PyErr_SetString ( SchedulerError, e.what() );
3828	+	return NULL;
3829		}catch (const std::exception& e) {
3830	<	SWIG_exception(SWIG_RuntimeError, e.what());
3830	>	PyErr_SetString ( BossError, e.what() );
3831	>	return NULL;
3832		}
3833		}
3834		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2890 | Line 3845 | static PyObject * BossTaskException_swig
3845		Py_INCREF(obj);
3846		return Py_BuildValue((char *)"");
3847		}
3848	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3848	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3849		PyObject *resultobj;
3850		BossTask *arg1 = (BossTask *) 0 ;
3851	<	PyObject *arg2 = (PyObject *) 0 ;
2897	<	BossAttributeContainer *arg3 = 0 ;
2898	<	PyObject *result;
3851	>	BossTask::job_iterator result;
3852		PyObject * obj0 = 0 ;
2900	–	PyObject * obj1 = 0 ;
2901	–	PyObject * obj2 = 0 ;
3853
3854	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3854	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3855		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2905	–	arg2 = obj1;
2906	–	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2907	–	if (arg3 == NULL) {
2908	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2909	–	}
3856		{
3857		try {
3858	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3858	>	result = ((BossTask const *)arg1)->job_begin();
3859
3860	+	}catch (const BossSchedFailure & e) {
3861	+	PyErr_SetString ( SchedulerError, e.what() );
3862	+	return NULL;
3863		}catch (const std::exception& e) {
3864	<	SWIG_exception(SWIG_RuntimeError, e.what());
3864	>	PyErr_SetString ( BossError, e.what() );
3865	>	return NULL;
3866		}
3867		}
3868	<	resultobj = result;
3868	>	{
3869	>	BossTask::job_iterator * resultptr;
3870	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3871	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3872	>	}
3873		return resultobj;
3874		fail:
3875		return NULL;
3876		}
3877
3878
3879	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3879	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3880		PyObject *resultobj;
3881		BossTask *arg1 = (BossTask *) 0 ;
3882	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
2929	<	PyObject *result;
3882	>	BossTask::job_iterator result;
3883		PyObject * obj0 = 0 ;
2931	–	PyObject * obj1 = 0 ;
3884
3885	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3885	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3886		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2935	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2936	–	if (arg2 == NULL) {
2937	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2938	–	}
3887		{
3888		try {
3889	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3889	>	result = ((BossTask const *)arg1)->job_end();
3890
3891	+	}catch (const BossSchedFailure & e) {
3892	+	PyErr_SetString ( SchedulerError, e.what() );
3893	+	return NULL;
3894		}catch (const std::exception& e) {
3895	<	SWIG_exception(SWIG_RuntimeError, e.what());
3895	>	PyErr_SetString ( BossError, e.what() );
3896	>	return NULL;
3897		}
3898		}
3899	<	resultobj = result;
3899	>	{
3900	>	BossTask::job_iterator * resultptr;
3901	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3902	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3903	>	}
3904		return resultobj;
3905		fail:
3906		return NULL;
3907		}
3908
3909
3910	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3910	>	static PyObject *_wrap_BossTask_jobsInMemory(PyObject *self, PyObject *args) {
3911		PyObject *resultobj;
3912		BossTask *arg1 = (BossTask *) 0 ;
3913	<	PyObject *result;
3913	>	unsigned int result;
3914		PyObject * obj0 = 0 ;
3915
3916	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3916	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsInMemory",&obj0)) goto fail;
3917		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3918		{
3919		try {
3920	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3920	>	result = (unsigned int)((BossTask const *)arg1)->jobsInMemory();
3921
3922	+	}catch (const BossSchedFailure & e) {
3923	+	PyErr_SetString ( SchedulerError, e.what() );
3924	+	return NULL;
3925		}catch (const std::exception& e) {
3926	<	SWIG_exception(SWIG_RuntimeError, e.what());
3926	>	PyErr_SetString ( BossError, e.what() );
3927	>	return NULL;
3928		}
3929		}
3930	<	resultobj = result;
3930	>	resultobj = PyInt_FromLong((long)result);
3931		return resultobj;
3932		fail:
3933		return NULL;
3934		}
3935
3936
3937	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3938	<	int argc;
3939	<	PyObject *argv[2];
3940	<	int ii;
3937	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3938	>	PyObject *resultobj;
3939	>	BossTask *arg1 = (BossTask *) 0 ;
3940	>	BossJob *arg2 = (BossJob *) 0 ;
3941	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3942	>	PyObject * obj0 = 0 ;
3943	>	PyObject * obj1 = 0 ;
3944
3945	<	argc = PyObject_Length(args);
3946	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3947	<	argv[ii] = PyTuple_GetItem(args,ii);
3948	<	}
3949	<	if (argc == 1) {
3950	<	int _v;
3951	<	{
3952	<	void *ptr;
3953	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3954	<	_v = 0;
3955	<	PyErr_Clear();
3956	<	}else {
3957	<	_v = 1;
2995	<	}
2996	<	}
2997	<	if (_v) {
2998	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
3945	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3946	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3947	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3948	>	{
3949	>	try {
3950	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
3951	>
3952	>	}catch (const BossSchedFailure & e) {
3953	>	PyErr_SetString ( SchedulerError, e.what() );
3954	>	return NULL;
3955	>	}catch (const std::exception& e) {
3956	>	PyErr_SetString ( BossError, e.what() );
3957	>	return NULL;
3958		}
3959		}
3960	<
3961	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3960	>	{
3961	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3962	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3963	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3964	>	}
3965	>	return resultobj;
3966	>	fail:
3967		return NULL;
3968		}
3969
3970
3971	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3971	>	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
3972		PyObject *resultobj;
3973		BossTask *arg1 = (BossTask *) 0 ;
3974	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3975	<	PyObject *result;
3974	>	BossJob *arg2 = (BossJob *) 0 ;
3975	>	std::string *arg3 = 0 ;
3976	>	BossProgram result;
3977	>	std::string temp3 ;
3978		PyObject * obj0 = 0 ;
3979		PyObject * obj1 = 0 ;
3980	+	PyObject * obj2 = 0 ;
3981
3982	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3982	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
3983		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3984	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3985	<	if (arg2 == NULL) {
3986	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3984	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3985	>	{
3986	>	if (PyString_Check(obj2)) {
3987	>	temp3 = std::string(PyString_AsString(obj2));
3988	>	arg3 = &temp3;
3989	>	}else {
3990	>	SWIG_exception(SWIG_TypeError, "string expected");
3991	>	}
3992		}
3993		{
3994		try {
3995	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3995	>	result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
3996
3997	+	}catch (const BossSchedFailure & e) {
3998	+	PyErr_SetString ( SchedulerError, e.what() );
3999	+	return NULL;
4000		}catch (const std::exception& e) {
4001	<	SWIG_exception(SWIG_RuntimeError, e.what());
4001	>	PyErr_SetString ( BossError, e.what() );
4002	>	return NULL;
4003		}
4004		}
4005	<	resultobj = result;
4005	>	{
4006	>	BossProgram * resultptr;
4007	>	resultptr = new BossProgram((BossProgram &) result);
4008	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4009	>	}
4010		return resultobj;
4011		fail:
4012		return NULL;
4013		}
4014
4015
4016	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
4016	>	static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4017		PyObject *resultobj;
4018		BossTask *arg1 = (BossTask *) 0 ;
4019	<	std::string *arg2 = 0 ;
4020	<	PyObject *result;
4021	<	std::string temp2 ;
4019	>	BossJob *arg2 = (BossJob *) 0 ;
4020	>	std::string *arg3 = 0 ;
4021	>	BossProgramExec result;
4022	>	std::string temp3 ;
4023		PyObject * obj0 = 0 ;
4024		PyObject * obj1 = 0 ;
4025	+	PyObject * obj2 = 0 ;
4026
4027	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
4027	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4028		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4029	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4030		{
4031	<	if (PyString_Check(obj1)) {
4032	<	temp2 = std::string(PyString_AsString(obj1));
4033	<	arg2 = &temp2;
4031	>	if (PyString_Check(obj2)) {
4032	>	temp3 = std::string(PyString_AsString(obj2));
4033	>	arg3 = &temp3;
4034		}else {
4035		SWIG_exception(SWIG_TypeError, "string expected");
4036		}
4037		}
4038		{
4039		try {
4040	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
4040	>	result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4041
4042	+	}catch (const BossSchedFailure & e) {
4043	+	PyErr_SetString ( SchedulerError, e.what() );
4044	+	return NULL;
4045		}catch (const std::exception& e) {
4046	<	SWIG_exception(SWIG_RuntimeError, e.what());
4046	>	PyErr_SetString ( BossError, e.what() );
4047	>	return NULL;
4048		}
4049		}
4050	<	resultobj = result;
4050	>	{
4051	>	BossProgramExec * resultptr;
4052	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4053	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4054	>	}
4055		return resultobj;
4056		fail:
4057		return NULL;
#	Line 3079 | Line 4070 | static PyObject *_wrap_new_BossTask__SWI
4070		try {
4071		result = (BossTask *)new BossTask(arg1);
4072
4073	+	}catch (const BossSchedFailure & e) {
4074	+	PyErr_SetString ( SchedulerError, e.what() );
4075	+	return NULL;
4076		}catch (const std::exception& e) {
4077	<	SWIG_exception(SWIG_RuntimeError, e.what());
4077	>	PyErr_SetString ( BossError, e.what() );
4078	>	return NULL;
4079		}
4080		}
4081		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3113 | Line 4108 | static PyObject *_wrap_new_BossTask__SWI
4108		try {
4109		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
4110
4111	+	}catch (const BossSchedFailure & e) {
4112	+	PyErr_SetString ( SchedulerError, e.what() );
4113	+	return NULL;
4114		}catch (const std::exception& e) {
4115	<	SWIG_exception(SWIG_RuntimeError, e.what());
4115	>	PyErr_SetString ( BossError, e.what() );
4116	>	return NULL;
4117		}
4118		}
4119		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3135 | Line 4134 | static PyObject *_wrap_delete_BossTask(P
4134		try {
4135		delete arg1;
4136
4137	+	}catch (const BossSchedFailure & e) {
4138	+	PyErr_SetString ( SchedulerError, e.what() );
4139	+	return NULL;
4140		}catch (const std::exception& e) {
4141	<	SWIG_exception(SWIG_RuntimeError, e.what());
4141	>	PyErr_SetString ( BossError, e.what() );
4142	>	return NULL;
4143		}
4144		}
4145		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3161 | Line 4164 | static PyObject *_wrap_new_BossTask__SWI
4164		try {
4165		result = (BossTask *)new BossTask((BossTask const &)*arg1);
4166
4167	+	}catch (const BossSchedFailure & e) {
4168	+	PyErr_SetString ( SchedulerError, e.what() );
4169	+	return NULL;
4170		}catch (const std::exception& e) {
4171	<	SWIG_exception(SWIG_RuntimeError, e.what());
4171	>	PyErr_SetString ( BossError, e.what() );
4172	>	return NULL;
4173		}
4174		}
4175		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3252 | Line 4259 | static PyObject *_wrap_BossTask_id(PyObj
4259		result = (std::string *) &_result_ref;
4260		}
4261
4262	+	}catch (const BossSchedFailure & e) {
4263	+	PyErr_SetString ( SchedulerError, e.what() );
4264	+	return NULL;
4265		}catch (const std::exception& e) {
4266	<	SWIG_exception(SWIG_RuntimeError, e.what());
4266	>	PyErr_SetString ( BossError, e.what() );
4267	>	return NULL;
4268		}
4269		}
4270		{
#	Line 3280 | Line 4291 | static PyObject *_wrap_BossTask_name(PyO
4291		result = (std::string *) &_result_ref;
4292		}
4293
4294	+	}catch (const BossSchedFailure & e) {
4295	+	PyErr_SetString ( SchedulerError, e.what() );
4296	+	return NULL;
4297		}catch (const std::exception& e) {
4298	<	SWIG_exception(SWIG_RuntimeError, e.what());
4298	>	PyErr_SetString ( BossError, e.what() );
4299	>	return NULL;
4300		}
4301		}
4302		{
#	Line 3293 | Line 4308 | static PyObject *_wrap_BossTask_name(PyO
4308		}
4309
4310
4311	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
4311	>	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4312		PyObject *resultobj;
4313		BossTask *arg1 = (BossTask *) 0 ;
4314	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4314	>	std::string *arg2 = 0 ;
4315	>	BossChain result;
4316	>	std::string temp2 ;
4317		PyObject * obj0 = 0 ;
4318	+	PyObject * obj1 = 0 ;
4319
4320	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4320	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4321		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4322		{
4323	+	if (PyString_Check(obj1)) {
4324	+	temp2 = std::string(PyString_AsString(obj1));
4325	+	arg2 = &temp2;
4326	+	}else {
4327	+	SWIG_exception(SWIG_TypeError, "string expected");
4328	+	}
4329	+	}
4330	+	{
4331		try {
4332	<	result = ((BossTask const *)arg1)->jobsMap();
4332	>	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4333
4334	+	}catch (const BossSchedFailure & e) {
4335	+	PyErr_SetString ( SchedulerError, e.what() );
4336	+	return NULL;
4337		}catch (const std::exception& e) {
4338	<	SWIG_exception(SWIG_RuntimeError, e.what());
4338	>	PyErr_SetString ( BossError, e.what() );
4339	>	return NULL;
4340		}
4341		}
4342		{
4343	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4344	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4345	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4343	>	BossChain * resultptr;
4344	>	resultptr = new BossChain((BossChain &) result);
4345	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4346		}
4347		return resultobj;
4348		fail:
#	Line 3320 | Line 4350 | static PyObject *_wrap_BossTask_jobsMap_
4350		}
4351
4352
4353	<	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4353	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4354		PyObject *resultobj;
4355		BossTask *arg1 = (BossTask *) 0 ;
3326	–	unsigned int arg2 ;
4356		std::map<std::string,std::string > result;
4357		PyObject * obj0 = 0 ;
3329	–	PyObject * obj1 = 0 ;
4358
4359	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4359	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4360		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3333	–	arg2 = (unsigned int) PyInt_AsLong(obj1);
3334	–	if (PyErr_Occurred()) SWIG_fail;
4361		{
4362		try {
4363	<	result = ((BossTask const *)arg1)->jobMap(arg2);
4363	>	result = ((BossTask const *)arg1)->taskMap();
4364
4365	+	}catch (const BossSchedFailure & e) {
4366	+	PyErr_SetString ( SchedulerError, e.what() );
4367	+	return NULL;
4368		}catch (const std::exception& e) {
4369	<	SWIG_exception(SWIG_RuntimeError, e.what());
4369	>	PyErr_SetString ( BossError, e.what() );
4370	>	return NULL;
4371		}
4372		}
4373		{
#	Line 3354 | Line 4384 | static PyObject *_wrap_BossTask_jobMap__
4384		}
4385
4386
4387	<	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4387	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4388	>	PyObject *resultobj;
4389	>	BossTask *arg1 = (BossTask *) 0 ;
4390	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4391	>	PyObject * obj0 = 0 ;
4392	>
4393	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4394	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4395	>	{
4396	>	try {
4397	>	result = ((BossTask const *)arg1)->jobsMap();
4398	>
4399	>	}catch (const BossSchedFailure & e) {
4400	>	PyErr_SetString ( SchedulerError, e.what() );
4401	>	return NULL;
4402	>	}catch (const std::exception& e) {
4403	>	PyErr_SetString ( BossError, e.what() );
4404	>	return NULL;
4405	>	}
4406	>	}
4407	>	{
4408	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4409	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4410	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4411	>	}
4412	>	return resultobj;
4413	>	fail:
4414	>	return NULL;
4415	>	}
4416	>
4417	>
4418	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4419		PyObject *resultobj;
4420		BossTask *arg1 = (BossTask *) 0 ;
4421		SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
#	Line 3377 | Line 4438 | static PyObject *_wrap_BossTask_jobMap__
4438		try {
4439		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4440
4441	+	}catch (const BossSchedFailure & e) {
4442	+	PyErr_SetString ( SchedulerError, e.what() );
4443	+	return NULL;
4444		}catch (const std::exception& e) {
4445	<	SWIG_exception(SWIG_RuntimeError, e.what());
4445	>	PyErr_SetString ( BossError, e.what() );
4446	>	return NULL;
4447		}
4448		}
4449		{
#	Line 3390 | Line 4455 | static PyObject *_wrap_BossTask_jobMap__
4455		}
4456
4457
4458	+	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4459	+	PyObject *resultobj;
4460	+	BossTask *arg1 = (BossTask *) 0 ;
4461	+	unsigned int arg2 ;
4462	+	std::map<std::string,std::string > result;
4463	+	PyObject * obj0 = 0 ;
4464	+	PyObject * obj1 = 0 ;
4465	+
4466	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4467	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4468	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
4469	+	if (PyErr_Occurred()) SWIG_fail;
4470	+	{
4471	+	try {
4472	+	result = ((BossTask const *)arg1)->jobMap(arg2);
4473	+
4474	+	}catch (const BossSchedFailure & e) {
4475	+	PyErr_SetString ( SchedulerError, e.what() );
4476	+	return NULL;
4477	+	}catch (const std::exception& e) {
4478	+	PyErr_SetString ( BossError, e.what() );
4479	+	return NULL;
4480	+	}
4481	+	}
4482	+	{
4483	+	resultobj = PyDict_New();
4484	+	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4485	+	PyDict_SetItem(resultobj,
4486	+	SwigString_FromString(i->first),
4487	+	SwigString_FromString(i->second));
4488	+	}
4489	+	}
4490	+	return resultobj;
4491	+	fail:
4492	+	return NULL;
4493	+	}
4494	+
4495	+
4496		static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4497		int argc;
4498		PyObject *argv[4];
#	Line 3415 | Line 4518 | static PyObject *_wrap_BossTask_jobMap(P
4518		_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4519		}
4520		if (_v) {
4521	<	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4521	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4522		}
4523		}
4524		}
#	Line 3451 | Line 4554 | static PyObject *_wrap_BossTask_jobMap(P
4554		}
4555		}
4556		if (_v) {
4557	<	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4557	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4558		}
4559		}
4560		}
#	Line 3462 | Line 4565 | static PyObject *_wrap_BossTask_jobMap(P
4565		}
4566
4567
3465	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3466	–	PyObject *resultobj;
3467	–	BossTask *arg1 = (BossTask *) 0 ;
3468	–	BossTask::job_iterator result;
3469	–	PyObject * obj0 = 0 ;
3470	–
3471	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3472	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3473	–	{
3474	–	try {
3475	–	result = ((BossTask const *)arg1)->job_begin();
3476	–
3477	–	}catch (const std::exception& e) {
3478	–	SWIG_exception(SWIG_RuntimeError, e.what());
3479	–	}
3480	–	}
3481	–	{
3482	–	BossTask::job_iterator * resultptr;
3483	–	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3484	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3485	–	}
3486	–	return resultobj;
3487	–	fail:
3488	–	return NULL;
3489	–	}
3490	–
3491	–
3492	–	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3493	–	PyObject *resultobj;
3494	–	BossTask *arg1 = (BossTask *) 0 ;
3495	–	BossTask::job_iterator result;
3496	–	PyObject * obj0 = 0 ;
3497	–
3498	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3499	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3500	–	{
3501	–	try {
3502	–	result = ((BossTask const *)arg1)->job_end();
3503	–
3504	–	}catch (const std::exception& e) {
3505	–	SWIG_exception(SWIG_RuntimeError, e.what());
3506	–	}
3507	–	}
3508	–	{
3509	–	BossTask::job_iterator * resultptr;
3510	–	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3511	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3512	–	}
3513	–	return resultobj;
3514	–	fail:
3515	–	return NULL;
3516	–	}
3517	–
3518	–
3519	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3520	–	PyObject *resultobj;
3521	–	BossTask *arg1 = (BossTask *) 0 ;
3522	–	BossJob *arg2 = (BossJob *) 0 ;
3523	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3524	–	PyObject * obj0 = 0 ;
3525	–	PyObject * obj1 = 0 ;
3526	–
3527	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3528	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3529	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3530	–	{
3531	–	try {
3532	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
3533	–
3534	–	}catch (const std::exception& e) {
3535	–	SWIG_exception(SWIG_RuntimeError, e.what());
3536	–	}
3537	–	}
3538	–	{
3539	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3540	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3541	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3542	–	}
3543	–	return resultobj;
3544	–	fail:
3545	–	return NULL;
3546	–	}
3547	–
3548	–
4568		static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4569		PyObject *resultobj;
4570		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3561 | Line 4580 | static PyObject *_wrap_BossTask_programs
4580		try {
4581		result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4582
4583	+	}catch (const BossSchedFailure & e) {
4584	+	PyErr_SetString ( SchedulerError, e.what() );
4585	+	return NULL;
4586		}catch (const std::exception& e) {
4587	<	SWIG_exception(SWIG_RuntimeError, e.what());
4587	>	PyErr_SetString ( BossError, e.what() );
4588	>	return NULL;
4589		}
4590		}
4591		{
#	Line 3612 | Line 4635 | static PyObject *_wrap_BossTask_declare_
4635		try {
4636		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4637
4638	+	}catch (const BossSchedFailure & e) {
4639	+	PyErr_SetString ( SchedulerError, e.what() );
4640	+	return NULL;
4641		}catch (const std::exception& e) {
4642	<	SWIG_exception(SWIG_RuntimeError, e.what());
4642	>	PyErr_SetString ( BossError, e.what() );
4643	>	return NULL;
4644		}
4645		}
4646		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3651 | Line 4678 | static PyObject *_wrap_BossTask_declare_
4678		try {
4679		(arg1)->declare(arg2,(std::string const &)*arg3);
4680
4681	+	}catch (const BossSchedFailure & e) {
4682	+	PyErr_SetString ( SchedulerError, e.what() );
4683	+	return NULL;
4684		}catch (const std::exception& e) {
4685	<	SWIG_exception(SWIG_RuntimeError, e.what());
4685	>	PyErr_SetString ( BossError, e.what() );
4686	>	return NULL;
4687		}
4688		}
4689		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3750 | Line 4781 | static PyObject *_wrap_BossTask_remove(P
4781		try {
4782		(arg1)->remove();
4783
4784	+	}catch (const BossSchedFailure & e) {
4785	+	PyErr_SetString ( SchedulerError, e.what() );
4786	+	return NULL;
4787		}catch (const std::exception& e) {
4788	<	SWIG_exception(SWIG_RuntimeError, e.what());
4788	>	PyErr_SetString ( BossError, e.what() );
4789	>	return NULL;
4790		}
4791		}
4792		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3786 | Line 4821 | static PyObject *_wrap_BossTask_archive(
4821		try {
4822		(arg1)->archive((std::string const &)*arg2);
4823
4824	+	}catch (const BossSchedFailure & e) {
4825	+	PyErr_SetString ( SchedulerError, e.what() );
4826	+	return NULL;
4827		}catch (const std::exception& e) {
4828	<	SWIG_exception(SWIG_RuntimeError, e.what());
4828	>	PyErr_SetString ( BossError, e.what() );
4829	>	return NULL;
4830		}
4831		}
4832		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3797 | Line 4836 | static PyObject *_wrap_BossTask_archive(
4836		}
4837
4838
3800	–	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3801	–	PyObject *resultobj;
3802	–	BossTask *arg1 = (BossTask *) 0 ;
3803	–	std::map<std::string,std::string > result;
3804	–	PyObject * obj0 = 0 ;
3805	–
3806	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3807	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3808	–	{
3809	–	try {
3810	–	result = ((BossTask const *)arg1)->taskMap();
3811	–
3812	–	}catch (const std::exception& e) {
3813	–	SWIG_exception(SWIG_RuntimeError, e.what());
3814	–	}
3815	–	}
3816	–	{
3817	–	resultobj = PyDict_New();
3818	–	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3819	–	PyDict_SetItem(resultobj,
3820	–	SwigString_FromString(i->first),
3821	–	SwigString_FromString(i->second));
3822	–	}
3823	–	}
3824	–	return resultobj;
3825	–	fail:
3826	–	return NULL;
3827	–	}
3828	–
3829	–
4839		static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4840		PyObject *resultobj;
4841		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3840 | Line 4849 | static PyObject *_wrap_BossTask_submit(P
4849		std::string *arg5 = (std::string *) &arg5_defvalue ;
4850		std::string const &arg6_defvalue = "" ;
4851		std::string *arg6 = (std::string *) &arg6_defvalue ;
4852	<	bool arg7 = (bool) false ;
4852	>	unsigned int arg7 = (unsigned int) 0 ;
4853	>	bool arg8 = (bool) false ;
4854		int result;
4855		std::string temp2 ;
4856		std::string temp3 ;
#	Line 3854 | Line 4864 | static PyObject *_wrap_BossTask_submit(P
4864		PyObject * obj4 = 0 ;
4865		PyObject * obj5 = 0 ;
4866		PyObject * obj6 = 0 ;
4867	+	PyObject * obj7 = 0 ;
4868
4869	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4869	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4870		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4871		if (obj1) {
4872		{
#	Line 3908 | Line 4919 | static PyObject *_wrap_BossTask_submit(P
4919		}
4920		}
4921		if (obj6) {
4922	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4922	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4923	>	if (PyErr_Occurred()) SWIG_fail;
4924	>	}
4925	>	if (obj7) {
4926	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4927		if (PyErr_Occurred()) SWIG_fail;
4928		}
4929		{
4930		try {
4931	<	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
4931	>	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7,arg8);
4932
4933	+	}catch (const BossSchedFailure & e) {
4934	+	PyErr_SetString ( SchedulerError, e.what() );
4935	+	return NULL;
4936		}catch (const std::exception& e) {
4937	<	SWIG_exception(SWIG_RuntimeError, e.what());
4937	>	PyErr_SetString ( BossError, e.what() );
4938	>	return NULL;
4939		}
4940		}
4941		resultobj = PyInt_FromLong((long)result);
#	Line 3955 | Line 4974 | static PyObject *_wrap_BossTask_reSubmit
4974		try {
4975		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4976
4977	+	}catch (const BossSchedFailure & e) {
4978	+	PyErr_SetString ( SchedulerError, e.what() );
4979	+	return NULL;
4980		}catch (const std::exception& e) {
4981	<	SWIG_exception(SWIG_RuntimeError, e.what());
4981	>	PyErr_SetString ( BossError, e.what() );
4982	>	return NULL;
4983		}
4984		}
4985		resultobj = PyInt_FromLong((long)result);
#	Line 3970 | Line 4993 | static PyObject *_wrap_BossTask_kill(PyO
4993		PyObject *resultobj;
4994		BossTask *arg1 = (BossTask *) 0 ;
4995		std::string *arg2 = 0 ;
4996	<	bool arg3 = (bool) false ;
4996	>	unsigned int arg3 = (unsigned int) 0 ;
4997	>	bool arg4 = (bool) false ;
4998		int result;
4999		std::string temp2 ;
5000		PyObject * obj0 = 0 ;
5001		PyObject * obj1 = 0 ;
5002		PyObject * obj2 = 0 ;
5003	+	PyObject * obj3 = 0 ;
5004
5005	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
5005	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
5006		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5007		{
5008		if (PyString_Check(obj1)) {
#	Line 3988 | Line 5013 | static PyObject *_wrap_BossTask_kill(PyO
5013		}
5014		}
5015		if (obj2) {
5016	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5016	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
5017	>	if (PyErr_Occurred()) SWIG_fail;
5018	>	}
5019	>	if (obj3) {
5020	>	arg4 = PyInt_AsLong(obj3) ? true : false;
5021		if (PyErr_Occurred()) SWIG_fail;
5022		}
5023		{
5024		try {
5025	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
5025	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
5026
5027	+	}catch (const BossSchedFailure & e) {
5028	+	PyErr_SetString ( SchedulerError, e.what() );
5029	+	return NULL;
5030		}catch (const std::exception& e) {
5031	<	SWIG_exception(SWIG_RuntimeError, e.what());
5031	>	PyErr_SetString ( BossError, e.what() );
5032	>	return NULL;
5033		}
5034		}
5035		resultobj = PyInt_FromLong((long)result);
#	Line 4006 | Line 5039 | static PyObject *_wrap_BossTask_kill(PyO
5039		}
5040
5041
5042	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
5042	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
5043		PyObject *resultobj;
5044		BossTask *arg1 = (BossTask *) 0 ;
5045		std::string const &arg2_defvalue = "all" ;
5046		std::string *arg2 = (std::string *) &arg2_defvalue ;
5047		std::string const &arg3_defvalue = "" ;
5048		std::string *arg3 = (std::string *) &arg3_defvalue ;
5049	<	bool arg4 = (bool) false ;
5049	>	unsigned int arg4 = (unsigned int) 0 ;
5050		bool arg5 = (bool) false ;
5051	+	bool arg6 = (bool) false ;
5052		int result;
5053		std::string temp2 ;
5054		std::string temp3 ;
#	Line 4023 | Line 5057 | static PyObject *_wrap_BossTask_getOutpu
5057		PyObject * obj2 = 0 ;
5058		PyObject * obj3 = 0 ;
5059		PyObject * obj4 = 0 ;
5060	+	PyObject * obj5 = 0 ;
5061
5062	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5062	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5063		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5064		if (obj1) {
5065		{
#	Line 4047 | Line 5082 | static PyObject *_wrap_BossTask_getOutpu
5082		}
5083		}
5084		if (obj3) {
5085	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5085	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
5086		if (PyErr_Occurred()) SWIG_fail;
5087		}
5088		if (obj4) {
5089		arg5 = PyInt_AsLong(obj4) ? true : false;
5090		if (PyErr_Occurred()) SWIG_fail;
5091		}
5092	+	if (obj5) {
5093	+	arg6 = PyInt_AsLong(obj5) ? true : false;
5094	+	if (PyErr_Occurred()) SWIG_fail;
5095	+	}
5096		{
5097		try {
5098	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
5098	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
5099
5100	+	}catch (const BossSchedFailure & e) {
5101	+	PyErr_SetString ( SchedulerError, e.what() );
5102	+	return NULL;
5103		}catch (const std::exception& e) {
5104	<	SWIG_exception(SWIG_RuntimeError, e.what());
5104	>	PyErr_SetString ( BossError, e.what() );
5105	>	return NULL;
5106		}
5107		}
5108		resultobj = PyInt_FromLong((long)result);
#	Line 4069 | Line 5112 | static PyObject *_wrap_BossTask_getOutpu
5112		}
5113
5114
5115	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
5115	>	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
5116		PyObject *resultobj;
5117		BossTask *arg1 = (BossTask *) 0 ;
5118	<	std::string const &arg2_defvalue = "" ;
4076	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
4077	<	bool arg3 = (bool) false ;
4078	<	bool arg4 = (bool) false ;
5118	>	std::string *arg2 = 0 ;
5119		int result;
5120		std::string temp2 ;
5121		PyObject * obj0 = 0 ;
5122		PyObject * obj1 = 0 ;
5123	+
5124	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5125	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5126	+	{
5127	+	if (PyString_Check(obj1)) {
5128	+	temp2 = std::string(PyString_AsString(obj1));
5129	+	arg2 = &temp2;
5130	+	}else {
5131	+	SWIG_exception(SWIG_TypeError, "string expected");
5132	+	}
5133	+	}
5134	+	{
5135	+	try {
5136	+	result = (int)(arg1)->loadByName((std::string const &)*arg2);
5137	+
5138	+	}catch (const BossSchedFailure & e) {
5139	+	PyErr_SetString ( SchedulerError, e.what() );
5140	+	return NULL;
5141	+	}catch (const std::exception& e) {
5142	+	PyErr_SetString ( BossError, e.what() );
5143	+	return NULL;
5144	+	}
5145	+	}
5146	+	resultobj = PyInt_FromLong((long)result);
5147	+	return resultobj;
5148	+	fail:
5149	+	return NULL;
5150	+	}
5151	+
5152	+
5153	+	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
5154	+	PyObject *resultobj;
5155	+	BossTask *arg1 = (BossTask *) 0 ;
5156	+	int arg2 = (int) SCHEDULED ;
5157	+	std::string const &arg3_defvalue = "all" ;
5158	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
5159	+	std::string const &arg4_defvalue = "" ;
5160	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
5161	+	std::string arg5 = (std::string) "" ;
5162	+	std::string arg6 = (std::string) "" ;
5163	+	std::string arg7 = (std::string) "" ;
5164	+	std::string arg8 = (std::string) "" ;
5165	+	int result;
5166	+	std::string temp3 ;
5167	+	std::string temp4 ;
5168	+	PyObject * obj0 = 0 ;
5169		PyObject * obj2 = 0 ;
5170		PyObject * obj3 = 0 ;
5171	+	PyObject * obj4 = 0 ;
5172	+	PyObject * obj5 = 0 ;
5173	+	PyObject * obj6 = 0 ;
5174	+	PyObject * obj7 = 0 ;
5175
5176	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
5176	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5177		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5178	<	if (obj1) {
5178	>	if (obj2) {
5179		{
5180	<	if (PyString_Check(obj1)) {
5181	<	temp2 = std::string(PyString_AsString(obj1));
5182	<	arg2 = &temp2;
5180	>	if (PyString_Check(obj2)) {
5181	>	temp3 = std::string(PyString_AsString(obj2));
5182	>	arg3 = &temp3;
5183		}else {
5184		SWIG_exception(SWIG_TypeError, "string expected");
5185		}
5186		}
5187		}
4098	–	if (obj2) {
4099	–	arg3 = PyInt_AsLong(obj2) ? true : false;
4100	–	if (PyErr_Occurred()) SWIG_fail;
4101	–	}
5188		if (obj3) {
5189	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5190	<	if (PyErr_Occurred()) SWIG_fail;
5189	>	{
5190	>	if (PyString_Check(obj3)) {
5191	>	temp4 = std::string(PyString_AsString(obj3));
5192	>	arg4 = &temp4;
5193	>	}else {
5194	>	SWIG_exception(SWIG_TypeError, "string expected");
5195	>	}
5196	>	}
5197	>	}
5198	>	if (obj4) {
5199	>	{
5200	>	if (PyString_Check(obj4))
5201	>	arg5 = std::string(PyString_AsString(obj4));
5202	>	else
5203	>	SWIG_exception(SWIG_TypeError, "string expected");
5204	>	}
5205	>	}
5206	>	if (obj5) {
5207	>	{
5208	>	if (PyString_Check(obj5))
5209	>	arg6 = std::string(PyString_AsString(obj5));
5210	>	else
5211	>	SWIG_exception(SWIG_TypeError, "string expected");
5212	>	}
5213	>	}
5214	>	if (obj6) {
5215	>	{
5216	>	if (PyString_Check(obj6))
5217	>	arg7 = std::string(PyString_AsString(obj6));
5218	>	else
5219	>	SWIG_exception(SWIG_TypeError, "string expected");
5220	>	}
5221	>	}
5222	>	if (obj7) {
5223	>	{
5224	>	if (PyString_Check(obj7))
5225	>	arg8 = std::string(PyString_AsString(obj7));
5226	>	else
5227	>	SWIG_exception(SWIG_TypeError, "string expected");
5228	>	}
5229		}
5230		{
5231		try {
5232	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
5232	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
5233
5234	+	}catch (const BossSchedFailure & e) {
5235	+	PyErr_SetString ( SchedulerError, e.what() );
5236	+	return NULL;
5237		}catch (const std::exception& e) {
5238	<	SWIG_exception(SWIG_RuntimeError, e.what());
5238	>	PyErr_SetString ( BossError, e.what() );
5239	>	return NULL;
5240		}
5241		}
5242		resultobj = PyInt_FromLong((long)result);
#	Line 4118 | Line 5246 | static PyObject *_wrap_BossTask_getOutpu
5246		}
5247
5248
5249	<	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
5250	<	int argc;
5251	<	PyObject *argv[6];
5252	<	int ii;
5249	>	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5250	>	PyObject *resultobj;
5251	>	BossTask *arg1 = (BossTask *) 0 ;
5252	>	int arg2 = (int) SCHEDULED ;
5253	>	std::string const &arg3_defvalue = "all" ;
5254	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
5255	>	std::string const &arg4_defvalue = "" ;
5256	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
5257	>	std::string arg5 = (std::string) "" ;
5258	>	std::string arg6 = (std::string) "" ;
5259	>	std::string arg7 = (std::string) "" ;
5260	>	std::string arg8 = (std::string) "" ;
5261	>	unsigned int arg9 = (unsigned int) 0 ;
5262	>	int result;
5263	>	std::string temp3 ;
5264	>	std::string temp4 ;
5265	>	PyObject * obj0 = 0 ;
5266	>	PyObject * obj2 = 0 ;
5267	>	PyObject * obj3 = 0 ;
5268	>	PyObject * obj4 = 0 ;
5269	>	PyObject * obj5 = 0 ;
5270	>	PyObject * obj6 = 0 ;
5271	>	PyObject * obj7 = 0 ;
5272	>	PyObject * obj8 = 0 ;
5273
5274	<	argc = PyObject_Length(args);
5275	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
5276	<	argv[ii] = PyTuple_GetItem(args,ii);
4129	<	}
4130	<	if ((argc >= 1) && (argc <= 5)) {
4131	<	int _v;
5274	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5275	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5276	>	if (obj2) {
5277		{
5278	<	void *ptr;
5279	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5280	<	_v = 0;
4136	<	PyErr_Clear();
5278	>	if (PyString_Check(obj2)) {
5279	>	temp3 = std::string(PyString_AsString(obj2));
5280	>	arg3 = &temp3;
5281		}else {
5282	<	_v = 1;
4139	<	}
4140	<	}
4141	<	if (_v) {
4142	<	if (argc <= 1) {
4143	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4144	<	}
4145	<	{
4146	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4147	<	}
4148	<	if (_v) {
4149	<	if (argc <= 2) {
4150	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4151	<	}
4152	<	{
4153	<	_v = PyString_Check(argv[2]) ? 1 : 0;
4154	<	}
4155	<	if (_v) {
4156	<	if (argc <= 3) {
4157	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4158	<	}
4159	<	{
4160	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4161	<	}
4162	<	if (_v) {
4163	<	if (argc <= 4) {
4164	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4165	<	}
4166	<	{
4167	<	_v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
4168	<	}
4169	<	if (_v) {
4170	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4171	<	}
4172	<	}
4173	<	}
5282	>	SWIG_exception(SWIG_TypeError, "string expected");
5283		}
5284		}
5285		}
5286	<	if ((argc >= 1) && (argc <= 4)) {
4178	<	int _v;
5286	>	if (obj3) {
5287		{
5288	<	void *ptr;
5289	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5290	<	_v = 0;
4183	<	PyErr_Clear();
5288	>	if (PyString_Check(obj3)) {
5289	>	temp4 = std::string(PyString_AsString(obj3));
5290	>	arg4 = &temp4;
5291		}else {
5292	<	_v = 1;
5292	>	SWIG_exception(SWIG_TypeError, "string expected");
5293		}
5294		}
5295	<	if (_v) {
5296	<	if (argc <= 1) {
5297	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
5298	<	}
5299	<	{
5300	<	_v = PyString_Check(argv[1]) ? 1 : 0;
5301	<	}
4195	<	if (_v) {
4196	<	if (argc <= 2) {
4197	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4198	<	}
4199	<	{
4200	<	_v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
4201	<	}
4202	<	if (_v) {
4203	<	if (argc <= 3) {
4204	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4205	<	}
4206	<	{
4207	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4208	<	}
4209	<	if (_v) {
4210	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4211	<	}
4212	<	}
4213	<	}
5295	>	}
5296	>	if (obj4) {
5297	>	{
5298	>	if (PyString_Check(obj4))
5299	>	arg5 = std::string(PyString_AsString(obj4));
5300	>	else
5301	>	SWIG_exception(SWIG_TypeError, "string expected");
5302		}
5303		}
5304	<
5305	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
5304	>	if (obj5) {
5305	>	{
5306	>	if (PyString_Check(obj5))
5307	>	arg6 = std::string(PyString_AsString(obj5));
5308	>	else
5309	>	SWIG_exception(SWIG_TypeError, "string expected");
5310	>	}
5311	>	}
5312	>	if (obj6) {
5313	>	{
5314	>	if (PyString_Check(obj6))
5315	>	arg7 = std::string(PyString_AsString(obj6));
5316	>	else
5317	>	SWIG_exception(SWIG_TypeError, "string expected");
5318	>	}
5319	>	}
5320	>	if (obj7) {
5321	>	{
5322	>	if (PyString_Check(obj7))
5323	>	arg8 = std::string(PyString_AsString(obj7));
5324	>	else
5325	>	SWIG_exception(SWIG_TypeError, "string expected");
5326	>	}
5327	>	}
5328	>	if (obj8) {
5329	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5330	>	if (PyErr_Occurred()) SWIG_fail;
5331	>	}
5332	>	{
5333	>	try {
5334	>	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5335	>
5336	>	}catch (const BossSchedFailure & e) {
5337	>	PyErr_SetString ( SchedulerError, e.what() );
5338	>	return NULL;
5339	>	}catch (const std::exception& e) {
5340	>	PyErr_SetString ( BossError, e.what() );
5341	>	return NULL;
5342	>	}
5343	>	}
5344	>	resultobj = PyInt_FromLong((long)result);
5345	>	return resultobj;
5346	>	fail:
5347		return NULL;
5348		}
5349
#	Line 4231 | Line 5360 | static PyObject *_wrap_BossTask_query(Py
5360		std::string arg6 = (std::string) "" ;
5361		std::string arg7 = (std::string) "" ;
5362		std::string arg8 = (std::string) "" ;
5363	<	bool arg9 = (bool) false ;
5363	>	unsigned int arg9 = (unsigned int) 0 ;
5364	>	bool arg10 = (bool) false ;
5365		int result;
5366		std::string temp3 ;
5367		std::string temp4 ;
#	Line 4243 | Line 5373 | static PyObject *_wrap_BossTask_query(Py
5373		PyObject * obj6 = 0 ;
5374		PyObject * obj7 = 0 ;
5375		PyObject * obj8 = 0 ;
5376	+	PyObject * obj9 = 0 ;
5377
5378	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5378	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5379		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5380		if (obj2) {
5381		{
#	Line 4299 | Line 5430 | static PyObject *_wrap_BossTask_query(Py
5430		}
5431		}
5432		if (obj8) {
5433	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5433	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5434	>	if (PyErr_Occurred()) SWIG_fail;
5435	>	}
5436	>	if (obj9) {
5437	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5438		if (PyErr_Occurred()) SWIG_fail;
5439		}
5440		{
5441		try {
5442	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5442	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5443
5444	+	}catch (const BossSchedFailure & e) {
5445	+	PyErr_SetString ( SchedulerError, e.what() );
5446	+	return NULL;
5447		}catch (const std::exception& e) {
5448	<	SWIG_exception(SWIG_RuntimeError, e.what());
5448	>	PyErr_SetString ( BossError, e.what() );
5449	>	return NULL;
5450		}
5451		}
5452		resultobj = PyInt_FromLong((long)result);
#	Line 4365 | Line 5504 | static PyObject *_wrap_BossTask_query_ou
5504		try {
5505		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5506
5507	+	}catch (const BossSchedFailure & e) {
5508	+	PyErr_SetString ( SchedulerError, e.what() );
5509	+	return NULL;
5510		}catch (const std::exception& e) {
5511	<	SWIG_exception(SWIG_RuntimeError, e.what());
5511	>	PyErr_SetString ( BossError, e.what() );
5512	>	return NULL;
5513		}
5514		}
5515		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4387 | Line 5530 | static PyObject *_wrap_BossTask_clear(Py
5530		try {
5531		(arg1)->clear();
5532
5533	+	}catch (const BossSchedFailure & e) {
5534	+	PyErr_SetString ( SchedulerError, e.what() );
5535	+	return NULL;
5536	+	}catch (const std::exception& e) {
5537	+	PyErr_SetString ( BossError, e.what() );
5538	+	return NULL;
5539	+	}
5540	+	}
5541	+	Py_INCREF(Py_None); resultobj = Py_None;
5542	+	return resultobj;
5543	+	fail:
5544	+	return NULL;
5545	+	}
5546	+
5547	+
5548	+	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5549	+	PyObject *resultobj;
5550	+	BossTask *arg1 = (BossTask *) 0 ;
5551	+	PyObject *arg2 = (PyObject *) 0 ;
5552	+	BossAttributeContainer *arg3 = 0 ;
5553	+	PyObject * obj0 = 0 ;
5554	+	PyObject * obj1 = 0 ;
5555	+	PyObject * obj2 = 0 ;
5556	+
5557	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5558	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5559	+	arg2 = obj1;
5560	+	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5561	+	if (arg3 == NULL) {
5562	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5563	+	}
5564	+	{
5565	+	try {
5566	+	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5567	+
5568	+	}catch (const BossSchedFailure & e) {
5569	+	PyErr_SetString ( SchedulerError, e.what() );
5570	+	return NULL;
5571		}catch (const std::exception& e) {
5572	<	SWIG_exception(SWIG_RuntimeError, e.what());
5572	>	PyErr_SetString ( BossError, e.what() );
5573	>	return NULL;
5574		}
5575		}
5576		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4398 | Line 5580 | static PyObject *_wrap_BossTask_clear(Py
5580		}
5581
5582
5583	<	static PyObject *_wrap_BossTask_prompt(PyObject *self, PyObject *args) {
5583	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5584	>	PyObject *resultobj;
5585	>	BossTask *arg1 = (BossTask *) 0 ;
5586	>	BossJob *arg2 = (BossJob *) 0 ;
5587	>	PyObject *arg3 = (PyObject *) 0 ;
5588	>	PyObject * obj0 = 0 ;
5589	>	PyObject * obj1 = 0 ;
5590	>	PyObject * obj2 = 0 ;
5591	>
5592	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5593	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5594	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5595	>	arg3 = obj2;
5596	>	{
5597	>	try {
5598	>	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5599	>
5600	>	}catch (const BossSchedFailure & e) {
5601	>	PyErr_SetString ( SchedulerError, e.what() );
5602	>	return NULL;
5603	>	}catch (const std::exception& e) {
5604	>	PyErr_SetString ( BossError, e.what() );
5605	>	return NULL;
5606	>	}
5607	>	}
5608	>	Py_INCREF(Py_None); resultobj = Py_None;
5609	>	return resultobj;
5610	>	fail:
5611	>	return NULL;
5612	>	}
5613	>
5614	>
5615	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5616	>	PyObject *resultobj;
5617	>	BossTask *arg1 = (BossTask *) 0 ;
5618	>	PyObject *result;
5619	>	PyObject * obj0 = 0 ;
5620	>
5621	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5622	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5623	>	{
5624	>	try {
5625	>	result = (PyObject *)BossTask_jobsDict(arg1);
5626	>
5627	>	}catch (const BossSchedFailure & e) {
5628	>	PyErr_SetString ( SchedulerError, e.what() );
5629	>	return NULL;
5630	>	}catch (const std::exception& e) {
5631	>	PyErr_SetString ( BossError, e.what() );
5632	>	return NULL;
5633	>	}
5634	>	}
5635	>	resultobj = result;
5636	>	return resultobj;
5637	>	fail:
5638	>	return NULL;
5639	>	}
5640	>
5641	>
5642	>	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5643		PyObject *resultobj;
5644		BossTask *arg1 = (BossTask *) 0 ;
5645		std::string *arg2 = 0 ;
5646	<	bool result;
5646	>	PyObject *result;
5647		std::string temp2 ;
5648		PyObject * obj0 = 0 ;
5649		PyObject * obj1 = 0 ;
5650
5651	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_prompt",&obj0,&obj1)) goto fail;
5651	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5652		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5653		{
5654		if (PyString_Check(obj1)) {
#	Line 4419 | Line 5660 | static PyObject *_wrap_BossTask_prompt(P
5660		}
5661		{
5662		try {
5663	<	result = (bool)(arg1)->prompt((std::string const &)*arg2);
5663	>	result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5664
5665	+	}catch (const BossSchedFailure & e) {
5666	+	PyErr_SetString ( SchedulerError, e.what() );
5667	+	return NULL;
5668		}catch (const std::exception& e) {
5669	<	SWIG_exception(SWIG_RuntimeError, e.what());
5669	>	PyErr_SetString ( BossError, e.what() );
5670	>	return NULL;
5671		}
5672		}
5673	<	resultobj = PyInt_FromLong((long)result);
5673	>	resultobj = result;
5674	>	return resultobj;
5675	>	fail:
5676	>	return NULL;
5677	>	}
5678	>
5679	>
5680	>	static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
5681	>	PyObject *resultobj;
5682	>	BossTask *arg1 = (BossTask *) 0 ;
5683	>	std::string *arg2 = 0 ;
5684	>	PyObject *result;
5685	>	std::string temp2 ;
5686	>	PyObject * obj0 = 0 ;
5687	>	PyObject * obj1 = 0 ;
5688	>
5689	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5690	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5691	>	{
5692	>	if (PyString_Check(obj1)) {
5693	>	temp2 = std::string(PyString_AsString(obj1));
5694	>	arg2 = &temp2;
5695	>	}else {
5696	>	SWIG_exception(SWIG_TypeError, "string expected");
5697	>	}
5698	>	}
5699	>	{
5700	>	try {
5701	>	result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
5702	>
5703	>	}catch (const BossSchedFailure & e) {
5704	>	PyErr_SetString ( SchedulerError, e.what() );
5705	>	return NULL;
5706	>	}catch (const std::exception& e) {
5707	>	PyErr_SetString ( BossError, e.what() );
5708	>	return NULL;
5709	>	}
5710	>	}
5711	>	resultobj = result;
5712	>	return resultobj;
5713	>	fail:
5714	>	return NULL;
5715	>	}
5716	>
5717	>
5718	>	static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5719	>	PyObject *resultobj;
5720	>	BossTask *arg1 = (BossTask *) 0 ;
5721	>	PyObject *result;
5722	>	PyObject * obj0 = 0 ;
5723	>
5724	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5725	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5726	>	{
5727	>	try {
5728	>	result = (PyObject *)BossTask_jobStates(arg1);
5729	>
5730	>	}catch (const BossSchedFailure & e) {
5731	>	PyErr_SetString ( SchedulerError, e.what() );
5732	>	return NULL;
5733	>	}catch (const std::exception& e) {
5734	>	PyErr_SetString ( BossError, e.what() );
5735	>	return NULL;
5736	>	}
5737	>	}
5738	>	resultobj = result;
5739	>	return resultobj;
5740	>	fail:
5741	>	return NULL;
5742	>	}
5743	>
5744	>
5745	>	static PyObject *_wrap_BossTask_joblist(PyObject *self, PyObject *args) {
5746	>	PyObject *resultobj;
5747	>	BossTask *arg1 = (BossTask *) 0 ;
5748	>	PyObject *result;
5749	>	PyObject * obj0 = 0 ;
5750	>
5751	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_joblist",&obj0)) goto fail;
5752	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5753	>	{
5754	>	try {
5755	>	result = (PyObject *)BossTask_joblist(arg1);
5756	>
5757	>	}catch (const BossSchedFailure & e) {
5758	>	PyErr_SetString ( SchedulerError, e.what() );
5759	>	return NULL;
5760	>	}catch (const std::exception& e) {
5761	>	PyErr_SetString ( BossError, e.what() );
5762	>	return NULL;
5763	>	}
5764	>	}
5765	>	resultobj = result;
5766	>	return resultobj;
5767	>	fail:
5768	>	return NULL;
5769	>	}
5770	>
5771	>
5772	>	static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5773	>	PyObject *resultobj;
5774	>	BossTask *arg1 = (BossTask *) 0 ;
5775	>	PyObject *result;
5776	>	PyObject * obj0 = 0 ;
5777	>
5778	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5779	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5780	>	{
5781	>	try {
5782	>	result = (PyObject *)BossTask_jobStatistic(arg1);
5783	>
5784	>	}catch (const BossSchedFailure & e) {
5785	>	PyErr_SetString ( SchedulerError, e.what() );
5786	>	return NULL;
5787	>	}catch (const std::exception& e) {
5788	>	PyErr_SetString ( BossError, e.what() );
5789	>	return NULL;
5790	>	}
5791	>	}
5792	>	resultobj = result;
5793	>	return resultobj;
5794	>	fail:
5795	>	return NULL;
5796	>	}
5797	>
5798	>
5799	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5800	>	PyObject *resultobj;
5801	>	BossTask *arg1 = (BossTask *) 0 ;
5802	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5803	>	PyObject *result;
5804	>	PyObject * obj0 = 0 ;
5805	>	PyObject * obj1 = 0 ;
5806	>
5807	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5808	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5809	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5810	>	if (arg2 == NULL) {
5811	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5812	>	}
5813	>	{
5814	>	try {
5815	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5816	>
5817	>	}catch (const BossSchedFailure & e) {
5818	>	PyErr_SetString ( SchedulerError, e.what() );
5819	>	return NULL;
5820	>	}catch (const std::exception& e) {
5821	>	PyErr_SetString ( BossError, e.what() );
5822	>	return NULL;
5823	>	}
5824	>	}
5825	>	resultobj = result;
5826	>	return resultobj;
5827	>	fail:
5828	>	return NULL;
5829	>	}
5830	>
5831	>
5832	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5833	>	PyObject *resultobj;
5834	>	BossTask *arg1 = (BossTask *) 0 ;
5835	>	std::string *arg2 = 0 ;
5836	>	PyObject *result;
5837	>	std::string temp2 ;
5838	>	PyObject * obj0 = 0 ;
5839	>	PyObject * obj1 = 0 ;
5840	>
5841	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5842	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5843	>	{
5844	>	if (PyString_Check(obj1)) {
5845	>	temp2 = std::string(PyString_AsString(obj1));
5846	>	arg2 = &temp2;
5847	>	}else {
5848	>	SWIG_exception(SWIG_TypeError, "string expected");
5849	>	}
5850	>	}
5851	>	{
5852	>	try {
5853	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5854	>
5855	>	}catch (const BossSchedFailure & e) {
5856	>	PyErr_SetString ( SchedulerError, e.what() );
5857	>	return NULL;
5858	>	}catch (const std::exception& e) {
5859	>	PyErr_SetString ( BossError, e.what() );
5860	>	return NULL;
5861	>	}
5862	>	}
5863	>	resultobj = result;
5864	>	return resultobj;
5865	>	fail:
5866	>	return NULL;
5867	>	}
5868	>
5869	>
5870	>	static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5871	>	PyObject *resultobj;
5872	>	BossTask *arg1 = (BossTask *) 0 ;
5873	>	std::string *arg2 = 0 ;
5874	>	std::string *arg3 = 0 ;
5875	>	PyObject *result;
5876	>	std::string temp2 ;
5877	>	std::string temp3 ;
5878	>	PyObject * obj0 = 0 ;
5879	>	PyObject * obj1 = 0 ;
5880	>	PyObject * obj2 = 0 ;
5881	>
5882	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5883	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5884	>	{
5885	>	if (PyString_Check(obj1)) {
5886	>	temp2 = std::string(PyString_AsString(obj1));
5887	>	arg2 = &temp2;
5888	>	}else {
5889	>	SWIG_exception(SWIG_TypeError, "string expected");
5890	>	}
5891	>	}
5892	>	{
5893	>	if (PyString_Check(obj2)) {
5894	>	temp3 = std::string(PyString_AsString(obj2));
5895	>	arg3 = &temp3;
5896	>	}else {
5897	>	SWIG_exception(SWIG_TypeError, "string expected");
5898	>	}
5899	>	}
5900	>	{
5901	>	try {
5902	>	result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5903	>
5904	>	}catch (const BossSchedFailure & e) {
5905	>	PyErr_SetString ( SchedulerError, e.what() );
5906	>	return NULL;
5907	>	}catch (const std::exception& e) {
5908	>	PyErr_SetString ( BossError, e.what() );
5909	>	return NULL;
5910	>	}
5911	>	}
5912	>	resultobj = result;
5913	>	return resultobj;
5914	>	fail:
5915	>	return NULL;
5916	>	}
5917	>
5918	>
5919	>	static PyObject *_wrap_BossTask_programExec(PyObject *self, PyObject *args) {
5920	>	PyObject *resultobj;
5921	>	BossTask *arg1 = (BossTask *) 0 ;
5922	>	std::string *arg2 = 0 ;
5923	>	std::string *arg3 = 0 ;
5924	>	PyObject *result;
5925	>	std::string temp2 ;
5926	>	std::string temp3 ;
5927	>	PyObject * obj0 = 0 ;
5928	>	PyObject * obj1 = 0 ;
5929	>	PyObject * obj2 = 0 ;
5930	>
5931	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
5932	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5933	>	{
5934	>	if (PyString_Check(obj1)) {
5935	>	temp2 = std::string(PyString_AsString(obj1));
5936	>	arg2 = &temp2;
5937	>	}else {
5938	>	SWIG_exception(SWIG_TypeError, "string expected");
5939	>	}
5940	>	}
5941	>	{
5942	>	if (PyString_Check(obj2)) {
5943	>	temp3 = std::string(PyString_AsString(obj2));
5944	>	arg3 = &temp3;
5945	>	}else {
5946	>	SWIG_exception(SWIG_TypeError, "string expected");
5947	>	}
5948	>	}
5949	>	{
5950	>	try {
5951	>	result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5952	>
5953	>	}catch (const BossSchedFailure & e) {
5954	>	PyErr_SetString ( SchedulerError, e.what() );
5955	>	return NULL;
5956	>	}catch (const std::exception& e) {
5957	>	PyErr_SetString ( BossError, e.what() );
5958	>	return NULL;
5959	>	}
5960	>	}
5961	>	resultobj = result;
5962	>	return resultobj;
5963	>	fail:
5964	>	return NULL;
5965	>	}
5966	>
5967	>
5968	>	static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
5969	>	PyObject *resultobj;
5970	>	BossTask *arg1 = (BossTask *) 0 ;
5971	>	std::string *arg2 = 0 ;
5972	>	std::string *arg3 = 0 ;
5973	>	PyObject *result;
5974	>	std::string temp2 ;
5975	>	std::string temp3 ;
5976	>	PyObject * obj0 = 0 ;
5977	>	PyObject * obj1 = 0 ;
5978	>	PyObject * obj2 = 0 ;
5979	>
5980	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
5981	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5982	>	{
5983	>	if (PyString_Check(obj1)) {
5984	>	temp2 = std::string(PyString_AsString(obj1));
5985	>	arg2 = &temp2;
5986	>	}else {
5987	>	SWIG_exception(SWIG_TypeError, "string expected");
5988	>	}
5989	>	}
5990	>	{
5991	>	if (PyString_Check(obj2)) {
5992	>	temp3 = std::string(PyString_AsString(obj2));
5993	>	arg3 = &temp3;
5994	>	}else {
5995	>	SWIG_exception(SWIG_TypeError, "string expected");
5996	>	}
5997	>	}
5998	>	{
5999	>	try {
6000	>	result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
6001	>
6002	>	}catch (const BossSchedFailure & e) {
6003	>	PyErr_SetString ( SchedulerError, e.what() );
6004	>	return NULL;
6005	>	}catch (const std::exception& e) {
6006	>	PyErr_SetString ( BossError, e.what() );
6007	>	return NULL;
6008	>	}
6009	>	}
6010	>	resultobj = result;
6011		return resultobj;
6012		fail:
6013		return NULL;
#	Line 4442 | Line 6024 | static PyObject * BossTask_swigregister(
6024		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
6025		PyObject *resultobj;
6026		std::string arg1 = (std::string) "" ;
6027	<	bool arg2 = (bool) false ;
6027	>	std::string arg2 = (std::string) "2" ;
6028	>	std::string arg3 = (std::string) "" ;
6029	>	std::string arg4 = (std::string) "" ;
6030	>	bool arg5 = (bool) false ;
6031		BossAdministratorSession *result;
6032		PyObject * obj0 = 0 ;
6033		PyObject * obj1 = 0 ;
6034	+	PyObject * obj2 = 0 ;
6035	+	PyObject * obj3 = 0 ;
6036	+	PyObject * obj4 = 0 ;
6037
6038	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
6038	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6039		if (obj0) {
6040		{
6041		if (PyString_Check(obj0))
#	Line 4457 | Line 6045 | static PyObject *_wrap_new_BossAdministr
6045		}
6046		}
6047		if (obj1) {
6048	<	arg2 = PyInt_AsLong(obj1) ? true : false;
6048	>	{
6049	>	if (PyString_Check(obj1))
6050	>	arg2 = std::string(PyString_AsString(obj1));
6051	>	else
6052	>	SWIG_exception(SWIG_TypeError, "string expected");
6053	>	}
6054	>	}
6055	>	if (obj2) {
6056	>	{
6057	>	if (PyString_Check(obj2))
6058	>	arg3 = std::string(PyString_AsString(obj2));
6059	>	else
6060	>	SWIG_exception(SWIG_TypeError, "string expected");
6061	>	}
6062	>	}
6063	>	if (obj3) {
6064	>	{
6065	>	if (PyString_Check(obj3))
6066	>	arg4 = std::string(PyString_AsString(obj3));
6067	>	else
6068	>	SWIG_exception(SWIG_TypeError, "string expected");
6069	>	}
6070	>	}
6071	>	if (obj4) {
6072	>	arg5 = PyInt_AsLong(obj4) ? true : false;
6073		if (PyErr_Occurred()) SWIG_fail;
6074		}
6075		{
6076		try {
6077	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
6077	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
6078
6079	+	}catch (const BossSchedFailure & e) {
6080	+	PyErr_SetString ( SchedulerError, e.what() );
6081	+	return NULL;
6082		}catch (const std::exception& e) {
6083	<	SWIG_exception(SWIG_RuntimeError, e.what());
6083	>	PyErr_SetString ( BossError, e.what() );
6084	>	return NULL;
6085		}
6086		}
6087		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4486 | Line 6102 | static PyObject *_wrap_delete_BossAdmini
6102		try {
6103		delete arg1;
6104
6105	+	}catch (const BossSchedFailure & e) {
6106	+	PyErr_SetString ( SchedulerError, e.what() );
6107	+	return NULL;
6108		}catch (const std::exception& e) {
6109	<	SWIG_exception(SWIG_RuntimeError, e.what());
6109	>	PyErr_SetString ( BossError, e.what() );
6110	>	return NULL;
6111		}
6112		}
6113		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4509 | Line 6129 | static PyObject *_wrap_BossAdministrator
6129		try {
6130		result = (int)(arg1)->configureDB();
6131
6132	+	}catch (const BossSchedFailure & e) {
6133	+	PyErr_SetString ( SchedulerError, e.what() );
6134	+	return NULL;
6135		}catch (const std::exception& e) {
6136	<	SWIG_exception(SWIG_RuntimeError, e.what());
6136	>	PyErr_SetString ( BossError, e.what() );
6137	>	return NULL;
6138		}
6139		}
6140		resultobj = PyInt_FromLong((long)result);
#	Line 4543 | Line 6167 | static PyObject *_wrap_BossAdministrator
6167		try {
6168		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
6169
6170	+	}catch (const BossSchedFailure & e) {
6171	+	PyErr_SetString ( SchedulerError, e.what() );
6172	+	return NULL;
6173		}catch (const std::exception& e) {
6174	<	SWIG_exception(SWIG_RuntimeError, e.what());
6174	>	PyErr_SetString ( BossError, e.what() );
6175	>	return NULL;
6176		}
6177		}
6178		resultobj = PyInt_FromLong((long)result);
#	Line 4577 | Line 6205 | static PyObject *_wrap_BossAdministrator
6205		try {
6206		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
6207
6208	+	}catch (const BossSchedFailure & e) {
6209	+	PyErr_SetString ( SchedulerError, e.what() );
6210	+	return NULL;
6211		}catch (const std::exception& e) {
6212	<	SWIG_exception(SWIG_RuntimeError, e.what());
6212	>	PyErr_SetString ( BossError, e.what() );
6213	>	return NULL;
6214		}
6215		}
6216		resultobj = PyInt_FromLong((long)result);
#	Line 4611 | Line 6243 | static PyObject *_wrap_BossAdministrator
6243		try {
6244		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
6245
6246	+	}catch (const BossSchedFailure & e) {
6247	+	PyErr_SetString ( SchedulerError, e.what() );
6248	+	return NULL;
6249		}catch (const std::exception& e) {
6250	<	SWIG_exception(SWIG_RuntimeError, e.what());
6250	>	PyErr_SetString ( BossError, e.what() );
6251	>	return NULL;
6252		}
6253		}
6254		resultobj = PyInt_FromLong((long)result);
#	Line 4645 | Line 6281 | static PyObject *_wrap_BossAdministrator
6281		try {
6282		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
6283
6284	+	}catch (const BossSchedFailure & e) {
6285	+	PyErr_SetString ( SchedulerError, e.what() );
6286	+	return NULL;
6287		}catch (const std::exception& e) {
6288	<	SWIG_exception(SWIG_RuntimeError, e.what());
6288	>	PyErr_SetString ( BossError, e.what() );
6289	>	return NULL;
6290		}
6291		}
6292		resultobj = PyInt_FromLong((long)result);
#	Line 4679 | Line 6319 | static PyObject *_wrap_BossAdministrator
6319		try {
6320		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
6321
6322	+	}catch (const BossSchedFailure & e) {
6323	+	PyErr_SetString ( SchedulerError, e.what() );
6324	+	return NULL;
6325		}catch (const std::exception& e) {
6326	<	SWIG_exception(SWIG_RuntimeError, e.what());
6326	>	PyErr_SetString ( BossError, e.what() );
6327	>	return NULL;
6328		}
6329		}
6330		resultobj = PyInt_FromLong((long)result);
#	Line 4745 | Line 6389 | static PyObject *_wrap_BossAdministrator
6389		try {
6390		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
6391
6392	+	}catch (const BossSchedFailure & e) {
6393	+	PyErr_SetString ( SchedulerError, e.what() );
6394	+	return NULL;
6395		}catch (const std::exception& e) {
6396	<	SWIG_exception(SWIG_RuntimeError, e.what());
6396	>	PyErr_SetString ( BossError, e.what() );
6397	>	return NULL;
6398		}
6399		}
6400		resultobj = PyInt_FromLong((long)result);
#	Line 4835 | Line 6483 | static PyObject *_wrap_BossAdministrator
6483		try {
6484		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
6485
6486	+	}catch (const BossSchedFailure & e) {
6487	+	PyErr_SetString ( SchedulerError, e.what() );
6488	+	return NULL;
6489		}catch (const std::exception& e) {
6490	<	SWIG_exception(SWIG_RuntimeError, e.what());
6490	>	PyErr_SetString ( BossError, e.what() );
6491	>	return NULL;
6492		}
6493		}
6494		resultobj = PyInt_FromLong((long)result);
#	Line 4911 | Line 6563 | static PyObject *_wrap_BossAdministrator
6563		try {
6564		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6565
6566	+	}catch (const BossSchedFailure & e) {
6567	+	PyErr_SetString ( SchedulerError, e.what() );
6568	+	return NULL;
6569		}catch (const std::exception& e) {
6570	<	SWIG_exception(SWIG_RuntimeError, e.what());
6570	>	PyErr_SetString ( BossError, e.what() );
6571	>	return NULL;
6572		}
6573		}
6574		resultobj = PyInt_FromLong((long)result);
#	Line 4940 | Line 6596 | static PyObject *_wrap_BossAdministrator
6596		std::string arg13 = (std::string) "" ;
6597		bool arg14 = (bool) false ;
6598		bool arg15 = (bool) false ;
6599	+	bool arg16 = (bool) false ;
6600	+	bool arg17 = (bool) false ;
6601		int result;
6602		std::string temp2 ;
6603		std::string temp11 ;
#	Line 4958 | Line 6616 | static PyObject *_wrap_BossAdministrator
6616		PyObject * obj12 = 0 ;
6617		PyObject * obj13 = 0 ;
6618		PyObject * obj14 = 0 ;
6619	+	PyObject * obj15 = 0 ;
6620	+	PyObject * obj16 = 0 ;
6621
6622	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) goto fail;
6622	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) goto fail;
6623		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6624		{
6625		if (PyString_Check(obj1)) {
#	Line 5067 | Line 6727 | static PyObject *_wrap_BossAdministrator
6727		arg15 = PyInt_AsLong(obj14) ? true : false;
6728		if (PyErr_Occurred()) SWIG_fail;
6729		}
6730	+	if (obj15) {
6731	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6732	+	if (PyErr_Occurred()) SWIG_fail;
6733	+	}
6734	+	if (obj16) {
6735	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6736	+	if (PyErr_Occurred()) SWIG_fail;
6737	+	}
6738		{
6739		try {
6740	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
6740	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15,arg16,arg17);
6741
6742	+	}catch (const BossSchedFailure & e) {
6743	+	PyErr_SetString ( SchedulerError, e.what() );
6744	+	return NULL;
6745		}catch (const std::exception& e) {
6746	<	SWIG_exception(SWIG_RuntimeError, e.what());
6746	>	PyErr_SetString ( BossError, e.what() );
6747	>	return NULL;
6748		}
6749		}
6750		resultobj = PyInt_FromLong((long)result);
#	Line 5094 | Line 6766 | static PyObject *_wrap_BossAdministrator
6766		try {
6767		result = (arg1)->help();
6768
6769	+	}catch (const BossSchedFailure & e) {
6770	+	PyErr_SetString ( SchedulerError, e.what() );
6771	+	return NULL;
6772		}catch (const std::exception& e) {
6773	<	SWIG_exception(SWIG_RuntimeError, e.what());
6773	>	PyErr_SetString ( BossError, e.what() );
6774	>	return NULL;
6775		}
6776		}
6777		{
#	Line 5133 | Line 6809 | static PyObject *_wrap_BossAdministrator
6809		try {
6810		result = (arg1)->SQL(arg2,arg3);
6811
6812	+	}catch (const BossSchedFailure & e) {
6813	+	PyErr_SetString ( SchedulerError, e.what() );
6814	+	return NULL;
6815		}catch (const std::exception& e) {
6816	<	SWIG_exception(SWIG_RuntimeError, e.what());
6816	>	PyErr_SetString ( BossError, e.what() );
6817	>	return NULL;
6818		}
6819		}
6820		{
#	Line 5205 | Line 6885 | static PyObject *_wrap_BossAdministrator
6885		try {
6886		result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6887
6888	+	}catch (const BossSchedFailure & e) {
6889	+	PyErr_SetString ( SchedulerError, e.what() );
6890	+	return NULL;
6891		}catch (const std::exception& e) {
6892	<	SWIG_exception(SWIG_RuntimeError, e.what());
6892	>	PyErr_SetString ( BossError, e.what() );
6893	>	return NULL;
6894	>	}
6895	>	}
6896	>	resultobj = PyInt_FromLong((long)result);
6897	>	return resultobj;
6898	>	fail:
6899	>	return NULL;
6900	>	}
6901	>
6902	>
6903	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
6904	>	PyObject *resultobj;
6905	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6906	>	std::string arg2 ;
6907	>	int result;
6908	>	PyObject * obj0 = 0 ;
6909	>	PyObject * obj1 = 0 ;
6910	>
6911	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6912	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6913	>	{
6914	>	if (PyString_Check(obj1))
6915	>	arg2 = std::string(PyString_AsString(obj1));
6916	>	else
6917	>	SWIG_exception(SWIG_TypeError, "string expected");
6918	>	}
6919	>	{
6920	>	try {
6921	>	result = (int)(arg1)->registerPlugins(arg2);
6922	>
6923	>	}catch (const BossSchedFailure & e) {
6924	>	PyErr_SetString ( SchedulerError, e.what() );
6925	>	return NULL;
6926	>	}catch (const std::exception& e) {
6927	>	PyErr_SetString ( BossError, e.what() );
6928	>	return NULL;
6929		}
6930		}
6931		resultobj = PyInt_FromLong((long)result);
#	Line 5239 | Line 6958 | static PyMethodDef SwigMethods[] = {
6958		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6959		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6960		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6961	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6962	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6963	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6964	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6965	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6966	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6961	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6962	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6963	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6964	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6965	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6966	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6967	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6968	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6969	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6970	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6971	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6972	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6973	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6974	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6975		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6976		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6977	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6978		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6979	+	{ (char *)"BossSession_task_begin", _wrap_BossSession_task_begin, METH_VARARGS },
6980	+	{ (char *)"BossSession_task_end", _wrap_BossSession_task_end, METH_VARARGS },
6981	+	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
6982	+	{ (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
6983		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6984		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6985	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6986	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6987	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6988	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6989		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6990		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6991		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5257 | Line 6993 | static PyMethodDef SwigMethods[] = {
6993		{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
6994		{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
6995		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5260	–	{ (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
6996		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6997		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6998	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6999	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
7000	+	{ (char *)"BossSession_getTasksByTaskInfo", _wrap_BossSession_getTasksByTaskInfo, METH_VARARGS },
7001	+	{ (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
7002	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7003	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7004	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
7005	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
7006	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
7007	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7008		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
5264	–	{ (char *)"BossSession_queryPrint", _wrap_BossSession_queryPrint, METH_VARARGS },
5265	–	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
7009		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5267	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5268	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7010		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
5270	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7011		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7012		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7013	<	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7014	<	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7015	<	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7016	<	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7017	<	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7013	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7014	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7015	>	{ (char *)"BossTask_jobsInMemory", _wrap_BossTask_jobsInMemory, METH_VARARGS },
7016	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7017	>	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7018	>	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
7019		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
7020		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7021		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7022		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7023	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7024	+	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
7025	+	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7026		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5283	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5284	–	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
5285	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7027		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
7028		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7029		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7030		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
5290	–	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
7031		{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
7032		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
7033		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
7034		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7035	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7036	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7037	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7038		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7039		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7040		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7041	<	{ (char *)"BossTask_prompt", _wrap_BossTask_prompt, METH_VARARGS },
7041	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7042	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7043	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7044	>	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7045	>	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7046	>	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7047	>	{ (char *)"BossTask_joblist", _wrap_BossTask_joblist, METH_VARARGS },
7048	>	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7049	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7050	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7051	>	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7052	>	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7053	>	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7054		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
7055		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7056		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 5312 | Line 7067 | static PyMethodDef SwigMethods[] = {
7067		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
7068		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
7069		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
7070	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
7071		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
7072		{ NULL, NULL }
7073		};
#	Line 5319 | Line 7075 | static PyMethodDef SwigMethods[] = {
7075
7076		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7077
5322	–	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}};
5323	–	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}};
7078		static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t", 0, "std::vector<std::pair<BossProgram,BossProgramExec > > *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t"},{0}};
7079		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7080	+	static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator", 0, "std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator"},{0}};
7081	+	static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7082	+	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7083		static swig_type_info _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t[] = {{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t", 0, "std::map<std::string,std::map<std::string,std::string > > *", 0},{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t"},{0}};
5327	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7084		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7085		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7086	<	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7086	>	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7087	>	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7088		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7089	<	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
7089	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7090		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
7091	+	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
7092		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
7093		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}};
7094		static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
7095		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5338	–	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
5339	–	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}};
7096		static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
7097	+	static swig_type_info _swigt__p_BossSession__task_iterator[] = {{"_p_BossSession__task_iterator", 0, "BossSession::task_iterator const *", 0},{"_p_BossSession__task_iterator"},{0}};
7098	+	static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
7099	+	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7100
7101		static swig_type_info *swig_types_initial[] = {
5343	–	_swigt__p_std__vectorTBossJob_p_t,
5344	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7102		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
7103		_swigt__p_XMLDoc,
7104	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7105	+	_swigt__p_BossProgramExec,
7106	+	_swigt__p_BossChain,
7107		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
5348	–	_swigt__p_std__ostream,
7108		_swigt__p_BossTask,
7109		_swigt__p_BossTaskException,
7110	<	_swigt__p_BossAttributeContainer,
7110	>	_swigt__p_std__ostream,
7111	>	_swigt__p_BossProgram,
7112		_swigt__p_printOption,
7113	<	_swigt__p_BossDatabase,
7113	>	_swigt__p_BossAttributeContainer,
7114		_swigt__p_BossJob,
7115	+	_swigt__p_BossDatabase,
7116		_swigt__p_BossSession,
7117		_swigt__p_std__vectorTstd__string_t,
7118		_swigt__p_std__mapTstd__string_std__string_t,
7119		_swigt__p_BossAdministratorSession,
5359	–	_swigt__p_jobStates,
5360	–	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7120		_swigt__p_BossTask__job_iterator,
7121	+	_swigt__p_BossSession__task_iterator,
7122	+	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7123	+	_swigt__p_jobStates,
7124		0
7125		};
7126
#	Line 5401 | Line 7163 | SWIGEXPORT(void) SWIG_init(void) {
7163		}
7164		SWIG_InstallConstants(d,swig_const_table);
7165
7166	+
7167	+	// define custom exceptions
7168	+	PyObject *e;
7169	+	PyMethodDef tp_methods = {
7170	+	NULL, NULL, 0, NULL
7171	+	};
7172	+	e = Py_InitModule("BossSession", &tp_methods);
7173	+	// generic BOSS exception
7174	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
7175	+	Py_INCREF(BossError);
7176	+	PyModule_AddObject(e, "BossError", BossError);
7177	+	// scheduler interaction BOSS exception
7178	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
7179	+	Py_INCREF(SchedulerError);
7180	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
7181	+
7182		}
7183

Diff Legend

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