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.35 by gcodispo, Mon Jul 2 09:40:39 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 ;
2627	<	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	>	std::string temp2 ;
3329		PyObject * obj0 = 0 ;
3330		PyObject * obj1 = 0 ;
2638	–	PyObject * obj2 = 0 ;
2639	–	PyObject * obj3 = 0 ;
2640	–	PyObject * obj4 = 0 ;
2641	–	PyObject * obj5 = 0 ;
3331
3332	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossSession_queryPrint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3332	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3333		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3334	<	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3335	<	arg2 = *argp2;
3336	<	if (obj2) {
3337	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3338	<	if (arg3 == NULL) {
3339	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3334	>	{
3335	>	if (PyString_Check(obj1)) {
3336	>	temp2 = std::string(PyString_AsString(obj1));
3337	>	arg2 = &temp2;
3338	>	}else {
3339	>	SWIG_exception(SWIG_TypeError, "string expected");
3340		}
3341		}
3342	<	if (obj3) {
3343	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3344	<	if (arg4 == NULL) {
3345	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3342	>	{
3343	>	try {
3344	>	(arg1)->getTasksByName((std::string const &)*arg2);
3345	>
3346	>	}catch (const BossSchedFailure & e) {
3347	>	PyErr_SetString ( SchedulerError, e.what() );
3348	>	return NULL;
3349	>	}catch (const std::exception& e) {
3350	>	PyErr_SetString ( BossError, e.what() );
3351	>	return NULL;
3352		}
3353		}
3354	<	if (obj4) {
3355	<	if ((SWIG_ConvertPtr(obj4,(void **) &arg5, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3356	<	if (arg5 == NULL) {
3357	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3354	>	Py_INCREF(Py_None); resultobj = Py_None;
3355	>	return resultobj;
3356	>	fail:
3357	>	return NULL;
3358	>	}
3359	>
3360	>
3361	>	static PyObject *_wrap_BossSession_getTasksByTaskInfo(PyObject *self, PyObject *args) {
3362	>	PyObject *resultobj;
3363	>	BossSession *arg1 = (BossSession *) 0 ;
3364	>	std::string *arg2 = 0 ;
3365	>	std::string temp2 ;
3366	>	PyObject * obj0 = 0 ;
3367	>	PyObject * obj1 = 0 ;
3368	>
3369	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByTaskInfo",&obj0,&obj1)) goto fail;
3370	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3371	>	{
3372	>	if (PyString_Check(obj1)) {
3373	>	temp2 = std::string(PyString_AsString(obj1));
3374	>	arg2 = &temp2;
3375	>	}else {
3376	>	SWIG_exception(SWIG_TypeError, "string expected");
3377		}
3378		}
3379	<	if (obj5) {
3380	<	{
3381	<	if (PyString_Check(obj5)) {
3382	<	temp6 = std::string(PyString_AsString(obj5));
3383	<	arg6 = &temp6;
3384	<	}else {
3385	<	SWIG_exception(SWIG_TypeError, "string expected");
3386	<	}
3379	>	{
3380	>	try {
3381	>	(arg1)->getTasksByTaskInfo((std::string const &)*arg2);
3382	>
3383	>	}catch (const BossSchedFailure & e) {
3384	>	PyErr_SetString ( SchedulerError, e.what() );
3385	>	return NULL;
3386	>	}catch (const std::exception& e) {
3387	>	PyErr_SetString ( BossError, e.what() );
3388	>	return NULL;
3389	>	}
3390	>	}
3391	>	Py_INCREF(Py_None); resultobj = Py_None;
3392	>	return resultobj;
3393	>	fail:
3394	>	return NULL;
3395	>	}
3396	>
3397	>
3398	>	static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3399	>	PyObject *resultobj;
3400	>	BossSession *arg1 = (BossSession *) 0 ;
3401	>	std::string *arg2 = 0 ;
3402	>	std::string temp2 ;
3403	>	PyObject * obj0 = 0 ;
3404	>	PyObject * obj1 = 0 ;
3405	>
3406	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3407	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3408	>	{
3409	>	if (PyString_Check(obj1)) {
3410	>	temp2 = std::string(PyString_AsString(obj1));
3411	>	arg2 = &temp2;
3412	>	}else {
3413	>	SWIG_exception(SWIG_TypeError, "string expected");
3414		}
3415		}
3416		{
3417		try {
3418	<	(arg1)->queryPrint(arg2,*arg3,(jobStates const &)*arg4,(printOption const &)*arg5,(std::string const &)*arg6);
3418	>	(arg1)->getTasksByJobName((std::string const &)*arg2);
3419
3420	+	}catch (const BossSchedFailure & e) {
3421	+	PyErr_SetString ( SchedulerError, e.what() );
3422	+	return NULL;
3423		}catch (const std::exception& e) {
3424	<	SWIG_exception(SWIG_RuntimeError, e.what());
3424	>	PyErr_SetString ( BossError, e.what() );
3425	>	return NULL;
3426		}
3427		}
3428		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2687 | Line 3432 | static PyObject *_wrap_BossSession_query
3432		}
3433
3434
3435	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3435	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3436		PyObject *resultobj;
3437		BossSession *arg1 = (BossSession *) 0 ;
3438	<	std::string const &arg2_defvalue = "all" ;
3439	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3440	<	std::string const &arg3_defvalue = "" ;
3441	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3438	>	std::vector<std::string > *arg2 = 0 ;
3439	>	PyObject *result;
3440	>	PyObject * obj0 = 0 ;
3441	>	PyObject * obj1 = 0 ;
3442	>
3443	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3444	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3445	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3446	>	if (arg2 == NULL) {
3447	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3448	>	}
3449	>	{
3450	>	try {
3451	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3452	>
3453	>	}catch (const BossSchedFailure & e) {
3454	>	PyErr_SetString ( SchedulerError, e.what() );
3455	>	return NULL;
3456	>	}catch (const std::exception& e) {
3457	>	PyErr_SetString ( BossError, e.what() );
3458	>	return NULL;
3459	>	}
3460	>	}
3461	>	resultobj = result;
3462	>	return resultobj;
3463	>	fail:
3464	>	return NULL;
3465	>	}
3466	>
3467	>
3468	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3469	>	PyObject *resultobj;
3470	>	BossSession *arg1 = (BossSession *) 0 ;
3471	>	PyObject *result;
3472	>	PyObject * obj0 = 0 ;
3473	>
3474	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3475	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3476	>	{
3477	>	try {
3478	>	result = (PyObject *)BossSession_CHTools(arg1);
3479	>
3480	>	}catch (const BossSchedFailure & e) {
3481	>	PyErr_SetString ( SchedulerError, e.what() );
3482	>	return NULL;
3483	>	}catch (const std::exception& e) {
3484	>	PyErr_SetString ( BossError, e.what() );
3485	>	return NULL;
3486	>	}
3487	>	}
3488	>	resultobj = result;
3489	>	return resultobj;
3490	>	fail:
3491	>	return NULL;
3492	>	}
3493	>
3494	>
3495	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3496	>	PyObject *resultobj;
3497	>	BossSession *arg1 = (BossSession *) 0 ;
3498	>	PyObject *result;
3499	>	PyObject * obj0 = 0 ;
3500	>
3501	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3502	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3503	>	{
3504	>	try {
3505	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3506	>
3507	>	}catch (const BossSchedFailure & e) {
3508	>	PyErr_SetString ( SchedulerError, e.what() );
3509	>	return NULL;
3510	>	}catch (const std::exception& e) {
3511	>	PyErr_SetString ( BossError, e.what() );
3512	>	return NULL;
3513	>	}
3514	>	}
3515	>	resultobj = result;
3516	>	return resultobj;
3517	>	fail:
3518	>	return NULL;
3519	>	}
3520	>
3521	>
3522	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3523	>	PyObject *resultobj;
3524	>	BossSession *arg1 = (BossSession *) 0 ;
3525	>	PyObject *result;
3526	>	PyObject * obj0 = 0 ;
3527	>
3528	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3529	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3530	>	{
3531	>	try {
3532	>	result = (PyObject *)BossSession_RTMons(arg1);
3533	>
3534	>	}catch (const BossSchedFailure & e) {
3535	>	PyErr_SetString ( SchedulerError, e.what() );
3536	>	return NULL;
3537	>	}catch (const std::exception& e) {
3538	>	PyErr_SetString ( BossError, e.what() );
3539	>	return NULL;
3540	>	}
3541	>	}
3542	>	resultobj = result;
3543	>	return resultobj;
3544	>	fail:
3545	>	return NULL;
3546	>	}
3547	>
3548	>
3549	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3550	>	PyObject *resultobj;
3551	>	BossSession *arg1 = (BossSession *) 0 ;
3552	>	PyObject *result;
3553	>	PyObject * obj0 = 0 ;
3554	>
3555	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3556	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3557	>	{
3558	>	try {
3559	>	result = (PyObject *)BossSession_schedulers(arg1);
3560	>
3561	>	}catch (const BossSchedFailure & e) {
3562	>	PyErr_SetString ( SchedulerError, e.what() );
3563	>	return NULL;
3564	>	}catch (const std::exception& e) {
3565	>	PyErr_SetString ( BossError, e.what() );
3566	>	return NULL;
3567	>	}
3568	>	}
3569	>	resultobj = result;
3570	>	return resultobj;
3571	>	fail:
3572	>	return NULL;
3573	>	}
3574	>
3575	>
3576	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3577	>	PyObject *resultobj;
3578	>	BossSession *arg1 = (BossSession *) 0 ;
3579	>	std::string *arg2 = 0 ;
3580	>	std::string *arg3 = 0 ;
3581		std::string const &arg4_defvalue = "" ;
3582		std::string *arg4 = (std::string *) &arg4_defvalue ;
3583		std::string const &arg5_defvalue = "" ;
3584		std::string *arg5 = (std::string *) &arg5_defvalue ;
3585	<	SwigValueWrapper< std::vector<std::string > > result;
3585	>	unsigned int arg6 = (unsigned int) 0 ;
3586	>	PyObject *result;
3587		std::string temp2 ;
3588		std::string temp3 ;
3589		std::string temp4 ;
#	Line 2708 | Line 3593 | static PyObject *_wrap_BossSession_selec
3593		PyObject * obj2 = 0 ;
3594		PyObject * obj3 = 0 ;
3595		PyObject * obj4 = 0 ;
3596	+	PyObject * obj5 = 0 ;
3597
3598	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3598	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3599		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3600	<	if (obj1) {
3600	>	{
3601	>	if (PyString_Check(obj1)) {
3602	>	temp2 = std::string(PyString_AsString(obj1));
3603	>	arg2 = &temp2;
3604	>	}else {
3605	>	SWIG_exception(SWIG_TypeError, "string expected");
3606	>	}
3607	>	}
3608	>	{
3609	>	if (PyString_Check(obj2)) {
3610	>	temp3 = std::string(PyString_AsString(obj2));
3611	>	arg3 = &temp3;
3612	>	}else {
3613	>	SWIG_exception(SWIG_TypeError, "string expected");
3614	>	}
3615	>	}
3616	>	if (obj3) {
3617		{
3618	<	if (PyString_Check(obj1)) {
3619	<	temp2 = std::string(PyString_AsString(obj1));
3620	<	arg2 = &temp2;
3618	>	if (PyString_Check(obj3)) {
3619	>	temp4 = std::string(PyString_AsString(obj3));
3620	>	arg4 = &temp4;
3621	>	}else {
3622	>	SWIG_exception(SWIG_TypeError, "string expected");
3623	>	}
3624	>	}
3625	>	}
3626	>	if (obj4) {
3627	>	{
3628	>	if (PyString_Check(obj4)) {
3629	>	temp5 = std::string(PyString_AsString(obj4));
3630	>	arg5 = &temp5;
3631		}else {
3632		SWIG_exception(SWIG_TypeError, "string expected");
3633		}
3634		}
3635		}
3636	+	if (obj5) {
3637	+	arg6 = (unsigned int) PyInt_AsLong(obj5);
3638	+	if (PyErr_Occurred()) SWIG_fail;
3639	+	}
3640	+	{
3641	+	try {
3642	+	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3643	+
3644	+	}catch (const BossSchedFailure & e) {
3645	+	PyErr_SetString ( SchedulerError, e.what() );
3646	+	return NULL;
3647	+	}catch (const std::exception& e) {
3648	+	PyErr_SetString ( BossError, e.what() );
3649	+	return NULL;
3650	+	}
3651	+	}
3652	+	resultobj = result;
3653	+	return resultobj;
3654	+	fail:
3655	+	return NULL;
3656	+	}
3657	+
3658	+
3659	+	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3660	+	PyObject *resultobj;
3661	+	BossSession *arg1 = (BossSession *) 0 ;
3662	+	int arg2 = (int) SCHEDULED ;
3663	+	std::string const &arg3_defvalue = "all" ;
3664	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
3665	+	std::string const &arg4_defvalue = "all" ;
3666	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
3667	+	std::string const &arg5_defvalue = "" ;
3668	+	std::string *arg5 = (std::string *) &arg5_defvalue ;
3669	+	std::string arg6 = (std::string) "" ;
3670	+	std::string arg7 = (std::string) "" ;
3671	+	std::string arg8 = (std::string) "" ;
3672	+	std::string arg9 = (std::string) "" ;
3673	+	unsigned int arg10 = (unsigned int) 0 ;
3674	+	bool arg11 = (bool) false ;
3675	+	std::string temp3 ;
3676	+	std::string temp4 ;
3677	+	std::string temp5 ;
3678	+	PyObject * obj0 = 0 ;
3679	+	PyObject * obj2 = 0 ;
3680	+	PyObject * obj3 = 0 ;
3681	+	PyObject * obj4 = 0 ;
3682	+	PyObject * obj5 = 0 ;
3683	+	PyObject * obj6 = 0 ;
3684	+	PyObject * obj7 = 0 ;
3685	+	PyObject * obj8 = 0 ;
3686	+	PyObject * obj9 = 0 ;
3687	+	PyObject * obj10 = 0 ;
3688	+
3689	+	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3690	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3691		if (obj2) {
3692		{
3693		if (PyString_Check(obj2)) {
#	Line 2751 | Line 3718 | static PyObject *_wrap_BossSession_selec
3718		}
3719		}
3720		}
3721	+	if (obj5) {
3722	+	{
3723	+	if (PyString_Check(obj5))
3724	+	arg6 = std::string(PyString_AsString(obj5));
3725	+	else
3726	+	SWIG_exception(SWIG_TypeError, "string expected");
3727	+	}
3728	+	}
3729	+	if (obj6) {
3730	+	{
3731	+	if (PyString_Check(obj6))
3732	+	arg7 = std::string(PyString_AsString(obj6));
3733	+	else
3734	+	SWIG_exception(SWIG_TypeError, "string expected");
3735	+	}
3736	+	}
3737	+	if (obj7) {
3738	+	{
3739	+	if (PyString_Check(obj7))
3740	+	arg8 = std::string(PyString_AsString(obj7));
3741	+	else
3742	+	SWIG_exception(SWIG_TypeError, "string expected");
3743	+	}
3744	+	}
3745	+	if (obj8) {
3746	+	{
3747	+	if (PyString_Check(obj8))
3748	+	arg9 = std::string(PyString_AsString(obj8));
3749	+	else
3750	+	SWIG_exception(SWIG_TypeError, "string expected");
3751	+	}
3752	+	}
3753	+	if (obj9) {
3754	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3755	+	if (PyErr_Occurred()) SWIG_fail;
3756	+	}
3757	+	if (obj10) {
3758	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3759	+	if (PyErr_Occurred()) SWIG_fail;
3760	+	}
3761		{
3762		try {
3763	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3763	>	BossSession_schedulerQuery(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3764
3765	+	}catch (const BossSchedFailure & e) {
3766	+	PyErr_SetString ( SchedulerError, e.what() );
3767	+	return NULL;
3768		}catch (const std::exception& e) {
3769	<	SWIG_exception(SWIG_RuntimeError, e.what());
3769	>	PyErr_SetString ( BossError, e.what() );
3770	>	return NULL;
3771		}
3772		}
3773	<	{
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	<	}
3773	>	Py_INCREF(Py_None); resultobj = Py_None;
3774		return resultobj;
3775		fail:
3776		return NULL;
#	Line 2777 | Line 3784 | static PyObject * BossSession_swigregist
3784		Py_INCREF(obj);
3785		return Py_BuildValue((char *)"");
3786		}
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	–
3787		static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3788		PyObject *resultobj;
3789		char *arg1 ;
#	Line 2827 | Line 3794 | static PyObject *_wrap_new_BossTaskExcep
3794		try {
3795		result = (BossTaskException *)new BossTaskException((char const *)arg1);
3796
3797	+	}catch (const BossSchedFailure & e) {
3798	+	PyErr_SetString ( SchedulerError, e.what() );
3799	+	return NULL;
3800		}catch (const std::exception& e) {
3801	<	SWIG_exception(SWIG_RuntimeError, e.what());
3801	>	PyErr_SetString ( BossError, e.what() );
3802	>	return NULL;
3803		}
3804		}
3805		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
#	Line 2838 | Line 3809 | static PyObject *_wrap_new_BossTaskExcep
3809		}
3810
3811
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	–
3812		static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3813		PyObject *resultobj;
3814		BossTaskException *arg1 = (BossTaskException *) 0 ;
#	Line 2872 | Line 3820 | static PyObject *_wrap_delete_BossTaskEx
3820		try {
3821		delete arg1;
3822
3823	+	}catch (const BossSchedFailure & e) {
3824	+	PyErr_SetString ( SchedulerError, e.what() );
3825	+	return NULL;
3826		}catch (const std::exception& e) {
3827	<	SWIG_exception(SWIG_RuntimeError, e.what());
3827	>	PyErr_SetString ( BossError, e.what() );
3828	>	return NULL;
3829		}
3830		}
3831		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2890 | Line 3842 | static PyObject * BossTaskException_swig
3842		Py_INCREF(obj);
3843		return Py_BuildValue((char *)"");
3844		}
3845	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3845	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3846		PyObject *resultobj;
3847		BossTask *arg1 = (BossTask *) 0 ;
3848	<	PyObject *arg2 = (PyObject *) 0 ;
2897	<	BossAttributeContainer *arg3 = 0 ;
2898	<	PyObject *result;
3848	>	BossTask::job_iterator result;
3849		PyObject * obj0 = 0 ;
2900	–	PyObject * obj1 = 0 ;
2901	–	PyObject * obj2 = 0 ;
3850
3851	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3851	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3852		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	–	}
3853		{
3854		try {
3855	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3855	>	result = ((BossTask const *)arg1)->job_begin();
3856
3857	+	}catch (const BossSchedFailure & e) {
3858	+	PyErr_SetString ( SchedulerError, e.what() );
3859	+	return NULL;
3860		}catch (const std::exception& e) {
3861	<	SWIG_exception(SWIG_RuntimeError, e.what());
3861	>	PyErr_SetString ( BossError, e.what() );
3862	>	return NULL;
3863		}
3864		}
3865	<	resultobj = result;
3865	>	{
3866	>	BossTask::job_iterator * resultptr;
3867	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3868	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3869	>	}
3870		return resultobj;
3871		fail:
3872		return NULL;
3873		}
3874
3875
3876	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3876	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3877		PyObject *resultobj;
3878		BossTask *arg1 = (BossTask *) 0 ;
3879	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
2929	<	PyObject *result;
3879	>	BossTask::job_iterator result;
3880		PyObject * obj0 = 0 ;
2931	–	PyObject * obj1 = 0 ;
3881
3882	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3882	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3883		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	–	}
3884		{
3885		try {
3886	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3886	>	result = ((BossTask const *)arg1)->job_end();
3887
3888	+	}catch (const BossSchedFailure & e) {
3889	+	PyErr_SetString ( SchedulerError, e.what() );
3890	+	return NULL;
3891		}catch (const std::exception& e) {
3892	<	SWIG_exception(SWIG_RuntimeError, e.what());
3892	>	PyErr_SetString ( BossError, e.what() );
3893	>	return NULL;
3894		}
3895		}
3896	<	resultobj = result;
3896	>	{
3897	>	BossTask::job_iterator * resultptr;
3898	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3899	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3900	>	}
3901		return resultobj;
3902		fail:
3903		return NULL;
3904		}
3905
3906
3907	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3907	>	static PyObject *_wrap_BossTask_jobsInMemory(PyObject *self, PyObject *args) {
3908		PyObject *resultobj;
3909		BossTask *arg1 = (BossTask *) 0 ;
3910	<	PyObject *result;
3910	>	unsigned int result;
3911		PyObject * obj0 = 0 ;
3912
3913	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3913	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsInMemory",&obj0)) goto fail;
3914		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3915		{
3916		try {
3917	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3917	>	result = (unsigned int)((BossTask const *)arg1)->jobsInMemory();
3918
3919	+	}catch (const BossSchedFailure & e) {
3920	+	PyErr_SetString ( SchedulerError, e.what() );
3921	+	return NULL;
3922		}catch (const std::exception& e) {
3923	<	SWIG_exception(SWIG_RuntimeError, e.what());
3923	>	PyErr_SetString ( BossError, e.what() );
3924	>	return NULL;
3925		}
3926		}
3927	<	resultobj = result;
3927	>	resultobj = PyInt_FromLong((long)result);
3928		return resultobj;
3929		fail:
3930		return NULL;
3931		}
3932
3933
3934	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3935	<	int argc;
3936	<	PyObject *argv[2];
3937	<	int ii;
3934	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3935	>	PyObject *resultobj;
3936	>	BossTask *arg1 = (BossTask *) 0 ;
3937	>	BossJob *arg2 = (BossJob *) 0 ;
3938	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3939	>	PyObject * obj0 = 0 ;
3940	>	PyObject * obj1 = 0 ;
3941
3942	<	argc = PyObject_Length(args);
3943	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3944	<	argv[ii] = PyTuple_GetItem(args,ii);
3945	<	}
3946	<	if (argc == 1) {
3947	<	int _v;
3948	<	{
3949	<	void *ptr;
3950	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3951	<	_v = 0;
3952	<	PyErr_Clear();
3953	<	}else {
3954	<	_v = 1;
2995	<	}
2996	<	}
2997	<	if (_v) {
2998	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
3942	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3943	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3944	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3945	>	{
3946	>	try {
3947	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
3948	>
3949	>	}catch (const BossSchedFailure & e) {
3950	>	PyErr_SetString ( SchedulerError, e.what() );
3951	>	return NULL;
3952	>	}catch (const std::exception& e) {
3953	>	PyErr_SetString ( BossError, e.what() );
3954	>	return NULL;
3955		}
3956		}
3957	<
3958	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3957	>	{
3958	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3959	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3960	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3961	>	}
3962	>	return resultobj;
3963	>	fail:
3964		return NULL;
3965		}
3966
3967
3968	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3968	>	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
3969		PyObject *resultobj;
3970		BossTask *arg1 = (BossTask *) 0 ;
3971	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3972	<	PyObject *result;
3971	>	BossJob *arg2 = (BossJob *) 0 ;
3972	>	std::string *arg3 = 0 ;
3973	>	BossProgram result;
3974	>	std::string temp3 ;
3975		PyObject * obj0 = 0 ;
3976		PyObject * obj1 = 0 ;
3977	+	PyObject * obj2 = 0 ;
3978
3979	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3979	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
3980		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3981	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3982	<	if (arg2 == NULL) {
3983	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3981	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3982	>	{
3983	>	if (PyString_Check(obj2)) {
3984	>	temp3 = std::string(PyString_AsString(obj2));
3985	>	arg3 = &temp3;
3986	>	}else {
3987	>	SWIG_exception(SWIG_TypeError, "string expected");
3988	>	}
3989		}
3990		{
3991		try {
3992	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3992	>	result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
3993
3994	+	}catch (const BossSchedFailure & e) {
3995	+	PyErr_SetString ( SchedulerError, e.what() );
3996	+	return NULL;
3997		}catch (const std::exception& e) {
3998	<	SWIG_exception(SWIG_RuntimeError, e.what());
3998	>	PyErr_SetString ( BossError, e.what() );
3999	>	return NULL;
4000		}
4001		}
4002	<	resultobj = result;
4002	>	{
4003	>	BossProgram * resultptr;
4004	>	resultptr = new BossProgram((BossProgram &) result);
4005	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4006	>	}
4007		return resultobj;
4008		fail:
4009		return NULL;
4010		}
4011
4012
4013	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
4013	>	static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4014		PyObject *resultobj;
4015		BossTask *arg1 = (BossTask *) 0 ;
4016	<	std::string *arg2 = 0 ;
4017	<	PyObject *result;
4018	<	std::string temp2 ;
4016	>	BossJob *arg2 = (BossJob *) 0 ;
4017	>	std::string *arg3 = 0 ;
4018	>	BossProgramExec result;
4019	>	std::string temp3 ;
4020		PyObject * obj0 = 0 ;
4021		PyObject * obj1 = 0 ;
4022	+	PyObject * obj2 = 0 ;
4023
4024	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
4024	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4025		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4026	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4027		{
4028	<	if (PyString_Check(obj1)) {
4029	<	temp2 = std::string(PyString_AsString(obj1));
4030	<	arg2 = &temp2;
4028	>	if (PyString_Check(obj2)) {
4029	>	temp3 = std::string(PyString_AsString(obj2));
4030	>	arg3 = &temp3;
4031		}else {
4032		SWIG_exception(SWIG_TypeError, "string expected");
4033		}
4034		}
4035		{
4036		try {
4037	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
4037	>	result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4038
4039	+	}catch (const BossSchedFailure & e) {
4040	+	PyErr_SetString ( SchedulerError, e.what() );
4041	+	return NULL;
4042		}catch (const std::exception& e) {
4043	<	SWIG_exception(SWIG_RuntimeError, e.what());
4043	>	PyErr_SetString ( BossError, e.what() );
4044	>	return NULL;
4045		}
4046		}
4047	<	resultobj = result;
4047	>	{
4048	>	BossProgramExec * resultptr;
4049	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4050	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4051	>	}
4052		return resultobj;
4053		fail:
4054		return NULL;
#	Line 3079 | Line 4067 | static PyObject *_wrap_new_BossTask__SWI
4067		try {
4068		result = (BossTask *)new BossTask(arg1);
4069
4070	+	}catch (const BossSchedFailure & e) {
4071	+	PyErr_SetString ( SchedulerError, e.what() );
4072	+	return NULL;
4073		}catch (const std::exception& e) {
4074	<	SWIG_exception(SWIG_RuntimeError, e.what());
4074	>	PyErr_SetString ( BossError, e.what() );
4075	>	return NULL;
4076		}
4077		}
4078		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3113 | Line 4105 | static PyObject *_wrap_new_BossTask__SWI
4105		try {
4106		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
4107
4108	+	}catch (const BossSchedFailure & e) {
4109	+	PyErr_SetString ( SchedulerError, e.what() );
4110	+	return NULL;
4111		}catch (const std::exception& e) {
4112	<	SWIG_exception(SWIG_RuntimeError, e.what());
4112	>	PyErr_SetString ( BossError, e.what() );
4113	>	return NULL;
4114		}
4115		}
4116		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3135 | Line 4131 | static PyObject *_wrap_delete_BossTask(P
4131		try {
4132		delete arg1;
4133
4134	+	}catch (const BossSchedFailure & e) {
4135	+	PyErr_SetString ( SchedulerError, e.what() );
4136	+	return NULL;
4137		}catch (const std::exception& e) {
4138	<	SWIG_exception(SWIG_RuntimeError, e.what());
4138	>	PyErr_SetString ( BossError, e.what() );
4139	>	return NULL;
4140		}
4141		}
4142		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3161 | Line 4161 | static PyObject *_wrap_new_BossTask__SWI
4161		try {
4162		result = (BossTask *)new BossTask((BossTask const &)*arg1);
4163
4164	+	}catch (const BossSchedFailure & e) {
4165	+	PyErr_SetString ( SchedulerError, e.what() );
4166	+	return NULL;
4167		}catch (const std::exception& e) {
4168	<	SWIG_exception(SWIG_RuntimeError, e.what());
4168	>	PyErr_SetString ( BossError, e.what() );
4169	>	return NULL;
4170		}
4171		}
4172		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3252 | Line 4256 | static PyObject *_wrap_BossTask_id(PyObj
4256		result = (std::string *) &_result_ref;
4257		}
4258
4259	+	}catch (const BossSchedFailure & e) {
4260	+	PyErr_SetString ( SchedulerError, e.what() );
4261	+	return NULL;
4262		}catch (const std::exception& e) {
4263	<	SWIG_exception(SWIG_RuntimeError, e.what());
4263	>	PyErr_SetString ( BossError, e.what() );
4264	>	return NULL;
4265		}
4266		}
4267		{
#	Line 3280 | Line 4288 | static PyObject *_wrap_BossTask_name(PyO
4288		result = (std::string *) &_result_ref;
4289		}
4290
4291	+	}catch (const BossSchedFailure & e) {
4292	+	PyErr_SetString ( SchedulerError, e.what() );
4293	+	return NULL;
4294		}catch (const std::exception& e) {
4295	<	SWIG_exception(SWIG_RuntimeError, e.what());
4295	>	PyErr_SetString ( BossError, e.what() );
4296	>	return NULL;
4297		}
4298		}
4299		{
#	Line 3293 | Line 4305 | static PyObject *_wrap_BossTask_name(PyO
4305		}
4306
4307
4308	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
4308	>	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4309		PyObject *resultobj;
4310		BossTask *arg1 = (BossTask *) 0 ;
4311	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4311	>	std::string *arg2 = 0 ;
4312	>	BossChain result;
4313	>	std::string temp2 ;
4314		PyObject * obj0 = 0 ;
4315	+	PyObject * obj1 = 0 ;
4316
4317	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4317	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4318		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4319		{
4320	+	if (PyString_Check(obj1)) {
4321	+	temp2 = std::string(PyString_AsString(obj1));
4322	+	arg2 = &temp2;
4323	+	}else {
4324	+	SWIG_exception(SWIG_TypeError, "string expected");
4325	+	}
4326	+	}
4327	+	{
4328		try {
4329	<	result = ((BossTask const *)arg1)->jobsMap();
4329	>	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4330
4331	+	}catch (const BossSchedFailure & e) {
4332	+	PyErr_SetString ( SchedulerError, e.what() );
4333	+	return NULL;
4334		}catch (const std::exception& e) {
4335	<	SWIG_exception(SWIG_RuntimeError, e.what());
4335	>	PyErr_SetString ( BossError, e.what() );
4336	>	return NULL;
4337		}
4338		}
4339		{
4340	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4341	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4342	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4340	>	BossChain * resultptr;
4341	>	resultptr = new BossChain((BossChain &) result);
4342	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4343		}
4344		return resultobj;
4345		fail:
#	Line 3320 | Line 4347 | static PyObject *_wrap_BossTask_jobsMap_
4347		}
4348
4349
4350	<	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4350	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4351		PyObject *resultobj;
4352		BossTask *arg1 = (BossTask *) 0 ;
3326	–	unsigned int arg2 ;
4353		std::map<std::string,std::string > result;
4354		PyObject * obj0 = 0 ;
3329	–	PyObject * obj1 = 0 ;
4355
4356	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4356	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4357		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;
4358		{
4359		try {
4360	<	result = ((BossTask const *)arg1)->jobMap(arg2);
4360	>	result = ((BossTask const *)arg1)->taskMap();
4361
4362	+	}catch (const BossSchedFailure & e) {
4363	+	PyErr_SetString ( SchedulerError, e.what() );
4364	+	return NULL;
4365		}catch (const std::exception& e) {
4366	<	SWIG_exception(SWIG_RuntimeError, e.what());
4366	>	PyErr_SetString ( BossError, e.what() );
4367	>	return NULL;
4368		}
4369		}
4370		{
#	Line 3354 | Line 4381 | static PyObject *_wrap_BossTask_jobMap__
4381		}
4382
4383
4384	<	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4384	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4385	>	PyObject *resultobj;
4386	>	BossTask *arg1 = (BossTask *) 0 ;
4387	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4388	>	PyObject * obj0 = 0 ;
4389	>
4390	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4391	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4392	>	{
4393	>	try {
4394	>	result = ((BossTask const *)arg1)->jobsMap();
4395	>
4396	>	}catch (const BossSchedFailure & e) {
4397	>	PyErr_SetString ( SchedulerError, e.what() );
4398	>	return NULL;
4399	>	}catch (const std::exception& e) {
4400	>	PyErr_SetString ( BossError, e.what() );
4401	>	return NULL;
4402	>	}
4403	>	}
4404	>	{
4405	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4406	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4407	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4408	>	}
4409	>	return resultobj;
4410	>	fail:
4411	>	return NULL;
4412	>	}
4413	>
4414	>
4415	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4416		PyObject *resultobj;
4417		BossTask *arg1 = (BossTask *) 0 ;
4418		SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
#	Line 3377 | Line 4435 | static PyObject *_wrap_BossTask_jobMap__
4435		try {
4436		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4437
4438	+	}catch (const BossSchedFailure & e) {
4439	+	PyErr_SetString ( SchedulerError, e.what() );
4440	+	return NULL;
4441		}catch (const std::exception& e) {
4442	<	SWIG_exception(SWIG_RuntimeError, e.what());
4442	>	PyErr_SetString ( BossError, e.what() );
4443	>	return NULL;
4444		}
4445		}
4446		{
#	Line 3390 | Line 4452 | static PyObject *_wrap_BossTask_jobMap__
4452		}
4453
4454
4455	+	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4456	+	PyObject *resultobj;
4457	+	BossTask *arg1 = (BossTask *) 0 ;
4458	+	unsigned int arg2 ;
4459	+	std::map<std::string,std::string > result;
4460	+	PyObject * obj0 = 0 ;
4461	+	PyObject * obj1 = 0 ;
4462	+
4463	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4464	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4465	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
4466	+	if (PyErr_Occurred()) SWIG_fail;
4467	+	{
4468	+	try {
4469	+	result = ((BossTask const *)arg1)->jobMap(arg2);
4470	+
4471	+	}catch (const BossSchedFailure & e) {
4472	+	PyErr_SetString ( SchedulerError, e.what() );
4473	+	return NULL;
4474	+	}catch (const std::exception& e) {
4475	+	PyErr_SetString ( BossError, e.what() );
4476	+	return NULL;
4477	+	}
4478	+	}
4479	+	{
4480	+	resultobj = PyDict_New();
4481	+	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4482	+	PyDict_SetItem(resultobj,
4483	+	SwigString_FromString(i->first),
4484	+	SwigString_FromString(i->second));
4485	+	}
4486	+	}
4487	+	return resultobj;
4488	+	fail:
4489	+	return NULL;
4490	+	}
4491	+
4492	+
4493		static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4494		int argc;
4495		PyObject *argv[4];
#	Line 3415 | Line 4515 | static PyObject *_wrap_BossTask_jobMap(P
4515		_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4516		}
4517		if (_v) {
4518	<	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4518	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4519		}
4520		}
4521		}
#	Line 3451 | Line 4551 | static PyObject *_wrap_BossTask_jobMap(P
4551		}
4552		}
4553		if (_v) {
4554	<	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4554	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4555		}
4556		}
4557		}
#	Line 3462 | Line 4562 | static PyObject *_wrap_BossTask_jobMap(P
4562		}
4563
4564
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	–
4565		static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4566		PyObject *resultobj;
4567		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3561 | Line 4577 | static PyObject *_wrap_BossTask_programs
4577		try {
4578		result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4579
4580	+	}catch (const BossSchedFailure & e) {
4581	+	PyErr_SetString ( SchedulerError, e.what() );
4582	+	return NULL;
4583		}catch (const std::exception& e) {
4584	<	SWIG_exception(SWIG_RuntimeError, e.what());
4584	>	PyErr_SetString ( BossError, e.what() );
4585	>	return NULL;
4586		}
4587		}
4588		{
#	Line 3612 | Line 4632 | static PyObject *_wrap_BossTask_declare_
4632		try {
4633		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4634
4635	+	}catch (const BossSchedFailure & e) {
4636	+	PyErr_SetString ( SchedulerError, e.what() );
4637	+	return NULL;
4638		}catch (const std::exception& e) {
4639	<	SWIG_exception(SWIG_RuntimeError, e.what());
4639	>	PyErr_SetString ( BossError, e.what() );
4640	>	return NULL;
4641		}
4642		}
4643		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3651 | Line 4675 | static PyObject *_wrap_BossTask_declare_
4675		try {
4676		(arg1)->declare(arg2,(std::string const &)*arg3);
4677
4678	+	}catch (const BossSchedFailure & e) {
4679	+	PyErr_SetString ( SchedulerError, e.what() );
4680	+	return NULL;
4681		}catch (const std::exception& e) {
4682	<	SWIG_exception(SWIG_RuntimeError, e.what());
4682	>	PyErr_SetString ( BossError, e.what() );
4683	>	return NULL;
4684		}
4685		}
4686		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3750 | Line 4778 | static PyObject *_wrap_BossTask_remove(P
4778		try {
4779		(arg1)->remove();
4780
4781	+	}catch (const BossSchedFailure & e) {
4782	+	PyErr_SetString ( SchedulerError, e.what() );
4783	+	return NULL;
4784		}catch (const std::exception& e) {
4785	<	SWIG_exception(SWIG_RuntimeError, e.what());
4785	>	PyErr_SetString ( BossError, e.what() );
4786	>	return NULL;
4787		}
4788		}
4789		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3786 | Line 4818 | static PyObject *_wrap_BossTask_archive(
4818		try {
4819		(arg1)->archive((std::string const &)*arg2);
4820
4821	+	}catch (const BossSchedFailure & e) {
4822	+	PyErr_SetString ( SchedulerError, e.what() );
4823	+	return NULL;
4824		}catch (const std::exception& e) {
4825	<	SWIG_exception(SWIG_RuntimeError, e.what());
4825	>	PyErr_SetString ( BossError, e.what() );
4826	>	return NULL;
4827		}
4828		}
4829		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3797 | Line 4833 | static PyObject *_wrap_BossTask_archive(
4833		}
4834
4835
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	–
4836		static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4837		PyObject *resultobj;
4838		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3840 | Line 4846 | static PyObject *_wrap_BossTask_submit(P
4846		std::string *arg5 = (std::string *) &arg5_defvalue ;
4847		std::string const &arg6_defvalue = "" ;
4848		std::string *arg6 = (std::string *) &arg6_defvalue ;
4849	<	bool arg7 = (bool) false ;
4849	>	unsigned int arg7 = (unsigned int) 0 ;
4850	>	bool arg8 = (bool) false ;
4851		int result;
4852		std::string temp2 ;
4853		std::string temp3 ;
#	Line 3854 | Line 4861 | static PyObject *_wrap_BossTask_submit(P
4861		PyObject * obj4 = 0 ;
4862		PyObject * obj5 = 0 ;
4863		PyObject * obj6 = 0 ;
4864	+	PyObject * obj7 = 0 ;
4865
4866	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4866	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4867		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4868		if (obj1) {
4869		{
#	Line 3908 | Line 4916 | static PyObject *_wrap_BossTask_submit(P
4916		}
4917		}
4918		if (obj6) {
4919	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4919	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4920	>	if (PyErr_Occurred()) SWIG_fail;
4921	>	}
4922	>	if (obj7) {
4923	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4924		if (PyErr_Occurred()) SWIG_fail;
4925		}
4926		{
4927		try {
4928	<	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);
4928	>	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);
4929
4930	+	}catch (const BossSchedFailure & e) {
4931	+	PyErr_SetString ( SchedulerError, e.what() );
4932	+	return NULL;
4933		}catch (const std::exception& e) {
4934	<	SWIG_exception(SWIG_RuntimeError, e.what());
4934	>	PyErr_SetString ( BossError, e.what() );
4935	>	return NULL;
4936		}
4937		}
4938		resultobj = PyInt_FromLong((long)result);
#	Line 3955 | Line 4971 | static PyObject *_wrap_BossTask_reSubmit
4971		try {
4972		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4973
4974	+	}catch (const BossSchedFailure & e) {
4975	+	PyErr_SetString ( SchedulerError, e.what() );
4976	+	return NULL;
4977		}catch (const std::exception& e) {
4978	<	SWIG_exception(SWIG_RuntimeError, e.what());
4978	>	PyErr_SetString ( BossError, e.what() );
4979	>	return NULL;
4980		}
4981		}
4982		resultobj = PyInt_FromLong((long)result);
#	Line 3970 | Line 4990 | static PyObject *_wrap_BossTask_kill(PyO
4990		PyObject *resultobj;
4991		BossTask *arg1 = (BossTask *) 0 ;
4992		std::string *arg2 = 0 ;
4993	<	bool arg3 = (bool) false ;
4993	>	unsigned int arg3 = (unsigned int) 0 ;
4994	>	bool arg4 = (bool) false ;
4995		int result;
4996		std::string temp2 ;
4997		PyObject * obj0 = 0 ;
4998		PyObject * obj1 = 0 ;
4999		PyObject * obj2 = 0 ;
5000	+	PyObject * obj3 = 0 ;
5001
5002	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
5002	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
5003		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5004		{
5005		if (PyString_Check(obj1)) {
#	Line 3988 | Line 5010 | static PyObject *_wrap_BossTask_kill(PyO
5010		}
5011		}
5012		if (obj2) {
5013	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5013	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
5014	>	if (PyErr_Occurred()) SWIG_fail;
5015	>	}
5016	>	if (obj3) {
5017	>	arg4 = PyInt_AsLong(obj3) ? true : false;
5018		if (PyErr_Occurred()) SWIG_fail;
5019		}
5020		{
5021		try {
5022	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
5022	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
5023
5024	+	}catch (const BossSchedFailure & e) {
5025	+	PyErr_SetString ( SchedulerError, e.what() );
5026	+	return NULL;
5027		}catch (const std::exception& e) {
5028	<	SWIG_exception(SWIG_RuntimeError, e.what());
5028	>	PyErr_SetString ( BossError, e.what() );
5029	>	return NULL;
5030		}
5031		}
5032		resultobj = PyInt_FromLong((long)result);
#	Line 4006 | Line 5036 | static PyObject *_wrap_BossTask_kill(PyO
5036		}
5037
5038
5039	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
5039	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
5040		PyObject *resultobj;
5041		BossTask *arg1 = (BossTask *) 0 ;
5042		std::string const &arg2_defvalue = "all" ;
5043		std::string *arg2 = (std::string *) &arg2_defvalue ;
5044		std::string const &arg3_defvalue = "" ;
5045		std::string *arg3 = (std::string *) &arg3_defvalue ;
5046	<	bool arg4 = (bool) false ;
5046	>	unsigned int arg4 = (unsigned int) 0 ;
5047		bool arg5 = (bool) false ;
5048	+	bool arg6 = (bool) false ;
5049		int result;
5050		std::string temp2 ;
5051		std::string temp3 ;
#	Line 4023 | Line 5054 | static PyObject *_wrap_BossTask_getOutpu
5054		PyObject * obj2 = 0 ;
5055		PyObject * obj3 = 0 ;
5056		PyObject * obj4 = 0 ;
5057	+	PyObject * obj5 = 0 ;
5058
5059	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5059	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5060		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5061		if (obj1) {
5062		{
#	Line 4047 | Line 5079 | static PyObject *_wrap_BossTask_getOutpu
5079		}
5080		}
5081		if (obj3) {
5082	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5082	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
5083		if (PyErr_Occurred()) SWIG_fail;
5084		}
5085		if (obj4) {
5086		arg5 = PyInt_AsLong(obj4) ? true : false;
5087		if (PyErr_Occurred()) SWIG_fail;
5088		}
5089	+	if (obj5) {
5090	+	arg6 = PyInt_AsLong(obj5) ? true : false;
5091	+	if (PyErr_Occurred()) SWIG_fail;
5092	+	}
5093		{
5094		try {
5095	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
5095	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
5096
5097	+	}catch (const BossSchedFailure & e) {
5098	+	PyErr_SetString ( SchedulerError, e.what() );
5099	+	return NULL;
5100		}catch (const std::exception& e) {
5101	<	SWIG_exception(SWIG_RuntimeError, e.what());
5101	>	PyErr_SetString ( BossError, e.what() );
5102	>	return NULL;
5103		}
5104		}
5105		resultobj = PyInt_FromLong((long)result);
#	Line 4069 | Line 5109 | static PyObject *_wrap_BossTask_getOutpu
5109		}
5110
5111
5112	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
5112	>	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
5113		PyObject *resultobj;
5114		BossTask *arg1 = (BossTask *) 0 ;
5115	<	std::string const &arg2_defvalue = "" ;
4076	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
4077	<	bool arg3 = (bool) false ;
4078	<	bool arg4 = (bool) false ;
5115	>	std::string *arg2 = 0 ;
5116		int result;
5117		std::string temp2 ;
5118		PyObject * obj0 = 0 ;
5119		PyObject * obj1 = 0 ;
5120	+
5121	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5122	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5123	+	{
5124	+	if (PyString_Check(obj1)) {
5125	+	temp2 = std::string(PyString_AsString(obj1));
5126	+	arg2 = &temp2;
5127	+	}else {
5128	+	SWIG_exception(SWIG_TypeError, "string expected");
5129	+	}
5130	+	}
5131	+	{
5132	+	try {
5133	+	result = (int)(arg1)->loadByName((std::string const &)*arg2);
5134	+
5135	+	}catch (const BossSchedFailure & e) {
5136	+	PyErr_SetString ( SchedulerError, e.what() );
5137	+	return NULL;
5138	+	}catch (const std::exception& e) {
5139	+	PyErr_SetString ( BossError, e.what() );
5140	+	return NULL;
5141	+	}
5142	+	}
5143	+	resultobj = PyInt_FromLong((long)result);
5144	+	return resultobj;
5145	+	fail:
5146	+	return NULL;
5147	+	}
5148	+
5149	+
5150	+	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
5151	+	PyObject *resultobj;
5152	+	BossTask *arg1 = (BossTask *) 0 ;
5153	+	int arg2 = (int) SCHEDULED ;
5154	+	std::string const &arg3_defvalue = "all" ;
5155	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
5156	+	std::string const &arg4_defvalue = "" ;
5157	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
5158	+	std::string arg5 = (std::string) "" ;
5159	+	std::string arg6 = (std::string) "" ;
5160	+	std::string arg7 = (std::string) "" ;
5161	+	std::string arg8 = (std::string) "" ;
5162	+	int result;
5163	+	std::string temp3 ;
5164	+	std::string temp4 ;
5165	+	PyObject * obj0 = 0 ;
5166		PyObject * obj2 = 0 ;
5167		PyObject * obj3 = 0 ;
5168	+	PyObject * obj4 = 0 ;
5169	+	PyObject * obj5 = 0 ;
5170	+	PyObject * obj6 = 0 ;
5171	+	PyObject * obj7 = 0 ;
5172
5173	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
5173	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5174		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5175	<	if (obj1) {
5175	>	if (obj2) {
5176		{
5177	<	if (PyString_Check(obj1)) {
5178	<	temp2 = std::string(PyString_AsString(obj1));
5179	<	arg2 = &temp2;
5177	>	if (PyString_Check(obj2)) {
5178	>	temp3 = std::string(PyString_AsString(obj2));
5179	>	arg3 = &temp3;
5180		}else {
5181		SWIG_exception(SWIG_TypeError, "string expected");
5182		}
5183		}
5184		}
4098	–	if (obj2) {
4099	–	arg3 = PyInt_AsLong(obj2) ? true : false;
4100	–	if (PyErr_Occurred()) SWIG_fail;
4101	–	}
5185		if (obj3) {
5186	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5187	<	if (PyErr_Occurred()) SWIG_fail;
5186	>	{
5187	>	if (PyString_Check(obj3)) {
5188	>	temp4 = std::string(PyString_AsString(obj3));
5189	>	arg4 = &temp4;
5190	>	}else {
5191	>	SWIG_exception(SWIG_TypeError, "string expected");
5192	>	}
5193	>	}
5194	>	}
5195	>	if (obj4) {
5196	>	{
5197	>	if (PyString_Check(obj4))
5198	>	arg5 = std::string(PyString_AsString(obj4));
5199	>	else
5200	>	SWIG_exception(SWIG_TypeError, "string expected");
5201	>	}
5202	>	}
5203	>	if (obj5) {
5204	>	{
5205	>	if (PyString_Check(obj5))
5206	>	arg6 = std::string(PyString_AsString(obj5));
5207	>	else
5208	>	SWIG_exception(SWIG_TypeError, "string expected");
5209	>	}
5210	>	}
5211	>	if (obj6) {
5212	>	{
5213	>	if (PyString_Check(obj6))
5214	>	arg7 = std::string(PyString_AsString(obj6));
5215	>	else
5216	>	SWIG_exception(SWIG_TypeError, "string expected");
5217	>	}
5218	>	}
5219	>	if (obj7) {
5220	>	{
5221	>	if (PyString_Check(obj7))
5222	>	arg8 = std::string(PyString_AsString(obj7));
5223	>	else
5224	>	SWIG_exception(SWIG_TypeError, "string expected");
5225	>	}
5226		}
5227		{
5228		try {
5229	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
5229	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
5230
5231	+	}catch (const BossSchedFailure & e) {
5232	+	PyErr_SetString ( SchedulerError, e.what() );
5233	+	return NULL;
5234		}catch (const std::exception& e) {
5235	<	SWIG_exception(SWIG_RuntimeError, e.what());
5235	>	PyErr_SetString ( BossError, e.what() );
5236	>	return NULL;
5237		}
5238		}
5239		resultobj = PyInt_FromLong((long)result);
#	Line 4118 | Line 5243 | static PyObject *_wrap_BossTask_getOutpu
5243		}
5244
5245
5246	<	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
5247	<	int argc;
5248	<	PyObject *argv[6];
5249	<	int ii;
5246	>	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5247	>	PyObject *resultobj;
5248	>	BossTask *arg1 = (BossTask *) 0 ;
5249	>	int arg2 = (int) SCHEDULED ;
5250	>	std::string const &arg3_defvalue = "all" ;
5251	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
5252	>	std::string const &arg4_defvalue = "" ;
5253	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
5254	>	std::string arg5 = (std::string) "" ;
5255	>	std::string arg6 = (std::string) "" ;
5256	>	std::string arg7 = (std::string) "" ;
5257	>	std::string arg8 = (std::string) "" ;
5258	>	unsigned int arg9 = (unsigned int) 0 ;
5259	>	int result;
5260	>	std::string temp3 ;
5261	>	std::string temp4 ;
5262	>	PyObject * obj0 = 0 ;
5263	>	PyObject * obj2 = 0 ;
5264	>	PyObject * obj3 = 0 ;
5265	>	PyObject * obj4 = 0 ;
5266	>	PyObject * obj5 = 0 ;
5267	>	PyObject * obj6 = 0 ;
5268	>	PyObject * obj7 = 0 ;
5269	>	PyObject * obj8 = 0 ;
5270
5271	<	argc = PyObject_Length(args);
5272	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
5273	<	argv[ii] = PyTuple_GetItem(args,ii);
4129	<	}
4130	<	if ((argc >= 1) && (argc <= 5)) {
4131	<	int _v;
5271	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5272	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5273	>	if (obj2) {
5274		{
5275	<	void *ptr;
5276	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5277	<	_v = 0;
4136	<	PyErr_Clear();
5275	>	if (PyString_Check(obj2)) {
5276	>	temp3 = std::string(PyString_AsString(obj2));
5277	>	arg3 = &temp3;
5278		}else {
5279	<	_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	<	}
5279	>	SWIG_exception(SWIG_TypeError, "string expected");
5280		}
5281		}
5282		}
5283	<	if ((argc >= 1) && (argc <= 4)) {
4178	<	int _v;
5283	>	if (obj3) {
5284		{
5285	<	void *ptr;
5286	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5287	<	_v = 0;
4183	<	PyErr_Clear();
5285	>	if (PyString_Check(obj3)) {
5286	>	temp4 = std::string(PyString_AsString(obj3));
5287	>	arg4 = &temp4;
5288		}else {
5289	<	_v = 1;
5289	>	SWIG_exception(SWIG_TypeError, "string expected");
5290		}
5291		}
5292	<	if (_v) {
5293	<	if (argc <= 1) {
5294	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
5295	<	}
5296	<	{
5297	<	_v = PyString_Check(argv[1]) ? 1 : 0;
5298	<	}
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	<	}
5292	>	}
5293	>	if (obj4) {
5294	>	{
5295	>	if (PyString_Check(obj4))
5296	>	arg5 = std::string(PyString_AsString(obj4));
5297	>	else
5298	>	SWIG_exception(SWIG_TypeError, "string expected");
5299		}
5300		}
5301	<
5302	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
5301	>	if (obj5) {
5302	>	{
5303	>	if (PyString_Check(obj5))
5304	>	arg6 = std::string(PyString_AsString(obj5));
5305	>	else
5306	>	SWIG_exception(SWIG_TypeError, "string expected");
5307	>	}
5308	>	}
5309	>	if (obj6) {
5310	>	{
5311	>	if (PyString_Check(obj6))
5312	>	arg7 = std::string(PyString_AsString(obj6));
5313	>	else
5314	>	SWIG_exception(SWIG_TypeError, "string expected");
5315	>	}
5316	>	}
5317	>	if (obj7) {
5318	>	{
5319	>	if (PyString_Check(obj7))
5320	>	arg8 = std::string(PyString_AsString(obj7));
5321	>	else
5322	>	SWIG_exception(SWIG_TypeError, "string expected");
5323	>	}
5324	>	}
5325	>	if (obj8) {
5326	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5327	>	if (PyErr_Occurred()) SWIG_fail;
5328	>	}
5329	>	{
5330	>	try {
5331	>	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5332	>
5333	>	}catch (const BossSchedFailure & e) {
5334	>	PyErr_SetString ( SchedulerError, e.what() );
5335	>	return NULL;
5336	>	}catch (const std::exception& e) {
5337	>	PyErr_SetString ( BossError, e.what() );
5338	>	return NULL;
5339	>	}
5340	>	}
5341	>	resultobj = PyInt_FromLong((long)result);
5342	>	return resultobj;
5343	>	fail:
5344		return NULL;
5345		}
5346
#	Line 4231 | Line 5357 | static PyObject *_wrap_BossTask_query(Py
5357		std::string arg6 = (std::string) "" ;
5358		std::string arg7 = (std::string) "" ;
5359		std::string arg8 = (std::string) "" ;
5360	<	bool arg9 = (bool) false ;
5360	>	unsigned int arg9 = (unsigned int) 0 ;
5361	>	bool arg10 = (bool) false ;
5362		int result;
5363		std::string temp3 ;
5364		std::string temp4 ;
#	Line 4243 | Line 5370 | static PyObject *_wrap_BossTask_query(Py
5370		PyObject * obj6 = 0 ;
5371		PyObject * obj7 = 0 ;
5372		PyObject * obj8 = 0 ;
5373	+	PyObject * obj9 = 0 ;
5374
5375	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5375	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5376		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5377		if (obj2) {
5378		{
#	Line 4299 | Line 5427 | static PyObject *_wrap_BossTask_query(Py
5427		}
5428		}
5429		if (obj8) {
5430	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5430	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5431	>	if (PyErr_Occurred()) SWIG_fail;
5432	>	}
5433	>	if (obj9) {
5434	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5435		if (PyErr_Occurred()) SWIG_fail;
5436		}
5437		{
5438		try {
5439	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5439	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5440
5441	+	}catch (const BossSchedFailure & e) {
5442	+	PyErr_SetString ( SchedulerError, e.what() );
5443	+	return NULL;
5444		}catch (const std::exception& e) {
5445	<	SWIG_exception(SWIG_RuntimeError, e.what());
5445	>	PyErr_SetString ( BossError, e.what() );
5446	>	return NULL;
5447		}
5448		}
5449		resultobj = PyInt_FromLong((long)result);
#	Line 4365 | Line 5501 | static PyObject *_wrap_BossTask_query_ou
5501		try {
5502		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5503
5504	+	}catch (const BossSchedFailure & e) {
5505	+	PyErr_SetString ( SchedulerError, e.what() );
5506	+	return NULL;
5507		}catch (const std::exception& e) {
5508	<	SWIG_exception(SWIG_RuntimeError, e.what());
5508	>	PyErr_SetString ( BossError, e.what() );
5509	>	return NULL;
5510		}
5511		}
5512		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4387 | Line 5527 | static PyObject *_wrap_BossTask_clear(Py
5527		try {
5528		(arg1)->clear();
5529
5530	+	}catch (const BossSchedFailure & e) {
5531	+	PyErr_SetString ( SchedulerError, e.what() );
5532	+	return NULL;
5533	+	}catch (const std::exception& e) {
5534	+	PyErr_SetString ( BossError, e.what() );
5535	+	return NULL;
5536	+	}
5537	+	}
5538	+	Py_INCREF(Py_None); resultobj = Py_None;
5539	+	return resultobj;
5540	+	fail:
5541	+	return NULL;
5542	+	}
5543	+
5544	+
5545	+	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5546	+	PyObject *resultobj;
5547	+	BossTask *arg1 = (BossTask *) 0 ;
5548	+	PyObject *arg2 = (PyObject *) 0 ;
5549	+	BossAttributeContainer *arg3 = 0 ;
5550	+	PyObject * obj0 = 0 ;
5551	+	PyObject * obj1 = 0 ;
5552	+	PyObject * obj2 = 0 ;
5553	+
5554	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5555	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5556	+	arg2 = obj1;
5557	+	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5558	+	if (arg3 == NULL) {
5559	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5560	+	}
5561	+	{
5562	+	try {
5563	+	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5564	+
5565	+	}catch (const BossSchedFailure & e) {
5566	+	PyErr_SetString ( SchedulerError, e.what() );
5567	+	return NULL;
5568		}catch (const std::exception& e) {
5569	<	SWIG_exception(SWIG_RuntimeError, e.what());
5569	>	PyErr_SetString ( BossError, e.what() );
5570	>	return NULL;
5571		}
5572		}
5573		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4398 | Line 5577 | static PyObject *_wrap_BossTask_clear(Py
5577		}
5578
5579
5580	<	static PyObject *_wrap_BossTask_prompt(PyObject *self, PyObject *args) {
5580	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5581	>	PyObject *resultobj;
5582	>	BossTask *arg1 = (BossTask *) 0 ;
5583	>	BossJob *arg2 = (BossJob *) 0 ;
5584	>	PyObject *arg3 = (PyObject *) 0 ;
5585	>	PyObject * obj0 = 0 ;
5586	>	PyObject * obj1 = 0 ;
5587	>	PyObject * obj2 = 0 ;
5588	>
5589	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5590	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5591	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5592	>	arg3 = obj2;
5593	>	{
5594	>	try {
5595	>	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5596	>
5597	>	}catch (const BossSchedFailure & e) {
5598	>	PyErr_SetString ( SchedulerError, e.what() );
5599	>	return NULL;
5600	>	}catch (const std::exception& e) {
5601	>	PyErr_SetString ( BossError, e.what() );
5602	>	return NULL;
5603	>	}
5604	>	}
5605	>	Py_INCREF(Py_None); resultobj = Py_None;
5606	>	return resultobj;
5607	>	fail:
5608	>	return NULL;
5609	>	}
5610	>
5611	>
5612	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5613	>	PyObject *resultobj;
5614	>	BossTask *arg1 = (BossTask *) 0 ;
5615	>	PyObject *result;
5616	>	PyObject * obj0 = 0 ;
5617	>
5618	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5619	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5620	>	{
5621	>	try {
5622	>	result = (PyObject *)BossTask_jobsDict(arg1);
5623	>
5624	>	}catch (const BossSchedFailure & e) {
5625	>	PyErr_SetString ( SchedulerError, e.what() );
5626	>	return NULL;
5627	>	}catch (const std::exception& e) {
5628	>	PyErr_SetString ( BossError, e.what() );
5629	>	return NULL;
5630	>	}
5631	>	}
5632	>	resultobj = result;
5633	>	return resultobj;
5634	>	fail:
5635	>	return NULL;
5636	>	}
5637	>
5638	>
5639	>	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5640		PyObject *resultobj;
5641		BossTask *arg1 = (BossTask *) 0 ;
5642		std::string *arg2 = 0 ;
5643	<	bool result;
5643	>	PyObject *result;
5644		std::string temp2 ;
5645		PyObject * obj0 = 0 ;
5646		PyObject * obj1 = 0 ;
5647
5648	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_prompt",&obj0,&obj1)) goto fail;
5648	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5649		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5650		{
5651		if (PyString_Check(obj1)) {
#	Line 4419 | Line 5657 | static PyObject *_wrap_BossTask_prompt(P
5657		}
5658		{
5659		try {
5660	<	result = (bool)(arg1)->prompt((std::string const &)*arg2);
5660	>	result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5661
5662	+	}catch (const BossSchedFailure & e) {
5663	+	PyErr_SetString ( SchedulerError, e.what() );
5664	+	return NULL;
5665		}catch (const std::exception& e) {
5666	<	SWIG_exception(SWIG_RuntimeError, e.what());
5666	>	PyErr_SetString ( BossError, e.what() );
5667	>	return NULL;
5668		}
5669		}
5670	<	resultobj = PyInt_FromLong((long)result);
5670	>	resultobj = result;
5671	>	return resultobj;
5672	>	fail:
5673	>	return NULL;
5674	>	}
5675	>
5676	>
5677	>	static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
5678	>	PyObject *resultobj;
5679	>	BossTask *arg1 = (BossTask *) 0 ;
5680	>	std::string *arg2 = 0 ;
5681	>	PyObject *result;
5682	>	std::string temp2 ;
5683	>	PyObject * obj0 = 0 ;
5684	>	PyObject * obj1 = 0 ;
5685	>
5686	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5687	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5688	>	{
5689	>	if (PyString_Check(obj1)) {
5690	>	temp2 = std::string(PyString_AsString(obj1));
5691	>	arg2 = &temp2;
5692	>	}else {
5693	>	SWIG_exception(SWIG_TypeError, "string expected");
5694	>	}
5695	>	}
5696	>	{
5697	>	try {
5698	>	result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
5699	>
5700	>	}catch (const BossSchedFailure & e) {
5701	>	PyErr_SetString ( SchedulerError, e.what() );
5702	>	return NULL;
5703	>	}catch (const std::exception& e) {
5704	>	PyErr_SetString ( BossError, e.what() );
5705	>	return NULL;
5706	>	}
5707	>	}
5708	>	resultobj = result;
5709	>	return resultobj;
5710	>	fail:
5711	>	return NULL;
5712	>	}
5713	>
5714	>
5715	>	static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5716	>	PyObject *resultobj;
5717	>	BossTask *arg1 = (BossTask *) 0 ;
5718	>	PyObject *result;
5719	>	PyObject * obj0 = 0 ;
5720	>
5721	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5722	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5723	>	{
5724	>	try {
5725	>	result = (PyObject *)BossTask_jobStates(arg1);
5726	>
5727	>	}catch (const BossSchedFailure & e) {
5728	>	PyErr_SetString ( SchedulerError, e.what() );
5729	>	return NULL;
5730	>	}catch (const std::exception& e) {
5731	>	PyErr_SetString ( BossError, e.what() );
5732	>	return NULL;
5733	>	}
5734	>	}
5735	>	resultobj = result;
5736	>	return resultobj;
5737	>	fail:
5738	>	return NULL;
5739	>	}
5740	>
5741	>
5742	>	static PyObject *_wrap_BossTask_joblist(PyObject *self, PyObject *args) {
5743	>	PyObject *resultobj;
5744	>	BossTask *arg1 = (BossTask *) 0 ;
5745	>	PyObject *result;
5746	>	PyObject * obj0 = 0 ;
5747	>
5748	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_joblist",&obj0)) goto fail;
5749	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5750	>	{
5751	>	try {
5752	>	result = (PyObject *)BossTask_joblist(arg1);
5753	>
5754	>	}catch (const BossSchedFailure & e) {
5755	>	PyErr_SetString ( SchedulerError, e.what() );
5756	>	return NULL;
5757	>	}catch (const std::exception& e) {
5758	>	PyErr_SetString ( BossError, e.what() );
5759	>	return NULL;
5760	>	}
5761	>	}
5762	>	resultobj = result;
5763	>	return resultobj;
5764	>	fail:
5765	>	return NULL;
5766	>	}
5767	>
5768	>
5769	>	static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5770	>	PyObject *resultobj;
5771	>	BossTask *arg1 = (BossTask *) 0 ;
5772	>	PyObject *result;
5773	>	PyObject * obj0 = 0 ;
5774	>
5775	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5776	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5777	>	{
5778	>	try {
5779	>	result = (PyObject *)BossTask_jobStatistic(arg1);
5780	>
5781	>	}catch (const BossSchedFailure & e) {
5782	>	PyErr_SetString ( SchedulerError, e.what() );
5783	>	return NULL;
5784	>	}catch (const std::exception& e) {
5785	>	PyErr_SetString ( BossError, e.what() );
5786	>	return NULL;
5787	>	}
5788	>	}
5789	>	resultobj = result;
5790	>	return resultobj;
5791	>	fail:
5792	>	return NULL;
5793	>	}
5794	>
5795	>
5796	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5797	>	PyObject *resultobj;
5798	>	BossTask *arg1 = (BossTask *) 0 ;
5799	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5800	>	PyObject *result;
5801	>	PyObject * obj0 = 0 ;
5802	>	PyObject * obj1 = 0 ;
5803	>
5804	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5805	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5806	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5807	>	if (arg2 == NULL) {
5808	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5809	>	}
5810	>	{
5811	>	try {
5812	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5813	>
5814	>	}catch (const BossSchedFailure & e) {
5815	>	PyErr_SetString ( SchedulerError, e.what() );
5816	>	return NULL;
5817	>	}catch (const std::exception& e) {
5818	>	PyErr_SetString ( BossError, e.what() );
5819	>	return NULL;
5820	>	}
5821	>	}
5822	>	resultobj = result;
5823	>	return resultobj;
5824	>	fail:
5825	>	return NULL;
5826	>	}
5827	>
5828	>
5829	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5830	>	PyObject *resultobj;
5831	>	BossTask *arg1 = (BossTask *) 0 ;
5832	>	std::string *arg2 = 0 ;
5833	>	PyObject *result;
5834	>	std::string temp2 ;
5835	>	PyObject * obj0 = 0 ;
5836	>	PyObject * obj1 = 0 ;
5837	>
5838	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5839	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5840	>	{
5841	>	if (PyString_Check(obj1)) {
5842	>	temp2 = std::string(PyString_AsString(obj1));
5843	>	arg2 = &temp2;
5844	>	}else {
5845	>	SWIG_exception(SWIG_TypeError, "string expected");
5846	>	}
5847	>	}
5848	>	{
5849	>	try {
5850	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5851	>
5852	>	}catch (const BossSchedFailure & e) {
5853	>	PyErr_SetString ( SchedulerError, e.what() );
5854	>	return NULL;
5855	>	}catch (const std::exception& e) {
5856	>	PyErr_SetString ( BossError, e.what() );
5857	>	return NULL;
5858	>	}
5859	>	}
5860	>	resultobj = result;
5861	>	return resultobj;
5862	>	fail:
5863	>	return NULL;
5864	>	}
5865	>
5866	>
5867	>	static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5868	>	PyObject *resultobj;
5869	>	BossTask *arg1 = (BossTask *) 0 ;
5870	>	std::string *arg2 = 0 ;
5871	>	std::string *arg3 = 0 ;
5872	>	PyObject *result;
5873	>	std::string temp2 ;
5874	>	std::string temp3 ;
5875	>	PyObject * obj0 = 0 ;
5876	>	PyObject * obj1 = 0 ;
5877	>	PyObject * obj2 = 0 ;
5878	>
5879	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5880	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5881	>	{
5882	>	if (PyString_Check(obj1)) {
5883	>	temp2 = std::string(PyString_AsString(obj1));
5884	>	arg2 = &temp2;
5885	>	}else {
5886	>	SWIG_exception(SWIG_TypeError, "string expected");
5887	>	}
5888	>	}
5889	>	{
5890	>	if (PyString_Check(obj2)) {
5891	>	temp3 = std::string(PyString_AsString(obj2));
5892	>	arg3 = &temp3;
5893	>	}else {
5894	>	SWIG_exception(SWIG_TypeError, "string expected");
5895	>	}
5896	>	}
5897	>	{
5898	>	try {
5899	>	result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5900	>
5901	>	}catch (const BossSchedFailure & e) {
5902	>	PyErr_SetString ( SchedulerError, e.what() );
5903	>	return NULL;
5904	>	}catch (const std::exception& e) {
5905	>	PyErr_SetString ( BossError, e.what() );
5906	>	return NULL;
5907	>	}
5908	>	}
5909	>	resultobj = result;
5910	>	return resultobj;
5911	>	fail:
5912	>	return NULL;
5913	>	}
5914	>
5915	>
5916	>	static PyObject *_wrap_BossTask_programExec(PyObject *self, PyObject *args) {
5917	>	PyObject *resultobj;
5918	>	BossTask *arg1 = (BossTask *) 0 ;
5919	>	std::string *arg2 = 0 ;
5920	>	std::string *arg3 = 0 ;
5921	>	PyObject *result;
5922	>	std::string temp2 ;
5923	>	std::string temp3 ;
5924	>	PyObject * obj0 = 0 ;
5925	>	PyObject * obj1 = 0 ;
5926	>	PyObject * obj2 = 0 ;
5927	>
5928	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
5929	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5930	>	{
5931	>	if (PyString_Check(obj1)) {
5932	>	temp2 = std::string(PyString_AsString(obj1));
5933	>	arg2 = &temp2;
5934	>	}else {
5935	>	SWIG_exception(SWIG_TypeError, "string expected");
5936	>	}
5937	>	}
5938	>	{
5939	>	if (PyString_Check(obj2)) {
5940	>	temp3 = std::string(PyString_AsString(obj2));
5941	>	arg3 = &temp3;
5942	>	}else {
5943	>	SWIG_exception(SWIG_TypeError, "string expected");
5944	>	}
5945	>	}
5946	>	{
5947	>	try {
5948	>	result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5949	>
5950	>	}catch (const BossSchedFailure & e) {
5951	>	PyErr_SetString ( SchedulerError, e.what() );
5952	>	return NULL;
5953	>	}catch (const std::exception& e) {
5954	>	PyErr_SetString ( BossError, e.what() );
5955	>	return NULL;
5956	>	}
5957	>	}
5958	>	resultobj = result;
5959	>	return resultobj;
5960	>	fail:
5961	>	return NULL;
5962	>	}
5963	>
5964	>
5965	>	static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
5966	>	PyObject *resultobj;
5967	>	BossTask *arg1 = (BossTask *) 0 ;
5968	>	std::string *arg2 = 0 ;
5969	>	std::string *arg3 = 0 ;
5970	>	PyObject *result;
5971	>	std::string temp2 ;
5972	>	std::string temp3 ;
5973	>	PyObject * obj0 = 0 ;
5974	>	PyObject * obj1 = 0 ;
5975	>	PyObject * obj2 = 0 ;
5976	>
5977	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
5978	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5979	>	{
5980	>	if (PyString_Check(obj1)) {
5981	>	temp2 = std::string(PyString_AsString(obj1));
5982	>	arg2 = &temp2;
5983	>	}else {
5984	>	SWIG_exception(SWIG_TypeError, "string expected");
5985	>	}
5986	>	}
5987	>	{
5988	>	if (PyString_Check(obj2)) {
5989	>	temp3 = std::string(PyString_AsString(obj2));
5990	>	arg3 = &temp3;
5991	>	}else {
5992	>	SWIG_exception(SWIG_TypeError, "string expected");
5993	>	}
5994	>	}
5995	>	{
5996	>	try {
5997	>	result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5998	>
5999	>	}catch (const BossSchedFailure & e) {
6000	>	PyErr_SetString ( SchedulerError, e.what() );
6001	>	return NULL;
6002	>	}catch (const std::exception& e) {
6003	>	PyErr_SetString ( BossError, e.what() );
6004	>	return NULL;
6005	>	}
6006	>	}
6007	>	resultobj = result;
6008		return resultobj;
6009		fail:
6010		return NULL;
#	Line 4442 | Line 6021 | static PyObject * BossTask_swigregister(
6021		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
6022		PyObject *resultobj;
6023		std::string arg1 = (std::string) "" ;
6024	<	bool arg2 = (bool) false ;
6024	>	std::string arg2 = (std::string) "2" ;
6025	>	std::string arg3 = (std::string) "" ;
6026	>	std::string arg4 = (std::string) "" ;
6027	>	bool arg5 = (bool) false ;
6028		BossAdministratorSession *result;
6029		PyObject * obj0 = 0 ;
6030		PyObject * obj1 = 0 ;
6031	+	PyObject * obj2 = 0 ;
6032	+	PyObject * obj3 = 0 ;
6033	+	PyObject * obj4 = 0 ;
6034
6035	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
6035	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6036		if (obj0) {
6037		{
6038		if (PyString_Check(obj0))
#	Line 4457 | Line 6042 | static PyObject *_wrap_new_BossAdministr
6042		}
6043		}
6044		if (obj1) {
6045	<	arg2 = PyInt_AsLong(obj1) ? true : false;
6045	>	{
6046	>	if (PyString_Check(obj1))
6047	>	arg2 = std::string(PyString_AsString(obj1));
6048	>	else
6049	>	SWIG_exception(SWIG_TypeError, "string expected");
6050	>	}
6051	>	}
6052	>	if (obj2) {
6053	>	{
6054	>	if (PyString_Check(obj2))
6055	>	arg3 = std::string(PyString_AsString(obj2));
6056	>	else
6057	>	SWIG_exception(SWIG_TypeError, "string expected");
6058	>	}
6059	>	}
6060	>	if (obj3) {
6061	>	{
6062	>	if (PyString_Check(obj3))
6063	>	arg4 = std::string(PyString_AsString(obj3));
6064	>	else
6065	>	SWIG_exception(SWIG_TypeError, "string expected");
6066	>	}
6067	>	}
6068	>	if (obj4) {
6069	>	arg5 = PyInt_AsLong(obj4) ? true : false;
6070		if (PyErr_Occurred()) SWIG_fail;
6071		}
6072		{
6073		try {
6074	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
6074	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
6075
6076	+	}catch (const BossSchedFailure & e) {
6077	+	PyErr_SetString ( SchedulerError, e.what() );
6078	+	return NULL;
6079		}catch (const std::exception& e) {
6080	<	SWIG_exception(SWIG_RuntimeError, e.what());
6080	>	PyErr_SetString ( BossError, e.what() );
6081	>	return NULL;
6082		}
6083		}
6084		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4486 | Line 6099 | static PyObject *_wrap_delete_BossAdmini
6099		try {
6100		delete arg1;
6101
6102	+	}catch (const BossSchedFailure & e) {
6103	+	PyErr_SetString ( SchedulerError, e.what() );
6104	+	return NULL;
6105		}catch (const std::exception& e) {
6106	<	SWIG_exception(SWIG_RuntimeError, e.what());
6106	>	PyErr_SetString ( BossError, e.what() );
6107	>	return NULL;
6108		}
6109		}
6110		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4509 | Line 6126 | static PyObject *_wrap_BossAdministrator
6126		try {
6127		result = (int)(arg1)->configureDB();
6128
6129	+	}catch (const BossSchedFailure & e) {
6130	+	PyErr_SetString ( SchedulerError, e.what() );
6131	+	return NULL;
6132		}catch (const std::exception& e) {
6133	<	SWIG_exception(SWIG_RuntimeError, e.what());
6133	>	PyErr_SetString ( BossError, e.what() );
6134	>	return NULL;
6135		}
6136		}
6137		resultobj = PyInt_FromLong((long)result);
#	Line 4543 | Line 6164 | static PyObject *_wrap_BossAdministrator
6164		try {
6165		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
6166
6167	+	}catch (const BossSchedFailure & e) {
6168	+	PyErr_SetString ( SchedulerError, e.what() );
6169	+	return NULL;
6170		}catch (const std::exception& e) {
6171	<	SWIG_exception(SWIG_RuntimeError, e.what());
6171	>	PyErr_SetString ( BossError, e.what() );
6172	>	return NULL;
6173		}
6174		}
6175		resultobj = PyInt_FromLong((long)result);
#	Line 4577 | Line 6202 | static PyObject *_wrap_BossAdministrator
6202		try {
6203		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
6204
6205	+	}catch (const BossSchedFailure & e) {
6206	+	PyErr_SetString ( SchedulerError, e.what() );
6207	+	return NULL;
6208		}catch (const std::exception& e) {
6209	<	SWIG_exception(SWIG_RuntimeError, e.what());
6209	>	PyErr_SetString ( BossError, e.what() );
6210	>	return NULL;
6211		}
6212		}
6213		resultobj = PyInt_FromLong((long)result);
#	Line 4611 | Line 6240 | static PyObject *_wrap_BossAdministrator
6240		try {
6241		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
6242
6243	+	}catch (const BossSchedFailure & e) {
6244	+	PyErr_SetString ( SchedulerError, e.what() );
6245	+	return NULL;
6246		}catch (const std::exception& e) {
6247	<	SWIG_exception(SWIG_RuntimeError, e.what());
6247	>	PyErr_SetString ( BossError, e.what() );
6248	>	return NULL;
6249		}
6250		}
6251		resultobj = PyInt_FromLong((long)result);
#	Line 4645 | Line 6278 | static PyObject *_wrap_BossAdministrator
6278		try {
6279		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
6280
6281	+	}catch (const BossSchedFailure & e) {
6282	+	PyErr_SetString ( SchedulerError, e.what() );
6283	+	return NULL;
6284		}catch (const std::exception& e) {
6285	<	SWIG_exception(SWIG_RuntimeError, e.what());
6285	>	PyErr_SetString ( BossError, e.what() );
6286	>	return NULL;
6287		}
6288		}
6289		resultobj = PyInt_FromLong((long)result);
#	Line 4679 | Line 6316 | static PyObject *_wrap_BossAdministrator
6316		try {
6317		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
6318
6319	+	}catch (const BossSchedFailure & e) {
6320	+	PyErr_SetString ( SchedulerError, e.what() );
6321	+	return NULL;
6322		}catch (const std::exception& e) {
6323	<	SWIG_exception(SWIG_RuntimeError, e.what());
6323	>	PyErr_SetString ( BossError, e.what() );
6324	>	return NULL;
6325		}
6326		}
6327		resultobj = PyInt_FromLong((long)result);
#	Line 4745 | Line 6386 | static PyObject *_wrap_BossAdministrator
6386		try {
6387		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
6388
6389	+	}catch (const BossSchedFailure & e) {
6390	+	PyErr_SetString ( SchedulerError, e.what() );
6391	+	return NULL;
6392		}catch (const std::exception& e) {
6393	<	SWIG_exception(SWIG_RuntimeError, e.what());
6393	>	PyErr_SetString ( BossError, e.what() );
6394	>	return NULL;
6395		}
6396		}
6397		resultobj = PyInt_FromLong((long)result);
#	Line 4835 | Line 6480 | static PyObject *_wrap_BossAdministrator
6480		try {
6481		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
6482
6483	+	}catch (const BossSchedFailure & e) {
6484	+	PyErr_SetString ( SchedulerError, e.what() );
6485	+	return NULL;
6486		}catch (const std::exception& e) {
6487	<	SWIG_exception(SWIG_RuntimeError, e.what());
6487	>	PyErr_SetString ( BossError, e.what() );
6488	>	return NULL;
6489		}
6490		}
6491		resultobj = PyInt_FromLong((long)result);
#	Line 4911 | Line 6560 | static PyObject *_wrap_BossAdministrator
6560		try {
6561		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6562
6563	+	}catch (const BossSchedFailure & e) {
6564	+	PyErr_SetString ( SchedulerError, e.what() );
6565	+	return NULL;
6566		}catch (const std::exception& e) {
6567	<	SWIG_exception(SWIG_RuntimeError, e.what());
6567	>	PyErr_SetString ( BossError, e.what() );
6568	>	return NULL;
6569		}
6570		}
6571		resultobj = PyInt_FromLong((long)result);
#	Line 4940 | Line 6593 | static PyObject *_wrap_BossAdministrator
6593		std::string arg13 = (std::string) "" ;
6594		bool arg14 = (bool) false ;
6595		bool arg15 = (bool) false ;
6596	+	bool arg16 = (bool) false ;
6597	+	bool arg17 = (bool) false ;
6598		int result;
6599		std::string temp2 ;
6600		std::string temp11 ;
#	Line 4958 | Line 6613 | static PyObject *_wrap_BossAdministrator
6613		PyObject * obj12 = 0 ;
6614		PyObject * obj13 = 0 ;
6615		PyObject * obj14 = 0 ;
6616	+	PyObject * obj15 = 0 ;
6617	+	PyObject * obj16 = 0 ;
6618
6619	<	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;
6619	>	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;
6620		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6621		{
6622		if (PyString_Check(obj1)) {
#	Line 5067 | Line 6724 | static PyObject *_wrap_BossAdministrator
6724		arg15 = PyInt_AsLong(obj14) ? true : false;
6725		if (PyErr_Occurred()) SWIG_fail;
6726		}
6727	+	if (obj15) {
6728	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6729	+	if (PyErr_Occurred()) SWIG_fail;
6730	+	}
6731	+	if (obj16) {
6732	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6733	+	if (PyErr_Occurred()) SWIG_fail;
6734	+	}
6735		{
6736		try {
6737	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
6737	>	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);
6738
6739	+	}catch (const BossSchedFailure & e) {
6740	+	PyErr_SetString ( SchedulerError, e.what() );
6741	+	return NULL;
6742		}catch (const std::exception& e) {
6743	<	SWIG_exception(SWIG_RuntimeError, e.what());
6743	>	PyErr_SetString ( BossError, e.what() );
6744	>	return NULL;
6745		}
6746		}
6747		resultobj = PyInt_FromLong((long)result);
#	Line 5094 | Line 6763 | static PyObject *_wrap_BossAdministrator
6763		try {
6764		result = (arg1)->help();
6765
6766	+	}catch (const BossSchedFailure & e) {
6767	+	PyErr_SetString ( SchedulerError, e.what() );
6768	+	return NULL;
6769		}catch (const std::exception& e) {
6770	<	SWIG_exception(SWIG_RuntimeError, e.what());
6770	>	PyErr_SetString ( BossError, e.what() );
6771	>	return NULL;
6772		}
6773		}
6774		{
#	Line 5133 | Line 6806 | static PyObject *_wrap_BossAdministrator
6806		try {
6807		result = (arg1)->SQL(arg2,arg3);
6808
6809	+	}catch (const BossSchedFailure & e) {
6810	+	PyErr_SetString ( SchedulerError, e.what() );
6811	+	return NULL;
6812		}catch (const std::exception& e) {
6813	<	SWIG_exception(SWIG_RuntimeError, e.what());
6813	>	PyErr_SetString ( BossError, e.what() );
6814	>	return NULL;
6815		}
6816		}
6817		{
#	Line 5205 | Line 6882 | static PyObject *_wrap_BossAdministrator
6882		try {
6883		result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6884
6885	+	}catch (const BossSchedFailure & e) {
6886	+	PyErr_SetString ( SchedulerError, e.what() );
6887	+	return NULL;
6888		}catch (const std::exception& e) {
6889	<	SWIG_exception(SWIG_RuntimeError, e.what());
6889	>	PyErr_SetString ( BossError, e.what() );
6890	>	return NULL;
6891	>	}
6892	>	}
6893	>	resultobj = PyInt_FromLong((long)result);
6894	>	return resultobj;
6895	>	fail:
6896	>	return NULL;
6897	>	}
6898	>
6899	>
6900	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
6901	>	PyObject *resultobj;
6902	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6903	>	std::string arg2 ;
6904	>	int result;
6905	>	PyObject * obj0 = 0 ;
6906	>	PyObject * obj1 = 0 ;
6907	>
6908	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6909	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6910	>	{
6911	>	if (PyString_Check(obj1))
6912	>	arg2 = std::string(PyString_AsString(obj1));
6913	>	else
6914	>	SWIG_exception(SWIG_TypeError, "string expected");
6915	>	}
6916	>	{
6917	>	try {
6918	>	result = (int)(arg1)->registerPlugins(arg2);
6919	>
6920	>	}catch (const BossSchedFailure & e) {
6921	>	PyErr_SetString ( SchedulerError, e.what() );
6922	>	return NULL;
6923	>	}catch (const std::exception& e) {
6924	>	PyErr_SetString ( BossError, e.what() );
6925	>	return NULL;
6926		}
6927		}
6928		resultobj = PyInt_FromLong((long)result);
#	Line 5239 | Line 6955 | static PyMethodDef SwigMethods[] = {
6955		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6956		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6957		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6958	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6959	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6960	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6961	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6962	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6963	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6958	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6959	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6960	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6961	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6962	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6963	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6964	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6965	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6966	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6967	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6968	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6969	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6970	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6971	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6972		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6973		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6974	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6975		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6976	+	{ (char *)"BossSession_task_begin", _wrap_BossSession_task_begin, METH_VARARGS },
6977	+	{ (char *)"BossSession_task_end", _wrap_BossSession_task_end, METH_VARARGS },
6978	+	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
6979	+	{ (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
6980		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6981		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6982	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6983	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6984	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6985	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6986		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6987		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6988		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5257 | Line 6990 | static PyMethodDef SwigMethods[] = {
6990		{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
6991		{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
6992		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5260	–	{ (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
6993		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6994		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6995	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6996	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
6997	+	{ (char *)"BossSession_getTasksByTaskInfo", _wrap_BossSession_getTasksByTaskInfo, METH_VARARGS },
6998	+	{ (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
6999	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7000	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7001	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
7002	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
7003	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
7004	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7005		{ (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 },
7006		{ (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 },
7007		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
5270	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7008		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7009		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7010	<	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7011	<	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7012	<	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7013	<	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7014	<	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7010	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7011	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7012	>	{ (char *)"BossTask_jobsInMemory", _wrap_BossTask_jobsInMemory, METH_VARARGS },
7013	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7014	>	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7015	>	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
7016		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
7017		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7018		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7019		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7020	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7021	+	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
7022	+	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7023		{ (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 },
7024		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
7025		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7026		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7027		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
5290	–	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
7028		{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
7029		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
7030		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
7031		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7032	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7033	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7034	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7035		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7036		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7037		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7038	<	{ (char *)"BossTask_prompt", _wrap_BossTask_prompt, METH_VARARGS },
7038	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7039	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7040	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7041	>	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7042	>	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7043	>	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7044	>	{ (char *)"BossTask_joblist", _wrap_BossTask_joblist, METH_VARARGS },
7045	>	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7046	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7047	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7048	>	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7049	>	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7050	>	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7051		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
7052		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7053		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 5312 | Line 7064 | static PyMethodDef SwigMethods[] = {
7064		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
7065		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
7066		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
7067	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
7068		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
7069		{ NULL, NULL }
7070		};
#	Line 5319 | Line 7072 | static PyMethodDef SwigMethods[] = {
7072
7073		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7074
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}};
7075		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}};
7076		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7077	+	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_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7079	+	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7080		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}};
7081		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7082		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7083	<	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7083	>	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_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7085		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7086	<	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
7086	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7087		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
7088	+	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
7089		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
7090		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}};
7091		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}};
7092		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}};
7093		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}};
7094	+	static swig_type_info _swigt__p_BossSession__task_iterator[] = {{"_p_BossSession__task_iterator", 0, "BossSession::task_iterator const *", 0},{"_p_BossSession__task_iterator"},{0}};
7095	+	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_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7097
7098		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,
7099		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
7100		_swigt__p_XMLDoc,
7101	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7102	+	_swigt__p_BossProgramExec,
7103	+	_swigt__p_BossChain,
7104		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
5348	–	_swigt__p_std__ostream,
7105		_swigt__p_BossTask,
7106		_swigt__p_BossTaskException,
7107	<	_swigt__p_BossAttributeContainer,
7107	>	_swigt__p_std__ostream,
7108	>	_swigt__p_BossProgram,
7109		_swigt__p_printOption,
7110	<	_swigt__p_BossDatabase,
7110	>	_swigt__p_BossAttributeContainer,
7111		_swigt__p_BossJob,
7112	+	_swigt__p_BossDatabase,
7113		_swigt__p_BossSession,
7114		_swigt__p_std__vectorTstd__string_t,
7115		_swigt__p_std__mapTstd__string_std__string_t,
7116		_swigt__p_BossAdministratorSession,
5359	–	_swigt__p_jobStates,
5360	–	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7117		_swigt__p_BossTask__job_iterator,
7118	+	_swigt__p_BossSession__task_iterator,
7119	+	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7120	+	_swigt__p_jobStates,
7121		0
7122		};
7123
#	Line 5401 | Line 7160 | SWIGEXPORT(void) SWIG_init(void) {
7160		}
7161		SWIG_InstallConstants(d,swig_const_table);
7162
7163	+
7164	+	// define custom exceptions
7165	+	PyObject *e;
7166	+	PyMethodDef tp_methods = {
7167	+	NULL, NULL, 0, NULL
7168	+	};
7169	+	e = Py_InitModule("BossSession", &tp_methods);
7170	+	// generic BOSS exception
7171	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
7172	+	Py_INCREF(BossError);
7173	+	PyModule_AddObject(e, "BossError", BossError);
7174	+	// scheduler interaction BOSS exception
7175	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
7176	+	Py_INCREF(SchedulerError);
7177	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
7178	+
7179		}
7180

Diff Legend

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