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.7 by gcodispo, Fri Oct 27 13:36:09 2006 UTC vs.
Revision 1.30 by gcodispo, Mon Apr 23 16:21:23 2007 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_XMLDoc swig_types[0]
658	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
657	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[0]
658	>	#define  SWIGTYPE_p_XMLDoc swig_types[1]
659		#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660	<	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[3]
661	<	#define  SWIGTYPE_p_BossTask swig_types[4]
662	<	#define  SWIGTYPE_p_BossTaskException swig_types[5]
663	<	#define  SWIGTYPE_p_std__ostream swig_types[6]
664	<	#define  SWIGTYPE_p_BossAttributeContainer swig_types[7]
665	<	#define  SWIGTYPE_p_printOption swig_types[8]
666	<	#define  SWIGTYPE_p_BossJob swig_types[9]
667	<	#define  SWIGTYPE_p_BossDatabase swig_types[10]
668	<	#define  SWIGTYPE_p_BossSession swig_types[11]
669	<	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[12]
670	<	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[13]
671	<	#define  SWIGTYPE_p_BossAdministratorSession swig_types[14]
672	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[15]
673	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	<	#define  SWIGTYPE_p_jobStates swig_types[17]
675	<	static swig_type_info *swig_types[19];
660	>	#define  SWIGTYPE_p_BossProgramExec swig_types[3]
661	>	#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[4]
662	>	#define  SWIGTYPE_p_BossChain swig_types[5]
663	>	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[6]
664	>	#define  SWIGTYPE_p_BossTask swig_types[7]
665	>	#define  SWIGTYPE_p_BossTaskException swig_types[8]
666	>	#define  SWIGTYPE_p_std__ostream swig_types[9]
667	>	#define  SWIGTYPE_p_BossProgram swig_types[10]
668	>	#define  SWIGTYPE_p_printOption swig_types[11]
669	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[12]
670	>	#define  SWIGTYPE_p_BossJob swig_types[13]
671	>	#define  SWIGTYPE_p_BossDatabase swig_types[14]
672	>	#define  SWIGTYPE_p_BossSession swig_types[15]
673	>	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[16]
674	>	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[17]
675	>	#define  SWIGTYPE_p_BossAdministratorSession swig_types[18]
676	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[19]
677	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[20]
678	>	#define  SWIGTYPE_p_jobStates swig_types[21]
679	>	static swig_type_info *swig_types[23];
680
681		/* -------- TYPES TABLE (END) -------- */
682
#	Line 850 | Line 854 | PyObject *std_maplstd_stringcstd_string_
854		" for iterator support");
855		#endif
856		}
857	+	std::string std_vectorlstd_string_g_pop___(std::vector<std::string > *self){
858	+	if (self->size() == 0)
859	+	throw std::out_of_range("pop from empty vector");
860	+	std::string x = self->back();
861	+	self->pop_back();
862	+	return x;
863	+	}
864	+	std::string std_vectorlstd_string_g___getitem_____(std::vector<std::string > *self,int i){
865	+	int size = int(self->size());
866	+	if (i<0) i += size;
867	+	if (i>=0 && i<size)
868	+	return (*self)[i];
869	+	else
870	+	throw std::out_of_range("vector index out of range");
871	+	}
872	+	std::vector<std::string > std_vectorlstd_string_g___getslice_____(std::vector<std::string > *self,int i,int j){
873	+	int size = int(self->size());
874	+	if (i<0) i = size+i;
875	+	if (j<0) j = size+j;
876	+	if (i<0) i = 0;
877	+	if (j>size) j = size;
878	+	std::vector<std::string > tmp(j-i);
879	+	std::copy(self->begin()+i,self->begin()+j,tmp.begin());
880	+	return tmp;
881	+	}
882	+	void std_vectorlstd_string_g___setitem_____(std::vector<std::string > *self,int i,std::string x){
883	+	int size = int(self->size());
884	+	if (i<0) i+= size;
885	+	if (i>=0 && i<size)
886	+	(*self)[i] = x;
887	+	else
888	+	throw std::out_of_range("vector index out of range");
889	+	}
890	+	void std_vectorlstd_string_g___setslice_____(std::vector<std::string > *self,int i,int j,std::vector<std::string > const &v){
891	+	int size = int(self->size());
892	+	if (i<0) i = size+i;
893	+	if (j<0) j = size+j;
894	+	if (i<0) i = 0;
895	+	if (j>size) j = size;
896	+	if (int(v.size()) == j-i) {
897	+	std::copy(v.begin(),v.end(),self->begin()+i);
898	+	} else {
899	+	self->erase(self->begin()+i,self->begin()+j);
900	+	if (i+1 <= int(self->size()))
901	+	self->insert(self->begin()+i,v.begin(),v.end());
902	+	else
903	+	self->insert(self->end(),v.begin(),v.end());
904	+	}
905	+	}
906	+	void std_vectorlstd_string_g___delitem_____(std::vector<std::string > *self,int i){
907	+	int size = int(self->size());
908	+	if (i<0) i+= size;
909	+	if (i>=0 && i<size)
910	+	self->erase(self->begin()+i);
911	+	else
912	+	throw std::out_of_range("vector index out of range");
913	+	}
914	+	void std_vectorlstd_string_g___delslice_____(std::vector<std::string > *self,int i,int j){
915	+	int size = int(self->size());
916	+	if (i<0) i = size+i;
917	+	if (j<0) j = size+j;
918	+	if (i<0) i = 0;
919	+	if (j>size) j = size;
920	+	self->erase(self->begin()+i,self->begin()+j);
921	+	}
922
923	+	static PyObject * BossError;
924	+	static PyObject * SchedulerError;
925		#include "BossSession.h"
926		#include "BossAdministratorSession.h"
927		#include "BossTask.h"
928		#include "BossJob.h"
929	+	#include "BossChain.h"
930		#include "BossTaskCore.h"
931		#include "BossAttributeContainer.h"
932		#include "BossDBObject.h"
933		#include "BossProgram.h"
934		#include "BossProgramExec.h"
935		#include "BossDatabase.h"
936	+	#include "BossScheduler.h"
937	+	#include "BossDeclaration.h"
938
939		PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
940		PyObject *  my_list = PyList_New( my_vec.size());
#	Line 871 | Line 945 | PyObject *BossSession_show(BossSession *
945		}
946		return my_list;
947		}
948	<	PyObject *BossSession_showCHTools__SWIG_1(BossSession *self){
948	>	PyObject *BossSession_CHTools(BossSession *self){
949		std::vector<std::string> my_vec = self->showCHTools();
950		return BossSession_show( self, my_vec );
951		}
952	<	PyObject *BossSession_showProgramTypes__SWIG_1(BossSession *self){
952	>	PyObject *BossSession_ProgramTypes(BossSession *self){
953		std::vector<std::string> my_vec = self->showProgramTypes();
954		return BossSession_show( self, my_vec );
955		}
956	<	PyObject *BossSession_showRTMon__SWIG_1(BossSession *self){
956	>	PyObject *BossSession_RTMons(BossSession *self){
957		std::vector<std::string> my_vec = self->showRTMon();
958		return BossSession_show( self, my_vec );
959		}
960	<	PyObject *BossSession_showSchedulers__SWIG_1(BossSession *self){
960	>	PyObject *BossSession_schedulers(BossSession *self){
961		std::vector<std::string> my_vec = self->showSchedulers();
962		return BossSession_show( self, my_vec );
963		}
964	<	PyObject *BossSession_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() ) );
964	>	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout,bool keepfile){
965	>	std::vector<std::string> my_vec = self->listMatch( scheduler,
966	>	schclassad,
967	>	keepfile,
968	>	taskid,
969	>	jobid,
970	>	timeout);
971	>	return BossSession_show( self, my_vec );
972	>	}
973	>	PyObject *BossSession_queryTasks(BossSession *self,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
974	>	PyObject * task_list = PyList_New(0);
975	>	std::vector <std::string> taskList;
976	>	if ( taskName.empty() ) {
977	>	taskList = self->selectTasks( taskRange, before, after, user);
978	>	} else {
979	>	taskList = self->selectTasksByName( taskName );
980		}
981	<
982	<	//       int size = taskList.size();
983	<	//       PyObject * job_dict = PyList_New(0);
905	<	//       for ( unsigned int i = 0; i < size; ++i ) {
906	<	//      PyList_SetItem(job_dict,i, );
907	<	//      self->makeBossTask( *it );
908	<	//       }
909	<	return  job_dict;
910	<	}
911	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
912	<	std::string tmp;
913	<	BossAttributeContainer::const_iterator it_end = obj.end ();
914	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
915	<	it != it_end; ++it) {
916	<	tmp = (*it).first.name ();
917	<	char * key = new char[ tmp.size() ];
918	<	key = strdup(tmp.c_str());
919	<	tmp = (*it).second.value ();
920	<	PyObject * val = PyString_FromString( tmp.c_str() );
921	<	PyDict_SetItemString( dict, key, val );
922	<	delete [] key;
981	>	for ( std::vector <std::string>::const_iterator it= taskList.begin();
982	>	it!= taskList.end(); ++it ) {
983	>	PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
984		}
985	<	return dict;
985	>	return  task_list;
986	>	}
987	>	void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
988	>	std::string tmp;
989	>	BossAttributeContainer::const_iterator it_end = obj.end ();
990	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
991	>	it != it_end; ++it) {
992	>
993	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
994	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
995	>	PyDict_SetItem( dict, key, val);
996	>	Py_DECREF(key);
997	>	Py_DECREF(val);
998		}
999	<	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
999	>	return;
1000	>	}
1001	>	void BossTask_jobDict(BossTask const *self,BossJob const *jobH,PyObject *job_dict){
1002
1003	<	PyObject * job_dict = PyDict_New();
1003	>	//    PyObject * job_dict = PyDict_New();
1004		std::string tmp;
1005
1006	<	BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1007	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1006	>	BossAttributeContainer obj = jobH->getTableEntries("JOB");
1007	>	BossTask_appendToPyDict ( self, job_dict, obj );
1008
1009	<	std::set<std::string> sch = (*jit)->getSchedulerElements();
1009	>	std::set<std::string> sch = jobH->getSchedulerElements();
1010		std::set<std::string>::const_iterator sch_end =  sch.end();
1011		for (std::set<std::string>::const_iterator it =sch.begin();
1012		it != sch_end; ++ it ) {
1013	<	tmp = (*it);
1014	<	char * key = new char[ tmp.size() ];
1015	<	key = strdup(tmp.c_str());
941	<	tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1013	>
1014	>	tmp = (*jobH)["JOB_SCHED_INFO."+(*it)];
1015	>	PyObject * key = PyString_FromString( it->c_str() );
1016		PyObject * val = PyString_FromString( tmp.c_str() );
1017	<	PyDict_SetItemString( job_dict, key, val );
1018	<	delete [] key;
1017	>	PyDict_SetItem( job_dict, key, val);
1018	>	Py_DECREF(key);
1019	>	Py_DECREF(val);
1020	>	}
1021	>	return;
1022	>	}
1023	>	PyObject *BossTask_jobsDict(BossTask *self){
1024	>
1025	>	PyObject * job_dict = PyDict_New();
1026	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1027	>	for (BossTask::job_iterator jit = self->job_begin ();
1028	>	jit != self->job_end (); ++jit) {
1029	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1030	>	PyObject * tmp_dict = PyDict_New();
1031	>	BossTask_jobDict( self, *jit, tmp_dict );
1032	>	PyDict_SetItem( job_dict, id, tmp_dict );
1033	>	Py_DECREF(id);
1034	>	Py_DECREF(tmp_dict);
1035	>	}
1036	>	return job_dict;
1037	>	}
1038	>	PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1039	>
1040	>	PyObject * job_dict = PyDict_New();
1041	>	self->load( ALL, jobid );
1042	>	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1043	>	return job_dict;
1044	>	}
1045	>	PyObject *BossTask_Chain(BossTask *self,std::string const &jobid){
1046	>
1047	>	PyObject * chain_dict = PyDict_New();
1048	>	BossAttributeContainer obj =
1049	>	self->chain( jobid ).getTableEntries("CHAIN");
1050	>	BossTask_appendToPyDict ( self, chain_dict, obj );
1051	>	return chain_dict;
1052	>	}
1053	>	PyObject *BossTask_jobStates(BossTask *self){
1054	>
1055	>	PyObject * job_dict = PyDict_New();
1056	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1057	>	for (BossTask::job_iterator jit = self->job_begin ();
1058	>	jit != self->job_end (); ++jit) {
1059	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1060	>	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1061	>	PyDict_SetItem( job_dict, id, status );
1062	>	Py_DECREF(id);
1063	>	Py_DECREF(status);
1064		}
1065		return job_dict;
1066		}
1067	<	PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
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	<	std::string id = (*jit)->chainId();
1075	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1076	<	PyObject * myid =  PyString_FromString(id.c_str() );
1077	<	PyDict_SetItem( job_dict, myid,tmp );
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 998 | 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 1016 | 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 1075 | 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 1190 | 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 1212 | 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 1235 | 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 1307 | 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 1369 | 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 1392 | 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 1415 | 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 1438 | 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 1469 | 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 1515 | 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 1533 | 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 ;
1674	<	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;
1762	<	PyErr_Clear();
1763	<	}else {
1764	<	_v = 1;
1765	<	}
1766	<	}
1767	<	if (_v) {
1768	<	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 ;
1785	<	std::string const &arg5_defvalue = "" ;
1786	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
1787	<	std::string arg6 = (std::string) "" ;
1788	<	std::string arg7 = (std::string) "" ;
1789	<	std::string arg8 = (std::string) "" ;
1790	<	std::string arg9 = (std::string) "" ;
1791	<	bool arg10 = (bool) false ;
1792	<	PyObject *result;
1793	<	std::string temp3 ;
1794	<	std::string temp4 ;
1795	<	std::string temp5 ;
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 ;
1797	–	PyObject * obj2 = 0 ;
2256		PyObject * obj3 = 0 ;
1799	–	PyObject * obj4 = 0 ;
1800	–	PyObject * obj5 = 0 ;
1801	–	PyObject * obj6 = 0 ;
1802	–	PyObject * obj7 = 0 ;
1803	–	PyObject * obj8 = 0 ;
1804	–	PyObject * obj9 = 0 ;
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		}
1870	–	if (obj9) {
1871	–	arg10 = PyInt_AsLong(obj9) ? true : false;
1872	–	if (PyErr_Occurred()) SWIG_fail;
1873	–	}
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) "" ;
1892	<	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) {
1897	<	{
1898	<	if (PyString_Check(obj0))
1899	<	arg1 = std::string(PyString_AsString(obj0));
1900	<	else
1901	<	SWIG_exception(SWIG_TypeError, "string expected");
1902	<	}
1903	<	}
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 1949 | 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 1986 | Line 2556 | static PyObject *_wrap_BossSession_makeB
2556		try {
2557		result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2558
2559	+	}catch (const BossSchedFailure & e) {
2560	+	PyErr_SetString ( SchedulerError, e.what() );
2561	+	return NULL;
2562		}catch (const std::exception& e) {
2563	<	SWIG_exception(SWIG_RuntimeError, e.what());
2563	>	PyErr_SetString ( BossError, e.what() );
2564	>	return NULL;
2565		}
2566		}
2567		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
#	Line 2011 | Line 2585 | static PyObject *_wrap_BossSession_destr
2585		try {
2586		(arg1)->destroyBossTask(arg2);
2587
2588	+	}catch (const BossSchedFailure & e) {
2589	+	PyErr_SetString ( SchedulerError, e.what() );
2590	+	return NULL;
2591		}catch (const std::exception& e) {
2592	<	SWIG_exception(SWIG_RuntimeError, e.what());
2592	>	PyErr_SetString ( BossError, e.what() );
2593	>	return NULL;
2594		}
2595		}
2596		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2022 | Line 2600 | static PyObject *_wrap_BossSession_destr
2600		}
2601
2602
2603	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_0(PyObject *self, PyObject *args) {
2603	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2604		PyObject *resultobj;
2605		BossSession *arg1 = (BossSession *) 0 ;
2606	<	SwigValueWrapper< std::vector<std::string > > result;
2606	>	std::vector<std::string > result;
2607		PyObject * obj0 = 0 ;
2608
2609		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
#	Line 2034 | Line 2612 | static PyObject *_wrap_BossSession_showC
2612		try {
2613		result = (arg1)->showCHTools();
2614
2615	+	}catch (const BossSchedFailure & e) {
2616	+	PyErr_SetString ( SchedulerError, e.what() );
2617	+	return NULL;
2618		}catch (const std::exception& e) {
2619	<	SWIG_exception(SWIG_RuntimeError, e.what());
2619	>	PyErr_SetString ( BossError, e.what() );
2620	>	return NULL;
2621		}
2622		}
2623		{
2624	<	std::vector<std::string > * resultptr;
2625	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2626	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2624	>	resultobj = PyTuple_New((&result)->size());
2625	>	for (unsigned int i=0; i<(&result)->size(); i++)
2626	>	PyTuple_SetItem(resultobj,i,
2627	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2628		}
2629		return resultobj;
2630		fail:
#	Line 2049 | Line 2632 | static PyObject *_wrap_BossSession_showC
2632		}
2633
2634
2635	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_0(PyObject *self, PyObject *args) {
2635	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2636		PyObject *resultobj;
2637		BossSession *arg1 = (BossSession *) 0 ;
2638	<	SwigValueWrapper< std::vector<std::string > > result;
2638	>	std::vector<std::string > result;
2639		PyObject * obj0 = 0 ;
2640
2641		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
#	Line 2061 | Line 2644 | static PyObject *_wrap_BossSession_showP
2644		try {
2645		result = (arg1)->showProgramTypes();
2646
2647	+	}catch (const BossSchedFailure & e) {
2648	+	PyErr_SetString ( SchedulerError, e.what() );
2649	+	return NULL;
2650		}catch (const std::exception& e) {
2651	<	SWIG_exception(SWIG_RuntimeError, e.what());
2651	>	PyErr_SetString ( BossError, e.what() );
2652	>	return NULL;
2653		}
2654		}
2655		{
2656	<	std::vector<std::string > * resultptr;
2657	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2658	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2656	>	resultobj = PyTuple_New((&result)->size());
2657	>	for (unsigned int i=0; i<(&result)->size(); i++)
2658	>	PyTuple_SetItem(resultobj,i,
2659	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2660		}
2661		return resultobj;
2662		fail:
#	Line 2076 | Line 2664 | static PyObject *_wrap_BossSession_showP
2664		}
2665
2666
2667	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_0(PyObject *self, PyObject *args) {
2667	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2668		PyObject *resultobj;
2669		BossSession *arg1 = (BossSession *) 0 ;
2670	<	SwigValueWrapper< std::vector<std::string > > result;
2670	>	std::vector<std::string > result;
2671		PyObject * obj0 = 0 ;
2672
2673		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
#	Line 2088 | Line 2676 | static PyObject *_wrap_BossSession_showR
2676		try {
2677		result = (arg1)->showRTMon();
2678
2679	+	}catch (const BossSchedFailure & e) {
2680	+	PyErr_SetString ( SchedulerError, e.what() );
2681	+	return NULL;
2682		}catch (const std::exception& e) {
2683	<	SWIG_exception(SWIG_RuntimeError, e.what());
2683	>	PyErr_SetString ( BossError, e.what() );
2684	>	return NULL;
2685		}
2686		}
2687		{
2688	<	std::vector<std::string > * resultptr;
2689	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2690	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2688	>	resultobj = PyTuple_New((&result)->size());
2689	>	for (unsigned int i=0; i<(&result)->size(); i++)
2690	>	PyTuple_SetItem(resultobj,i,
2691	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2692		}
2693		return resultobj;
2694		fail:
#	Line 2103 | Line 2696 | static PyObject *_wrap_BossSession_showR
2696		}
2697
2698
2699	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_0(PyObject *self, PyObject *args) {
2699	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2700		PyObject *resultobj;
2701		BossSession *arg1 = (BossSession *) 0 ;
2702	<	SwigValueWrapper< std::vector<std::string > > result;
2702	>	std::vector<std::string > result;
2703		PyObject * obj0 = 0 ;
2704
2705		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
#	Line 2115 | Line 2708 | static PyObject *_wrap_BossSession_showS
2708		try {
2709		result = (arg1)->showSchedulers();
2710
2711	+	}catch (const BossSchedFailure & e) {
2712	+	PyErr_SetString ( SchedulerError, e.what() );
2713	+	return NULL;
2714		}catch (const std::exception& e) {
2715	<	SWIG_exception(SWIG_RuntimeError, e.what());
2715	>	PyErr_SetString ( BossError, e.what() );
2716	>	return NULL;
2717		}
2718		}
2719		{
2720	<	std::vector<std::string > * resultptr;
2721	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2722	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2720	>	resultobj = PyTuple_New((&result)->size());
2721	>	for (unsigned int i=0; i<(&result)->size(); i++)
2722	>	PyTuple_SetItem(resultobj,i,
2723	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2724		}
2725		return resultobj;
2726		fail:
#	Line 2142 | Line 2740 | static PyObject *_wrap_BossSession_defau
2740		try {
2741		result = (arg1)->defaultCHTool();
2742
2743	+	}catch (const BossSchedFailure & e) {
2744	+	PyErr_SetString ( SchedulerError, e.what() );
2745	+	return NULL;
2746		}catch (const std::exception& e) {
2747	<	SWIG_exception(SWIG_RuntimeError, e.what());
2747	>	PyErr_SetString ( BossError, e.what() );
2748	>	return NULL;
2749		}
2750		}
2751		{
#	Line 2167 | Line 2769 | static PyObject *_wrap_BossSession_defau
2769		try {
2770		result = (arg1)->defaultProgramType();
2771
2772	+	}catch (const BossSchedFailure & e) {
2773	+	PyErr_SetString ( SchedulerError, e.what() );
2774	+	return NULL;
2775		}catch (const std::exception& e) {
2776	<	SWIG_exception(SWIG_RuntimeError, e.what());
2776	>	PyErr_SetString ( BossError, e.what() );
2777	>	return NULL;
2778		}
2779		}
2780		{
#	Line 2192 | Line 2798 | static PyObject *_wrap_BossSession_defau
2798		try {
2799		result = (arg1)->defaultRTMon();
2800
2801	+	}catch (const BossSchedFailure & e) {
2802	+	PyErr_SetString ( SchedulerError, e.what() );
2803	+	return NULL;
2804		}catch (const std::exception& e) {
2805	<	SWIG_exception(SWIG_RuntimeError, e.what());
2805	>	PyErr_SetString ( BossError, e.what() );
2806	>	return NULL;
2807		}
2808		}
2809		{
#	Line 2217 | Line 2827 | static PyObject *_wrap_BossSession_defau
2827		try {
2828		result = (arg1)->defaultScheduler();
2829
2830	+	}catch (const BossSchedFailure & e) {
2831	+	PyErr_SetString ( SchedulerError, e.what() );
2832	+	return NULL;
2833		}catch (const std::exception& e) {
2834	<	SWIG_exception(SWIG_RuntimeError, e.what());
2834	>	PyErr_SetString ( BossError, e.what() );
2835	>	return NULL;
2836		}
2837		}
2838		{
#	Line 2242 | Line 2856 | static PyObject *_wrap_BossSession_versi
2856		try {
2857		result = (arg1)->version();
2858
2859	+	}catch (const BossSchedFailure & e) {
2860	+	PyErr_SetString ( SchedulerError, e.what() );
2861	+	return NULL;
2862		}catch (const std::exception& e) {
2863	<	SWIG_exception(SWIG_RuntimeError, e.what());
2863	>	PyErr_SetString ( BossError, e.what() );
2864	>	return NULL;
2865		}
2866		}
2867		{
#	Line 2267 | Line 2885 | static PyObject *_wrap_BossSession_clien
2885		try {
2886		result = (arg1)->clientID();
2887
2888	+	}catch (const BossSchedFailure & e) {
2889	+	PyErr_SetString ( SchedulerError, e.what() );
2890	+	return NULL;
2891		}catch (const std::exception& e) {
2892	<	SWIG_exception(SWIG_RuntimeError, e.what());
2892	>	PyErr_SetString ( BossError, e.what() );
2893	>	return NULL;
2894		}
2895		}
2896		{
#	Line 2298 | Line 2920 | static PyObject *_wrap_BossSession_showC
2920		try {
2921		result = (int)(arg1)->showConfigs(arg2);
2922
2923	+	}catch (const BossSchedFailure & e) {
2924	+	PyErr_SetString ( SchedulerError, e.what() );
2925	+	return NULL;
2926		}catch (const std::exception& e) {
2927	<	SWIG_exception(SWIG_RuntimeError, e.what());
2927	>	PyErr_SetString ( BossError, e.what() );
2928	>	return NULL;
2929		}
2930		}
2931		resultobj = PyInt_FromLong((long)result);
#	Line 2351 | Line 2977 | static PyObject *_wrap_BossSession_RTupd
2977		try {
2978		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2979
2980	+	}catch (const BossSchedFailure & e) {
2981	+	PyErr_SetString ( SchedulerError, e.what() );
2982	+	return NULL;
2983		}catch (const std::exception& e) {
2984	<	SWIG_exception(SWIG_RuntimeError, e.what());
2984	>	PyErr_SetString ( BossError, e.what() );
2985	>	return NULL;
2986		}
2987		}
2988		resultobj = PyInt_FromLong((long)result);
#	Line 2372 | Line 3002 | static PyObject *_wrap_BossSession_listM
3002		std::string *arg5 = (std::string *) &arg5_defvalue ;
3003		std::string const &arg6_defvalue = "" ;
3004		std::string *arg6 = (std::string *) &arg6_defvalue ;
3005	<	std::string result;
3005	>	unsigned int arg7 = (unsigned int) 0 ;
3006	>	std::vector<std::string > result;
3007		std::string temp2 ;
3008		std::string temp3 ;
3009		std::string temp5 ;
#	Line 2383 | Line 3014 | static PyObject *_wrap_BossSession_listM
3014		PyObject * obj3 = 0 ;
3015		PyObject * obj4 = 0 ;
3016		PyObject * obj5 = 0 ;
3017	+	PyObject * obj6 = 0 ;
3018
3019	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3019	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3020		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3021		{
3022		if (PyString_Check(obj1)) {
#	Line 2426 | Line 3058 | static PyObject *_wrap_BossSession_listM
3058		}
3059		}
3060		}
3061	+	if (obj6) {
3062	+	arg7 = (unsigned int) PyInt_AsLong(obj6);
3063	+	if (PyErr_Occurred()) SWIG_fail;
3064	+	}
3065		{
3066		try {
3067	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
3067	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
3068
3069	+	}catch (const BossSchedFailure & e) {
3070	+	PyErr_SetString ( SchedulerError, e.what() );
3071	+	return NULL;
3072		}catch (const std::exception& e) {
3073	<	SWIG_exception(SWIG_RuntimeError, e.what());
3073	>	PyErr_SetString ( BossError, e.what() );
3074	>	return NULL;
3075		}
3076		}
3077		{
3078	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3078	>	resultobj = PyTuple_New((&result)->size());
3079	>	for (unsigned int i=0; i<(&result)->size(); i++)
3080	>	PyTuple_SetItem(resultobj,i,
3081	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3082		}
3083		return resultobj;
3084		fail:
#	Line 2457 | Line 3100 | static PyObject *_wrap_BossSession_sched
3100		std::string arg7 = (std::string) "" ;
3101		std::string arg8 = (std::string) "" ;
3102		std::string arg9 = (std::string) "" ;
3103	+	unsigned int arg10 = (unsigned int) 0 ;
3104		std::string temp3 ;
3105		std::string temp4 ;
3106		std::string temp5 ;
#	Line 2468 | Line 3112 | static PyObject *_wrap_BossSession_sched
3112		PyObject * obj6 = 0 ;
3113		PyObject * obj7 = 0 ;
3114		PyObject * obj8 = 0 ;
3115	+	PyObject * obj9 = 0 ;
3116
3117	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3117	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3118		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3119		if (obj2) {
3120		{
#	Line 2533 | Line 3178 | static PyObject *_wrap_BossSession_sched
3178		SWIG_exception(SWIG_TypeError, "string expected");
3179		}
3180		}
3181	+	if (obj9) {
3182	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3183	+	if (PyErr_Occurred()) SWIG_fail;
3184	+	}
3185		{
3186		try {
3187	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3187	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3188
3189	+	}catch (const BossSchedFailure & e) {
3190	+	PyErr_SetString ( SchedulerError, e.what() );
3191	+	return NULL;
3192		}catch (const std::exception& e) {
3193	<	SWIG_exception(SWIG_RuntimeError, e.what());
3193	>	PyErr_SetString ( BossError, e.what() );
3194	>	return NULL;
3195		}
3196		}
3197		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2559 | Line 3212 | static PyObject *_wrap_BossSession_selec
3212		std::string *arg4 = (std::string *) &arg4_defvalue ;
3213		std::string const &arg5_defvalue = "" ;
3214		std::string *arg5 = (std::string *) &arg5_defvalue ;
3215	<	SwigValueWrapper< std::vector<std::string > > result;
3215	>	std::vector<std::string > result;
3216		std::string temp2 ;
3217		std::string temp3 ;
3218		std::string temp4 ;
#	Line 2616 | Line 3269 | static PyObject *_wrap_BossSession_selec
3269		try {
3270		result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3271
3272	+	}catch (const BossSchedFailure & e) {
3273	+	PyErr_SetString ( SchedulerError, e.what() );
3274	+	return NULL;
3275		}catch (const std::exception& e) {
3276	<	SWIG_exception(SWIG_RuntimeError, e.what());
3276	>	PyErr_SetString ( BossError, e.what() );
3277	>	return NULL;
3278		}
3279		}
3280		{
3281	<	std::vector<std::string > * resultptr;
3282	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3283	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3281	>	resultobj = PyTuple_New((&result)->size());
3282	>	for (unsigned int i=0; i<(&result)->size(); i++)
3283	>	PyTuple_SetItem(resultobj,i,
3284	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3285		}
3286		return resultobj;
3287		fail:
#	Line 2631 | Line 3289 | static PyObject *_wrap_BossSession_selec
3289		}
3290
3291
3292	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
2635	<	PyObject *obj;
2636	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2637	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
2638	<	Py_INCREF(obj);
2639	<	return Py_BuildValue((char *)"");
2640	<	}
2641	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3292	>	static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
3293		PyObject *resultobj;
3294	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3295	<	char *arg2 ;
3294	>	BossSession *arg1 = (BossSession *) 0 ;
3295	>	std::string *arg2 = 0 ;
3296	>	std::vector<std::string > result;
3297	>	std::string temp2 ;
3298		PyObject * obj0 = 0 ;
3299	+	PyObject * obj1 = 0 ;
3300
3301	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3302	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3301	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3302	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3303		{
3304	<	if (arg2) {
3305	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3306	<	strcpy((char *) arg1->key,arg2);
3304	>	if (PyString_Check(obj1)) {
3305	>	temp2 = std::string(PyString_AsString(obj1));
3306	>	arg2 = &temp2;
3307		}else {
3308	<	arg1->key = 0;
3308	>	SWIG_exception(SWIG_TypeError, "string expected");
3309		}
3310		}
3311	<	Py_INCREF(Py_None); resultobj = Py_None;
3311	>	{
3312	>	try {
3313	>	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3314	>
3315	>	}catch (const BossSchedFailure & e) {
3316	>	PyErr_SetString ( SchedulerError, e.what() );
3317	>	return NULL;
3318	>	}catch (const std::exception& e) {
3319	>	PyErr_SetString ( BossError, e.what() );
3320	>	return NULL;
3321	>	}
3322	>	}
3323	>	{
3324	>	resultobj = PyTuple_New((&result)->size());
3325	>	for (unsigned int i=0; i<(&result)->size(); i++)
3326	>	PyTuple_SetItem(resultobj,i,
3327	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3328	>	}
3329		return resultobj;
3330		fail:
3331		return NULL;
3332		}
3333
3334
3335	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3335	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3336		PyObject *resultobj;
3337	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3338	<	char *result;
3337	>	BossSession *arg1 = (BossSession *) 0 ;
3338	>	int arg2 = (int) SCHEDULED ;
3339	>	std::string const &arg3_defvalue = "all" ;
3340	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3341	>	std::string const &arg4_defvalue = "all" ;
3342	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3343	>	std::string const &arg5_defvalue = "" ;
3344	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3345	>	std::string arg6 = (std::string) "" ;
3346	>	std::string arg7 = (std::string) "" ;
3347	>	std::string arg8 = (std::string) "" ;
3348	>	std::string arg9 = (std::string) "" ;
3349	>	unsigned int arg10 = (unsigned int) 0 ;
3350	>	bool arg11 = (bool) false ;
3351	>	SwigValueWrapper< std::vector<BossTask * > > result;
3352	>	std::string temp3 ;
3353	>	std::string temp4 ;
3354	>	std::string temp5 ;
3355		PyObject * obj0 = 0 ;
3356	+	PyObject * obj2 = 0 ;
3357	+	PyObject * obj3 = 0 ;
3358	+	PyObject * obj4 = 0 ;
3359	+	PyObject * obj5 = 0 ;
3360	+	PyObject * obj6 = 0 ;
3361	+	PyObject * obj7 = 0 ;
3362	+	PyObject * obj8 = 0 ;
3363	+	PyObject * obj9 = 0 ;
3364	+	PyObject * obj10 = 0 ;
3365
3366	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3367	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3368	<	result = (char *) ((arg1)->key);
3366	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3367	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3368	>	if (obj2) {
3369	>	{
3370	>	if (PyString_Check(obj2)) {
3371	>	temp3 = std::string(PyString_AsString(obj2));
3372	>	arg3 = &temp3;
3373	>	}else {
3374	>	SWIG_exception(SWIG_TypeError, "string expected");
3375	>	}
3376	>	}
3377	>	}
3378	>	if (obj3) {
3379	>	{
3380	>	if (PyString_Check(obj3)) {
3381	>	temp4 = std::string(PyString_AsString(obj3));
3382	>	arg4 = &temp4;
3383	>	}else {
3384	>	SWIG_exception(SWIG_TypeError, "string expected");
3385	>	}
3386	>	}
3387	>	}
3388	>	if (obj4) {
3389	>	{
3390	>	if (PyString_Check(obj4)) {
3391	>	temp5 = std::string(PyString_AsString(obj4));
3392	>	arg5 = &temp5;
3393	>	}else {
3394	>	SWIG_exception(SWIG_TypeError, "string expected");
3395	>	}
3396	>	}
3397	>	}
3398	>	if (obj5) {
3399	>	{
3400	>	if (PyString_Check(obj5))
3401	>	arg6 = std::string(PyString_AsString(obj5));
3402	>	else
3403	>	SWIG_exception(SWIG_TypeError, "string expected");
3404	>	}
3405	>	}
3406	>	if (obj6) {
3407	>	{
3408	>	if (PyString_Check(obj6))
3409	>	arg7 = std::string(PyString_AsString(obj6));
3410	>	else
3411	>	SWIG_exception(SWIG_TypeError, "string expected");
3412	>	}
3413	>	}
3414	>	if (obj7) {
3415	>	{
3416	>	if (PyString_Check(obj7))
3417	>	arg8 = std::string(PyString_AsString(obj7));
3418	>	else
3419	>	SWIG_exception(SWIG_TypeError, "string expected");
3420	>	}
3421	>	}
3422	>	if (obj8) {
3423	>	{
3424	>	if (PyString_Check(obj8))
3425	>	arg9 = std::string(PyString_AsString(obj8));
3426	>	else
3427	>	SWIG_exception(SWIG_TypeError, "string expected");
3428	>	}
3429	>	}
3430	>	if (obj9) {
3431	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3432	>	if (PyErr_Occurred()) SWIG_fail;
3433	>	}
3434	>	if (obj10) {
3435	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3436	>	if (PyErr_Occurred()) SWIG_fail;
3437	>	}
3438	>	{
3439	>	try {
3440	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3441	>
3442	>	}catch (const BossSchedFailure & e) {
3443	>	PyErr_SetString ( SchedulerError, e.what() );
3444	>	return NULL;
3445	>	}catch (const std::exception& e) {
3446	>	PyErr_SetString ( BossError, e.what() );
3447	>	return NULL;
3448	>	}
3449	>	}
3450	>	{
3451	>	std::vector<BossTask * > * resultptr;
3452	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3453	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3454	>	}
3455	>	return resultobj;
3456	>	fail:
3457	>	return NULL;
3458	>	}
3459	>
3460	>
3461	>	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3462	>	PyObject *resultobj;
3463	>	BossSession *arg1 = (BossSession *) 0 ;
3464	>	std::string *arg2 = 0 ;
3465	>	SwigValueWrapper< std::vector<BossTask * > > result;
3466	>	std::string temp2 ;
3467	>	PyObject * obj0 = 0 ;
3468	>	PyObject * obj1 = 0 ;
3469
3470	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3470	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3471	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3472	>	{
3473	>	if (PyString_Check(obj1)) {
3474	>	temp2 = std::string(PyString_AsString(obj1));
3475	>	arg2 = &temp2;
3476	>	}else {
3477	>	SWIG_exception(SWIG_TypeError, "string expected");
3478	>	}
3479	>	}
3480	>	{
3481	>	try {
3482	>	result = (arg1)->getTasksByName((std::string const &)*arg2);
3483	>
3484	>	}catch (const BossSchedFailure & e) {
3485	>	PyErr_SetString ( SchedulerError, e.what() );
3486	>	return NULL;
3487	>	}catch (const std::exception& e) {
3488	>	PyErr_SetString ( BossError, e.what() );
3489	>	return NULL;
3490	>	}
3491	>	}
3492	>	{
3493	>	std::vector<BossTask * > * resultptr;
3494	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3495	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3496	>	}
3497		return resultobj;
3498		fail:
3499		return NULL;
3500		}
3501
3502
3503	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3503	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3504		PyObject *resultobj;
3505	<	char *arg1 ;
3506	<	BossTaskException *result;
3505	>	BossSession *arg1 = (BossSession *) 0 ;
3506	>	std::vector<std::string > *arg2 = 0 ;
3507	>	PyObject *result;
3508	>	PyObject * obj0 = 0 ;
3509	>	PyObject * obj1 = 0 ;
3510
3511	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3511	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3512	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3513	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3514	>	if (arg2 == NULL) {
3515	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3516	>	}
3517		{
3518		try {
3519	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3519	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3520
3521	+	}catch (const BossSchedFailure & e) {
3522	+	PyErr_SetString ( SchedulerError, e.what() );
3523	+	return NULL;
3524		}catch (const std::exception& e) {
3525	<	SWIG_exception(SWIG_RuntimeError, e.what());
3525	>	PyErr_SetString ( BossError, e.what() );
3526	>	return NULL;
3527		}
3528		}
3529	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3529	>	resultobj = result;
3530		return resultobj;
3531		fail:
3532		return NULL;
3533		}
3534
3535
3536	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3536	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3537		PyObject *resultobj;
3538	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3539	<	char *result;
3538	>	BossSession *arg1 = (BossSession *) 0 ;
3539	>	PyObject *result;
3540		PyObject * obj0 = 0 ;
3541
3542	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3543	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3542	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3543	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3544		{
3545		try {
3546	<	result = (char *)((BossTaskException const *)arg1)->what();
3546	>	result = (PyObject *)BossSession_CHTools(arg1);
3547
3548	+	}catch (const BossSchedFailure & e) {
3549	+	PyErr_SetString ( SchedulerError, e.what() );
3550	+	return NULL;
3551		}catch (const std::exception& e) {
3552	<	SWIG_exception(SWIG_RuntimeError, e.what());
3552	>	PyErr_SetString ( BossError, e.what() );
3553	>	return NULL;
3554		}
3555		}
3556	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3556	>	resultobj = result;
3557		return resultobj;
3558		fail:
3559		return NULL;
3560		}
3561
3562
3563	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3563	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3564		PyObject *resultobj;
3565	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3565	>	BossSession *arg1 = (BossSession *) 0 ;
3566	>	PyObject *result;
3567		PyObject * obj0 = 0 ;
3568
3569	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3570	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3569	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3570	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3571		{
3572		try {
3573	<	delete arg1;
3573	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3574
3575	+	}catch (const BossSchedFailure & e) {
3576	+	PyErr_SetString ( SchedulerError, e.what() );
3577	+	return NULL;
3578		}catch (const std::exception& e) {
3579	<	SWIG_exception(SWIG_RuntimeError, e.what());
3579	>	PyErr_SetString ( BossError, e.what() );
3580	>	return NULL;
3581		}
3582		}
3583	<	Py_INCREF(Py_None); resultobj = Py_None;
3583	>	resultobj = result;
3584		return resultobj;
3585		fail:
3586		return NULL;
3587		}
3588
3589
3590	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3591	<	PyObject *obj;
3592	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3593	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3594	<	Py_INCREF(obj);
3595	<	return Py_BuildValue((char *)"");
3590	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3591	>	PyObject *resultobj;
3592	>	BossSession *arg1 = (BossSession *) 0 ;
3593	>	PyObject *result;
3594	>	PyObject * obj0 = 0 ;
3595	>
3596	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3597	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3598	>	{
3599	>	try {
3600	>	result = (PyObject *)BossSession_RTMons(arg1);
3601	>
3602	>	}catch (const BossSchedFailure & e) {
3603	>	PyErr_SetString ( SchedulerError, e.what() );
3604	>	return NULL;
3605	>	}catch (const std::exception& e) {
3606	>	PyErr_SetString ( BossError, e.what() );
3607	>	return NULL;
3608	>	}
3609	>	}
3610	>	resultobj = result;
3611	>	return resultobj;
3612	>	fail:
3613	>	return NULL;
3614		}
3615	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3615	>
3616	>
3617	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3618		PyObject *resultobj;
3619	<	BossTask *arg1 = (BossTask *) 0 ;
2757	<	PyObject *arg2 = (PyObject *) 0 ;
2758	<	BossAttributeContainer *arg3 = 0 ;
3619	>	BossSession *arg1 = (BossSession *) 0 ;
3620		PyObject *result;
3621		PyObject * obj0 = 0 ;
3622	+
3623	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3624	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3625	+	{
3626	+	try {
3627	+	result = (PyObject *)BossSession_schedulers(arg1);
3628	+
3629	+	}catch (const BossSchedFailure & e) {
3630	+	PyErr_SetString ( SchedulerError, e.what() );
3631	+	return NULL;
3632	+	}catch (const std::exception& e) {
3633	+	PyErr_SetString ( BossError, e.what() );
3634	+	return NULL;
3635	+	}
3636	+	}
3637	+	resultobj = result;
3638	+	return resultobj;
3639	+	fail:
3640	+	return NULL;
3641	+	}
3642	+
3643	+
3644	+	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3645	+	PyObject *resultobj;
3646	+	BossSession *arg1 = (BossSession *) 0 ;
3647	+	std::string *arg2 = 0 ;
3648	+	std::string *arg3 = 0 ;
3649	+	std::string const &arg4_defvalue = "" ;
3650	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
3651	+	std::string const &arg5_defvalue = "" ;
3652	+	std::string *arg5 = (std::string *) &arg5_defvalue ;
3653	+	unsigned int arg6 = (unsigned int) 0 ;
3654	+	bool arg7 = (bool) false ;
3655	+	PyObject *result;
3656	+	std::string temp2 ;
3657	+	std::string temp3 ;
3658	+	std::string temp4 ;
3659	+	std::string temp5 ;
3660	+	PyObject * obj0 = 0 ;
3661		PyObject * obj1 = 0 ;
3662		PyObject * obj2 = 0 ;
3663	+	PyObject * obj3 = 0 ;
3664	+	PyObject * obj4 = 0 ;
3665	+	PyObject * obj5 = 0 ;
3666	+	PyObject * obj6 = 0 ;
3667
3668	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3669	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3670	<	arg2 = obj1;
3671	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3672	<	if (arg3 == NULL) {
3673	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3668	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3669	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3670	>	{
3671	>	if (PyString_Check(obj1)) {
3672	>	temp2 = std::string(PyString_AsString(obj1));
3673	>	arg2 = &temp2;
3674	>	}else {
3675	>	SWIG_exception(SWIG_TypeError, "string expected");
3676	>	}
3677	>	}
3678	>	{
3679	>	if (PyString_Check(obj2)) {
3680	>	temp3 = std::string(PyString_AsString(obj2));
3681	>	arg3 = &temp3;
3682	>	}else {
3683	>	SWIG_exception(SWIG_TypeError, "string expected");
3684	>	}
3685	>	}
3686	>	if (obj3) {
3687	>	{
3688	>	if (PyString_Check(obj3)) {
3689	>	temp4 = std::string(PyString_AsString(obj3));
3690	>	arg4 = &temp4;
3691	>	}else {
3692	>	SWIG_exception(SWIG_TypeError, "string expected");
3693	>	}
3694	>	}
3695	>	}
3696	>	if (obj4) {
3697	>	{
3698	>	if (PyString_Check(obj4)) {
3699	>	temp5 = std::string(PyString_AsString(obj4));
3700	>	arg5 = &temp5;
3701	>	}else {
3702	>	SWIG_exception(SWIG_TypeError, "string expected");
3703	>	}
3704	>	}
3705	>	}
3706	>	if (obj5) {
3707	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3708	>	if (PyErr_Occurred()) SWIG_fail;
3709	>	}
3710	>	if (obj6) {
3711	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3712	>	if (PyErr_Occurred()) SWIG_fail;
3713		}
3714		{
3715		try {
3716	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3716	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3717
3718	+	}catch (const BossSchedFailure & e) {
3719	+	PyErr_SetString ( SchedulerError, e.what() );
3720	+	return NULL;
3721		}catch (const std::exception& e) {
3722	<	SWIG_exception(SWIG_RuntimeError, e.what());
3722	>	PyErr_SetString ( BossError, e.what() );
3723	>	return NULL;
3724		}
3725		}
3726		resultobj = result;
#	Line 2783 | Line 3730 | static PyObject *_wrap_BossTask_appendTo
3730		}
3731
3732
3733	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3733	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3734		PyObject *resultobj;
3735	<	BossTask *arg1 = (BossTask *) 0 ;
3736	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3735	>	BossSession *arg1 = (BossSession *) 0 ;
3736	>	std::string const &arg2_defvalue = "" ;
3737	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3738	>	std::string const &arg3_defvalue = "all" ;
3739	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3740	>	std::string arg4 = (std::string) "" ;
3741	>	std::string arg5 = (std::string) "" ;
3742	>	std::string arg6 = (std::string) "" ;
3743		PyObject *result;
3744	+	std::string temp2 ;
3745	+	std::string temp3 ;
3746		PyObject * obj0 = 0 ;
3747		PyObject * obj1 = 0 ;
3748	+	PyObject * obj2 = 0 ;
3749	+	PyObject * obj3 = 0 ;
3750	+	PyObject * obj4 = 0 ;
3751	+	PyObject * obj5 = 0 ;
3752
3753	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3754	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3755	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3756	<	if (arg2 == NULL) {
3757	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3753	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3754	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3755	>	if (obj1) {
3756	>	{
3757	>	if (PyString_Check(obj1)) {
3758	>	temp2 = std::string(PyString_AsString(obj1));
3759	>	arg2 = &temp2;
3760	>	}else {
3761	>	SWIG_exception(SWIG_TypeError, "string expected");
3762	>	}
3763	>	}
3764	>	}
3765	>	if (obj2) {
3766	>	{
3767	>	if (PyString_Check(obj2)) {
3768	>	temp3 = std::string(PyString_AsString(obj2));
3769	>	arg3 = &temp3;
3770	>	}else {
3771	>	SWIG_exception(SWIG_TypeError, "string expected");
3772	>	}
3773	>	}
3774	>	}
3775	>	if (obj3) {
3776	>	{
3777	>	if (PyString_Check(obj3))
3778	>	arg4 = std::string(PyString_AsString(obj3));
3779	>	else
3780	>	SWIG_exception(SWIG_TypeError, "string expected");
3781	>	}
3782	>	}
3783	>	if (obj4) {
3784	>	{
3785	>	if (PyString_Check(obj4))
3786	>	arg5 = std::string(PyString_AsString(obj4));
3787	>	else
3788	>	SWIG_exception(SWIG_TypeError, "string expected");
3789	>	}
3790	>	}
3791	>	if (obj5) {
3792	>	{
3793	>	if (PyString_Check(obj5))
3794	>	arg6 = std::string(PyString_AsString(obj5));
3795	>	else
3796	>	SWIG_exception(SWIG_TypeError, "string expected");
3797	>	}
3798		}
3799		{
3800		try {
3801	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3801	>	result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3802
3803	+	}catch (const BossSchedFailure & e) {
3804	+	PyErr_SetString ( SchedulerError, e.what() );
3805	+	return NULL;
3806		}catch (const std::exception& e) {
3807	<	SWIG_exception(SWIG_RuntimeError, e.what());
3807	>	PyErr_SetString ( BossError, e.what() );
3808	>	return NULL;
3809		}
3810		}
3811		resultobj = result;
#	Line 2812 | Line 3815 | static PyObject *_wrap_BossTask_jobDict(
3815		}
3816
3817
3818	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3818	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3819	>	PyObject *obj;
3820	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3821	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3822	>	Py_INCREF(obj);
3823	>	return Py_BuildValue((char *)"");
3824	>	}
3825	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3826	>	PyObject *resultobj;
3827	>	char *arg1 ;
3828	>	BossTaskException *result;
3829	>
3830	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3831	>	{
3832	>	try {
3833	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3834	>
3835	>	}catch (const BossSchedFailure & e) {
3836	>	PyErr_SetString ( SchedulerError, e.what() );
3837	>	return NULL;
3838	>	}catch (const std::exception& e) {
3839	>	PyErr_SetString ( BossError, e.what() );
3840	>	return NULL;
3841	>	}
3842	>	}
3843	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3844	>	return resultobj;
3845	>	fail:
3846	>	return NULL;
3847	>	}
3848	>
3849	>
3850	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3851	>	PyObject *resultobj;
3852	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3853	>	PyObject * obj0 = 0 ;
3854	>
3855	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3856	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3857	>	{
3858	>	try {
3859	>	delete arg1;
3860	>
3861	>	}catch (const BossSchedFailure & e) {
3862	>	PyErr_SetString ( SchedulerError, e.what() );
3863	>	return NULL;
3864	>	}catch (const std::exception& e) {
3865	>	PyErr_SetString ( BossError, e.what() );
3866	>	return NULL;
3867	>	}
3868	>	}
3869	>	Py_INCREF(Py_None); resultobj = Py_None;
3870	>	return resultobj;
3871	>	fail:
3872	>	return NULL;
3873	>	}
3874	>
3875	>
3876	>	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3877	>	PyObject *obj;
3878	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3879	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3880	>	Py_INCREF(obj);
3881	>	return Py_BuildValue((char *)"");
3882	>	}
3883	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3884		PyObject *resultobj;
3885		BossTask *arg1 = (BossTask *) 0 ;
3886	<	PyObject *result;
3886	>	BossTask::job_iterator result;
3887		PyObject * obj0 = 0 ;
3888
3889	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3889	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3890		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3891		{
3892		try {
3893	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3893	>	result = ((BossTask const *)arg1)->job_begin();
3894
3895	+	}catch (const BossSchedFailure & e) {
3896	+	PyErr_SetString ( SchedulerError, e.what() );
3897	+	return NULL;
3898		}catch (const std::exception& e) {
3899	<	SWIG_exception(SWIG_RuntimeError, e.what());
3899	>	PyErr_SetString ( BossError, e.what() );
3900	>	return NULL;
3901		}
3902		}
3903	<	resultobj = result;
3903	>	{
3904	>	BossTask::job_iterator * resultptr;
3905	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3906	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3907	>	}
3908		return resultobj;
3909		fail:
3910		return NULL;
3911		}
3912
3913
3914	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3915	<	int argc;
3916	<	PyObject *argv[2];
3917	<	int ii;
3914	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3915	>	PyObject *resultobj;
3916	>	BossTask *arg1 = (BossTask *) 0 ;
3917	>	BossTask::job_iterator result;
3918	>	PyObject * obj0 = 0 ;
3919
3920	<	argc = PyObject_Length(args);
3921	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3922	<	argv[ii] = PyTuple_GetItem(args,ii);
3923	<	}
3924	<	if (argc == 1) {
3925	<	int _v;
3926	<	{
3927	<	void *ptr;
3928	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3929	<	_v = 0;
3930	<	PyErr_Clear();
3931	<	}else {
2855	<	_v = 1;
2856	<	}
2857	<	}
2858	<	if (_v) {
2859	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
3920	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3921	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3922	>	{
3923	>	try {
3924	>	result = ((BossTask const *)arg1)->job_end();
3925	>
3926	>	}catch (const BossSchedFailure & e) {
3927	>	PyErr_SetString ( SchedulerError, e.what() );
3928	>	return NULL;
3929	>	}catch (const std::exception& e) {
3930	>	PyErr_SetString ( BossError, e.what() );
3931	>	return NULL;
3932		}
3933		}
3934	+	{
3935	+	BossTask::job_iterator * resultptr;
3936	+	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3937	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3938	+	}
3939	+	return resultobj;
3940	+	fail:
3941	+	return NULL;
3942	+	}
3943	+
3944	+
3945	+	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3946	+	PyObject *resultobj;
3947	+	BossTask *arg1 = (BossTask *) 0 ;
3948	+	BossJob *arg2 = (BossJob *) 0 ;
3949	+	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3950	+	PyObject * obj0 = 0 ;
3951	+	PyObject * obj1 = 0 ;
3952
3953	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3953	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3954	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3955	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3956	>	{
3957	>	try {
3958	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
3959	>
3960	>	}catch (const BossSchedFailure & e) {
3961	>	PyErr_SetString ( SchedulerError, e.what() );
3962	>	return NULL;
3963	>	}catch (const std::exception& e) {
3964	>	PyErr_SetString ( BossError, e.what() );
3965	>	return NULL;
3966	>	}
3967	>	}
3968	>	{
3969	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3970	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3971	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3972	>	}
3973	>	return resultobj;
3974	>	fail:
3975		return NULL;
3976		}
3977
3978
3979	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3979	>	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
3980		PyObject *resultobj;
3981		BossTask *arg1 = (BossTask *) 0 ;
3982	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3983	<	PyObject *result;
3982	>	BossJob *arg2 = (BossJob *) 0 ;
3983	>	std::string *arg3 = 0 ;
3984	>	BossProgram result;
3985	>	std::string temp3 ;
3986		PyObject * obj0 = 0 ;
3987		PyObject * obj1 = 0 ;
3988	+	PyObject * obj2 = 0 ;
3989
3990	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3990	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
3991		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3992	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3993	<	if (arg2 == NULL) {
3994	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3992	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3993	>	{
3994	>	if (PyString_Check(obj2)) {
3995	>	temp3 = std::string(PyString_AsString(obj2));
3996	>	arg3 = &temp3;
3997	>	}else {
3998	>	SWIG_exception(SWIG_TypeError, "string expected");
3999	>	}
4000		}
4001		{
4002		try {
4003	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
4003	>	result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
4004
4005	+	}catch (const BossSchedFailure & e) {
4006	+	PyErr_SetString ( SchedulerError, e.what() );
4007	+	return NULL;
4008		}catch (const std::exception& e) {
4009	<	SWIG_exception(SWIG_RuntimeError, e.what());
4009	>	PyErr_SetString ( BossError, e.what() );
4010	>	return NULL;
4011		}
4012		}
4013	<	resultobj = result;
4013	>	{
4014	>	BossProgram * resultptr;
4015	>	resultptr = new BossProgram((BossProgram &) result);
4016	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4017	>	}
4018		return resultobj;
4019		fail:
4020		return NULL;
4021		}
4022
4023
4024	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
4024	>	static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4025		PyObject *resultobj;
4026		BossTask *arg1 = (BossTask *) 0 ;
4027	<	std::string *arg2 = 0 ;
4028	<	PyObject *result;
4029	<	std::string temp2 ;
4027	>	BossJob *arg2 = (BossJob *) 0 ;
4028	>	std::string *arg3 = 0 ;
4029	>	BossProgramExec result;
4030	>	std::string temp3 ;
4031		PyObject * obj0 = 0 ;
4032		PyObject * obj1 = 0 ;
4033	+	PyObject * obj2 = 0 ;
4034
4035	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
4035	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4036		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4037	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4038		{
4039	<	if (PyString_Check(obj1)) {
4040	<	temp2 = std::string(PyString_AsString(obj1));
4041	<	arg2 = &temp2;
4039	>	if (PyString_Check(obj2)) {
4040	>	temp3 = std::string(PyString_AsString(obj2));
4041	>	arg3 = &temp3;
4042		}else {
4043		SWIG_exception(SWIG_TypeError, "string expected");
4044		}
4045		}
4046		{
4047		try {
4048	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
4048	>	result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4049
4050	+	}catch (const BossSchedFailure & e) {
4051	+	PyErr_SetString ( SchedulerError, e.what() );
4052	+	return NULL;
4053		}catch (const std::exception& e) {
4054	<	SWIG_exception(SWIG_RuntimeError, e.what());
4054	>	PyErr_SetString ( BossError, e.what() );
4055	>	return NULL;
4056		}
4057		}
4058	<	resultobj = result;
4058	>	{
4059	>	BossProgramExec * resultptr;
4060	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4061	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4062	>	}
4063		return resultobj;
4064		fail:
4065		return NULL;
#	Line 2940 | Line 4078 | static PyObject *_wrap_new_BossTask__SWI
4078		try {
4079		result = (BossTask *)new BossTask(arg1);
4080
4081	+	}catch (const BossSchedFailure & e) {
4082	+	PyErr_SetString ( SchedulerError, e.what() );
4083	+	return NULL;
4084		}catch (const std::exception& e) {
4085	<	SWIG_exception(SWIG_RuntimeError, e.what());
4085	>	PyErr_SetString ( BossError, e.what() );
4086	>	return NULL;
4087		}
4088		}
4089		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 2974 | Line 4116 | static PyObject *_wrap_new_BossTask__SWI
4116		try {
4117		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
4118
4119	+	}catch (const BossSchedFailure & e) {
4120	+	PyErr_SetString ( SchedulerError, e.what() );
4121	+	return NULL;
4122		}catch (const std::exception& e) {
4123	<	SWIG_exception(SWIG_RuntimeError, e.what());
4123	>	PyErr_SetString ( BossError, e.what() );
4124	>	return NULL;
4125		}
4126		}
4127		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 2996 | Line 4142 | static PyObject *_wrap_delete_BossTask(P
4142		try {
4143		delete arg1;
4144
4145	+	}catch (const BossSchedFailure & e) {
4146	+	PyErr_SetString ( SchedulerError, e.what() );
4147	+	return NULL;
4148		}catch (const std::exception& e) {
4149	<	SWIG_exception(SWIG_RuntimeError, e.what());
4149	>	PyErr_SetString ( BossError, e.what() );
4150	>	return NULL;
4151		}
4152		}
4153		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3022 | Line 4172 | static PyObject *_wrap_new_BossTask__SWI
4172		try {
4173		result = (BossTask *)new BossTask((BossTask const &)*arg1);
4174
4175	+	}catch (const BossSchedFailure & e) {
4176	+	PyErr_SetString ( SchedulerError, e.what() );
4177	+	return NULL;
4178		}catch (const std::exception& e) {
4179	<	SWIG_exception(SWIG_RuntimeError, e.what());
4179	>	PyErr_SetString ( BossError, e.what() );
4180	>	return NULL;
4181		}
4182		}
4183		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3113 | Line 4267 | static PyObject *_wrap_BossTask_id(PyObj
4267		result = (std::string *) &_result_ref;
4268		}
4269
4270	+	}catch (const BossSchedFailure & e) {
4271	+	PyErr_SetString ( SchedulerError, e.what() );
4272	+	return NULL;
4273		}catch (const std::exception& e) {
4274	<	SWIG_exception(SWIG_RuntimeError, e.what());
4274	>	PyErr_SetString ( BossError, e.what() );
4275	>	return NULL;
4276		}
4277		}
4278		{
#	Line 3141 | Line 4299 | static PyObject *_wrap_BossTask_name(PyO
4299		result = (std::string *) &_result_ref;
4300		}
4301
4302	+	}catch (const BossSchedFailure & e) {
4303	+	PyErr_SetString ( SchedulerError, e.what() );
4304	+	return NULL;
4305		}catch (const std::exception& e) {
4306	<	SWIG_exception(SWIG_RuntimeError, e.what());
4306	>	PyErr_SetString ( BossError, e.what() );
4307	>	return NULL;
4308		}
4309		}
4310		{
#	Line 3154 | Line 4316 | static PyObject *_wrap_BossTask_name(PyO
4316		}
4317
4318
4319	<	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4319	>	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4320		PyObject *resultobj;
4321		BossTask *arg1 = (BossTask *) 0 ;
4322	<	std::map<std::string,std::string > result;
4322	>	std::string *arg2 = 0 ;
4323	>	BossChain result;
4324	>	std::string temp2 ;
4325		PyObject * obj0 = 0 ;
4326	+	PyObject * obj1 = 0 ;
4327
4328	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4328	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4329		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4330		{
4331	<	try {
4332	<	result = ((BossTask const *)arg1)->taskMap();
4333	<
4334	<	}catch (const std::exception& e) {
4335	<	SWIG_exception(SWIG_RuntimeError, e.what());
3171	<	}
3172	<	}
3173	<	{
3174	<	resultobj = PyDict_New();
3175	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3176	<	PyDict_SetItem(resultobj,
3177	<	SwigString_FromString(i->first),
3178	<	SwigString_FromString(i->second));
4331	>	if (PyString_Check(obj1)) {
4332	>	temp2 = std::string(PyString_AsString(obj1));
4333	>	arg2 = &temp2;
4334	>	}else {
4335	>	SWIG_exception(SWIG_TypeError, "string expected");
4336		}
4337		}
3181	–	return resultobj;
3182	–	fail:
3183	–	return NULL;
3184	–	}
3185	–
3186	–
3187	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3188	–	PyObject *resultobj;
3189	–	BossTask *arg1 = (BossTask *) 0 ;
3190	–	BossTask::job_iterator result;
3191	–	PyObject * obj0 = 0 ;
3192	–
3193	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3194	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4338		{
4339		try {
4340	<	result = ((BossTask const *)arg1)->job_begin();
4340	>	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4341
4342	+	}catch (const BossSchedFailure & e) {
4343	+	PyErr_SetString ( SchedulerError, e.what() );
4344	+	return NULL;
4345		}catch (const std::exception& e) {
4346	<	SWIG_exception(SWIG_RuntimeError, e.what());
4346	>	PyErr_SetString ( BossError, e.what() );
4347	>	return NULL;
4348		}
4349		}
4350		{
4351	<	BossTask::job_iterator * resultptr;
4352	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4353	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4351	>	BossChain * resultptr;
4352	>	resultptr = new BossChain((BossChain &) result);
4353	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4354		}
4355		return resultobj;
4356		fail:
#	Line 3211 | Line 4358 | static PyObject *_wrap_BossTask_job_begi
4358		}
4359
4360
4361	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4361	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4362		PyObject *resultobj;
4363		BossTask *arg1 = (BossTask *) 0 ;
4364	<	BossTask::job_iterator result;
4364	>	std::map<std::string,std::string > result;
4365		PyObject * obj0 = 0 ;
4366
4367	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4367	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4368		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4369		{
4370		try {
4371	<	result = ((BossTask const *)arg1)->job_end();
4371	>	result = ((BossTask const *)arg1)->taskMap();
4372
4373	+	}catch (const BossSchedFailure & e) {
4374	+	PyErr_SetString ( SchedulerError, e.what() );
4375	+	return NULL;
4376		}catch (const std::exception& e) {
4377	<	SWIG_exception(SWIG_RuntimeError, e.what());
4377	>	PyErr_SetString ( BossError, e.what() );
4378	>	return NULL;
4379		}
4380		}
4381		{
4382	<	BossTask::job_iterator * resultptr;
4383	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4384	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4382	>	resultobj = PyDict_New();
4383	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4384	>	PyDict_SetItem(resultobj,
4385	>	SwigString_FromString(i->first),
4386	>	SwigString_FromString(i->second));
4387	>	}
4388		}
4389		return resultobj;
4390		fail:
#	Line 3238 | Line 4392 | static PyObject *_wrap_BossTask_job_end(
4392		}
4393
4394
4395	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
4395	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4396		PyObject *resultobj;
4397		BossTask *arg1 = (BossTask *) 0 ;
4398		SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
#	Line 3250 | Line 4404 | static PyObject *_wrap_BossTask_jobsMap_
4404		try {
4405		result = ((BossTask const *)arg1)->jobsMap();
4406
4407	+	}catch (const BossSchedFailure & e) {
4408	+	PyErr_SetString ( SchedulerError, e.what() );
4409	+	return NULL;
4410		}catch (const std::exception& e) {
4411	<	SWIG_exception(SWIG_RuntimeError, e.what());
4411	>	PyErr_SetString ( BossError, e.what() );
4412	>	return NULL;
4413		}
4414		}
4415		{
#	Line 3288 | Line 4446 | static PyObject *_wrap_BossTask_jobMap__
4446		try {
4447		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4448
4449	+	}catch (const BossSchedFailure & e) {
4450	+	PyErr_SetString ( SchedulerError, e.what() );
4451	+	return NULL;
4452		}catch (const std::exception& e) {
4453	<	SWIG_exception(SWIG_RuntimeError, e.what());
4453	>	PyErr_SetString ( BossError, e.what() );
4454	>	return NULL;
4455		}
4456		}
4457		{
#	Line 3317 | Line 4479 | static PyObject *_wrap_BossTask_jobMap__
4479		try {
4480		result = ((BossTask const *)arg1)->jobMap(arg2);
4481
4482	+	}catch (const BossSchedFailure & e) {
4483	+	PyErr_SetString ( SchedulerError, e.what() );
4484	+	return NULL;
4485		}catch (const std::exception& e) {
4486	<	SWIG_exception(SWIG_RuntimeError, e.what());
4486	>	PyErr_SetString ( BossError, e.what() );
4487	>	return NULL;
4488		}
4489		}
4490		{
#	Line 3422 | Line 4588 | static PyObject *_wrap_BossTask_programs
4588		try {
4589		result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4590
4591	+	}catch (const BossSchedFailure & e) {
4592	+	PyErr_SetString ( SchedulerError, e.what() );
4593	+	return NULL;
4594		}catch (const std::exception& e) {
4595	<	SWIG_exception(SWIG_RuntimeError, e.what());
4595	>	PyErr_SetString ( BossError, e.what() );
4596	>	return NULL;
4597		}
4598		}
4599		{
#	Line 3437 | Line 4607 | static PyObject *_wrap_BossTask_programs
4607		}
4608
4609
3440	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3441	–	PyObject *resultobj;
3442	–	BossTask *arg1 = (BossTask *) 0 ;
3443	–	BossJob *arg2 = (BossJob *) 0 ;
3444	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3445	–	PyObject * obj0 = 0 ;
3446	–	PyObject * obj1 = 0 ;
3447	–
3448	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3449	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3450	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3451	–	{
3452	–	try {
3453	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
3454	–
3455	–	}catch (const std::exception& e) {
3456	–	SWIG_exception(SWIG_RuntimeError, e.what());
3457	–	}
3458	–	}
3459	–	{
3460	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3461	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3462	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3463	–	}
3464	–	return resultobj;
3465	–	fail:
3466	–	return NULL;
3467	–	}
3468	–
3469	–
4610		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4611		PyObject *resultobj;
4612		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3503 | Line 4643 | static PyObject *_wrap_BossTask_declare_
4643		try {
4644		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4645
4646	+	}catch (const BossSchedFailure & e) {
4647	+	PyErr_SetString ( SchedulerError, e.what() );
4648	+	return NULL;
4649		}catch (const std::exception& e) {
4650	<	SWIG_exception(SWIG_RuntimeError, e.what());
4650	>	PyErr_SetString ( BossError, e.what() );
4651	>	return NULL;
4652		}
4653		}
4654		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3542 | Line 4686 | static PyObject *_wrap_BossTask_declare_
4686		try {
4687		(arg1)->declare(arg2,(std::string const &)*arg3);
4688
4689	+	}catch (const BossSchedFailure & e) {
4690	+	PyErr_SetString ( SchedulerError, e.what() );
4691	+	return NULL;
4692		}catch (const std::exception& e) {
4693	<	SWIG_exception(SWIG_RuntimeError, e.what());
4693	>	PyErr_SetString ( BossError, e.what() );
4694	>	return NULL;
4695		}
4696		}
4697		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3641 | Line 4789 | static PyObject *_wrap_BossTask_remove(P
4789		try {
4790		(arg1)->remove();
4791
4792	+	}catch (const BossSchedFailure & e) {
4793	+	PyErr_SetString ( SchedulerError, e.what() );
4794	+	return NULL;
4795		}catch (const std::exception& e) {
4796	<	SWIG_exception(SWIG_RuntimeError, e.what());
4796	>	PyErr_SetString ( BossError, e.what() );
4797	>	return NULL;
4798		}
4799		}
4800		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3677 | Line 4829 | static PyObject *_wrap_BossTask_archive(
4829		try {
4830		(arg1)->archive((std::string const &)*arg2);
4831
4832	+	}catch (const BossSchedFailure & e) {
4833	+	PyErr_SetString ( SchedulerError, e.what() );
4834	+	return NULL;
4835		}catch (const std::exception& e) {
4836	<	SWIG_exception(SWIG_RuntimeError, e.what());
4836	>	PyErr_SetString ( BossError, e.what() );
4837	>	return NULL;
4838		}
4839		}
4840		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3701 | Line 4857 | static PyObject *_wrap_BossTask_submit(P
4857		std::string *arg5 = (std::string *) &arg5_defvalue ;
4858		std::string const &arg6_defvalue = "" ;
4859		std::string *arg6 = (std::string *) &arg6_defvalue ;
4860	<	bool arg7 = (bool) false ;
4860	>	unsigned int arg7 = (unsigned int) 0 ;
4861	>	bool arg8 = (bool) false ;
4862		int result;
4863		std::string temp2 ;
4864		std::string temp3 ;
#	Line 3715 | Line 4872 | static PyObject *_wrap_BossTask_submit(P
4872		PyObject * obj4 = 0 ;
4873		PyObject * obj5 = 0 ;
4874		PyObject * obj6 = 0 ;
4875	+	PyObject * obj7 = 0 ;
4876
4877	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4877	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4878		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4879		if (obj1) {
4880		{
#	Line 3769 | Line 4927 | static PyObject *_wrap_BossTask_submit(P
4927		}
4928		}
4929		if (obj6) {
4930	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4930	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4931	>	if (PyErr_Occurred()) SWIG_fail;
4932	>	}
4933	>	if (obj7) {
4934	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4935		if (PyErr_Occurred()) SWIG_fail;
4936		}
4937		{
4938		try {
4939	<	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);
4939	>	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);
4940
4941	+	}catch (const BossSchedFailure & e) {
4942	+	PyErr_SetString ( SchedulerError, e.what() );
4943	+	return NULL;
4944		}catch (const std::exception& e) {
4945	<	SWIG_exception(SWIG_RuntimeError, e.what());
4945	>	PyErr_SetString ( BossError, e.what() );
4946	>	return NULL;
4947		}
4948		}
4949		resultobj = PyInt_FromLong((long)result);
#	Line 3816 | Line 4982 | static PyObject *_wrap_BossTask_reSubmit
4982		try {
4983		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4984
4985	+	}catch (const BossSchedFailure & e) {
4986	+	PyErr_SetString ( SchedulerError, e.what() );
4987	+	return NULL;
4988		}catch (const std::exception& e) {
4989	<	SWIG_exception(SWIG_RuntimeError, e.what());
4989	>	PyErr_SetString ( BossError, e.what() );
4990	>	return NULL;
4991		}
4992		}
4993		resultobj = PyInt_FromLong((long)result);
#	Line 3831 | Line 5001 | static PyObject *_wrap_BossTask_kill(PyO
5001		PyObject *resultobj;
5002		BossTask *arg1 = (BossTask *) 0 ;
5003		std::string *arg2 = 0 ;
5004	<	bool arg3 = (bool) false ;
5004	>	unsigned int arg3 = (unsigned int) 0 ;
5005	>	bool arg4 = (bool) false ;
5006		int result;
5007		std::string temp2 ;
5008		PyObject * obj0 = 0 ;
5009		PyObject * obj1 = 0 ;
5010		PyObject * obj2 = 0 ;
5011	+	PyObject * obj3 = 0 ;
5012
5013	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
5013	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
5014		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5015		{
5016		if (PyString_Check(obj1)) {
#	Line 3849 | Line 5021 | static PyObject *_wrap_BossTask_kill(PyO
5021		}
5022		}
5023		if (obj2) {
5024	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5024	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
5025	>	if (PyErr_Occurred()) SWIG_fail;
5026	>	}
5027	>	if (obj3) {
5028	>	arg4 = PyInt_AsLong(obj3) ? true : false;
5029		if (PyErr_Occurred()) SWIG_fail;
5030		}
5031		{
5032		try {
5033	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
5033	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
5034
5035	+	}catch (const BossSchedFailure & e) {
5036	+	PyErr_SetString ( SchedulerError, e.what() );
5037	+	return NULL;
5038		}catch (const std::exception& e) {
5039	<	SWIG_exception(SWIG_RuntimeError, e.what());
5039	>	PyErr_SetString ( BossError, e.what() );
5040	>	return NULL;
5041		}
5042		}
5043		resultobj = PyInt_FromLong((long)result);
#	Line 3867 | Line 5047 | static PyObject *_wrap_BossTask_kill(PyO
5047		}
5048
5049
5050	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
5050	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
5051		PyObject *resultobj;
5052		BossTask *arg1 = (BossTask *) 0 ;
5053		std::string const &arg2_defvalue = "all" ;
5054		std::string *arg2 = (std::string *) &arg2_defvalue ;
5055		std::string const &arg3_defvalue = "" ;
5056		std::string *arg3 = (std::string *) &arg3_defvalue ;
5057	<	bool arg4 = (bool) false ;
5057	>	unsigned int arg4 = (unsigned int) 0 ;
5058		bool arg5 = (bool) false ;
5059	+	bool arg6 = (bool) false ;
5060		int result;
5061		std::string temp2 ;
5062		std::string temp3 ;
#	Line 3884 | Line 5065 | static PyObject *_wrap_BossTask_getOutpu
5065		PyObject * obj2 = 0 ;
5066		PyObject * obj3 = 0 ;
5067		PyObject * obj4 = 0 ;
5068	+	PyObject * obj5 = 0 ;
5069
5070	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5070	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5071		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5072		if (obj1) {
5073		{
#	Line 3908 | Line 5090 | static PyObject *_wrap_BossTask_getOutpu
5090		}
5091		}
5092		if (obj3) {
5093	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5093	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
5094		if (PyErr_Occurred()) SWIG_fail;
5095		}
5096		if (obj4) {
5097		arg5 = PyInt_AsLong(obj4) ? true : false;
5098		if (PyErr_Occurred()) SWIG_fail;
5099		}
5100	+	if (obj5) {
5101	+	arg6 = PyInt_AsLong(obj5) ? true : false;
5102	+	if (PyErr_Occurred()) SWIG_fail;
5103	+	}
5104		{
5105		try {
5106	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
5106	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
5107
5108	+	}catch (const BossSchedFailure & e) {
5109	+	PyErr_SetString ( SchedulerError, e.what() );
5110	+	return NULL;
5111		}catch (const std::exception& e) {
5112	<	SWIG_exception(SWIG_RuntimeError, e.what());
5112	>	PyErr_SetString ( BossError, e.what() );
5113	>	return NULL;
5114		}
5115		}
5116		resultobj = PyInt_FromLong((long)result);
#	Line 3930 | Line 5120 | static PyObject *_wrap_BossTask_getOutpu
5120		}
5121
5122
5123	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
5123	>	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
5124		PyObject *resultobj;
5125		BossTask *arg1 = (BossTask *) 0 ;
5126	<	std::string const &arg2_defvalue = "" ;
3937	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3938	<	bool arg3 = (bool) false ;
3939	<	bool arg4 = (bool) false ;
5126	>	std::string *arg2 = 0 ;
5127		int result;
5128		std::string temp2 ;
5129		PyObject * obj0 = 0 ;
5130		PyObject * obj1 = 0 ;
5131	+
5132	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5133	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5134	+	{
5135	+	if (PyString_Check(obj1)) {
5136	+	temp2 = std::string(PyString_AsString(obj1));
5137	+	arg2 = &temp2;
5138	+	}else {
5139	+	SWIG_exception(SWIG_TypeError, "string expected");
5140	+	}
5141	+	}
5142	+	{
5143	+	try {
5144	+	result = (int)(arg1)->loadByName((std::string const &)*arg2);
5145	+
5146	+	}catch (const BossSchedFailure & e) {
5147	+	PyErr_SetString ( SchedulerError, e.what() );
5148	+	return NULL;
5149	+	}catch (const std::exception& e) {
5150	+	PyErr_SetString ( BossError, e.what() );
5151	+	return NULL;
5152	+	}
5153	+	}
5154	+	resultobj = PyInt_FromLong((long)result);
5155	+	return resultobj;
5156	+	fail:
5157	+	return NULL;
5158	+	}
5159	+
5160	+
5161	+	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
5162	+	PyObject *resultobj;
5163	+	BossTask *arg1 = (BossTask *) 0 ;
5164	+	int arg2 = (int) SCHEDULED ;
5165	+	std::string const &arg3_defvalue = "all" ;
5166	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
5167	+	std::string const &arg4_defvalue = "" ;
5168	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
5169	+	std::string arg5 = (std::string) "" ;
5170	+	std::string arg6 = (std::string) "" ;
5171	+	std::string arg7 = (std::string) "" ;
5172	+	std::string arg8 = (std::string) "" ;
5173	+	int result;
5174	+	std::string temp3 ;
5175	+	std::string temp4 ;
5176	+	PyObject * obj0 = 0 ;
5177		PyObject * obj2 = 0 ;
5178		PyObject * obj3 = 0 ;
5179	+	PyObject * obj4 = 0 ;
5180	+	PyObject * obj5 = 0 ;
5181	+	PyObject * obj6 = 0 ;
5182	+	PyObject * obj7 = 0 ;
5183
5184	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
5184	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5185		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5186	<	if (obj1) {
5186	>	if (obj2) {
5187		{
5188	<	if (PyString_Check(obj1)) {
5189	<	temp2 = std::string(PyString_AsString(obj1));
5190	<	arg2 = &temp2;
5188	>	if (PyString_Check(obj2)) {
5189	>	temp3 = std::string(PyString_AsString(obj2));
5190	>	arg3 = &temp3;
5191		}else {
5192		SWIG_exception(SWIG_TypeError, "string expected");
5193		}
5194		}
5195		}
3959	–	if (obj2) {
3960	–	arg3 = PyInt_AsLong(obj2) ? true : false;
3961	–	if (PyErr_Occurred()) SWIG_fail;
3962	–	}
5196		if (obj3) {
5197	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5198	<	if (PyErr_Occurred()) SWIG_fail;
5197	>	{
5198	>	if (PyString_Check(obj3)) {
5199	>	temp4 = std::string(PyString_AsString(obj3));
5200	>	arg4 = &temp4;
5201	>	}else {
5202	>	SWIG_exception(SWIG_TypeError, "string expected");
5203	>	}
5204	>	}
5205	>	}
5206	>	if (obj4) {
5207	>	{
5208	>	if (PyString_Check(obj4))
5209	>	arg5 = std::string(PyString_AsString(obj4));
5210	>	else
5211	>	SWIG_exception(SWIG_TypeError, "string expected");
5212	>	}
5213	>	}
5214	>	if (obj5) {
5215	>	{
5216	>	if (PyString_Check(obj5))
5217	>	arg6 = std::string(PyString_AsString(obj5));
5218	>	else
5219	>	SWIG_exception(SWIG_TypeError, "string expected");
5220	>	}
5221	>	}
5222	>	if (obj6) {
5223	>	{
5224	>	if (PyString_Check(obj6))
5225	>	arg7 = std::string(PyString_AsString(obj6));
5226	>	else
5227	>	SWIG_exception(SWIG_TypeError, "string expected");
5228	>	}
5229	>	}
5230	>	if (obj7) {
5231	>	{
5232	>	if (PyString_Check(obj7))
5233	>	arg8 = std::string(PyString_AsString(obj7));
5234	>	else
5235	>	SWIG_exception(SWIG_TypeError, "string expected");
5236	>	}
5237		}
5238		{
5239		try {
5240	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
5240	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
5241
5242	+	}catch (const BossSchedFailure & e) {
5243	+	PyErr_SetString ( SchedulerError, e.what() );
5244	+	return NULL;
5245		}catch (const std::exception& e) {
5246	<	SWIG_exception(SWIG_RuntimeError, e.what());
5246	>	PyErr_SetString ( BossError, e.what() );
5247	>	return NULL;
5248		}
5249		}
5250		resultobj = PyInt_FromLong((long)result);
#	Line 3979 | Line 5254 | static PyObject *_wrap_BossTask_getOutpu
5254		}
5255
5256
5257	<	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
5258	<	int argc;
5259	<	PyObject *argv[6];
5260	<	int ii;
5257	>	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5258	>	PyObject *resultobj;
5259	>	BossTask *arg1 = (BossTask *) 0 ;
5260	>	int arg2 = (int) SCHEDULED ;
5261	>	std::string const &arg3_defvalue = "all" ;
5262	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
5263	>	std::string const &arg4_defvalue = "" ;
5264	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
5265	>	std::string arg5 = (std::string) "" ;
5266	>	std::string arg6 = (std::string) "" ;
5267	>	std::string arg7 = (std::string) "" ;
5268	>	std::string arg8 = (std::string) "" ;
5269	>	unsigned int arg9 = (unsigned int) 0 ;
5270	>	int result;
5271	>	std::string temp3 ;
5272	>	std::string temp4 ;
5273	>	PyObject * obj0 = 0 ;
5274	>	PyObject * obj2 = 0 ;
5275	>	PyObject * obj3 = 0 ;
5276	>	PyObject * obj4 = 0 ;
5277	>	PyObject * obj5 = 0 ;
5278	>	PyObject * obj6 = 0 ;
5279	>	PyObject * obj7 = 0 ;
5280	>	PyObject * obj8 = 0 ;
5281
5282	<	argc = PyObject_Length(args);
5283	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
5284	<	argv[ii] = PyTuple_GetItem(args,ii);
3990	<	}
3991	<	if ((argc >= 1) && (argc <= 5)) {
3992	<	int _v;
5282	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5283	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5284	>	if (obj2) {
5285		{
5286	<	void *ptr;
5287	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5288	<	_v = 0;
3997	<	PyErr_Clear();
5286	>	if (PyString_Check(obj2)) {
5287	>	temp3 = std::string(PyString_AsString(obj2));
5288	>	arg3 = &temp3;
5289		}else {
5290	<	_v = 1;
4000	<	}
4001	<	}
4002	<	if (_v) {
4003	<	if (argc <= 1) {
4004	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4005	<	}
4006	<	{
4007	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4008	<	}
4009	<	if (_v) {
4010	<	if (argc <= 2) {
4011	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4012	<	}
4013	<	{
4014	<	_v = PyString_Check(argv[2]) ? 1 : 0;
4015	<	}
4016	<	if (_v) {
4017	<	if (argc <= 3) {
4018	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4019	<	}
4020	<	{
4021	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4022	<	}
4023	<	if (_v) {
4024	<	if (argc <= 4) {
4025	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4026	<	}
4027	<	{
4028	<	_v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
4029	<	}
4030	<	if (_v) {
4031	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4032	<	}
4033	<	}
4034	<	}
5290	>	SWIG_exception(SWIG_TypeError, "string expected");
5291		}
5292		}
5293		}
5294	<	if ((argc >= 1) && (argc <= 4)) {
4039	<	int _v;
5294	>	if (obj3) {
5295		{
5296	<	void *ptr;
5297	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5298	<	_v = 0;
4044	<	PyErr_Clear();
5296	>	if (PyString_Check(obj3)) {
5297	>	temp4 = std::string(PyString_AsString(obj3));
5298	>	arg4 = &temp4;
5299		}else {
5300	<	_v = 1;
5300	>	SWIG_exception(SWIG_TypeError, "string expected");
5301		}
5302		}
5303	<	if (_v) {
5304	<	if (argc <= 1) {
5305	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
5306	<	}
5307	<	{
5308	<	_v = PyString_Check(argv[1]) ? 1 : 0;
5309	<	}
4056	<	if (_v) {
4057	<	if (argc <= 2) {
4058	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4059	<	}
4060	<	{
4061	<	_v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
4062	<	}
4063	<	if (_v) {
4064	<	if (argc <= 3) {
4065	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4066	<	}
4067	<	{
4068	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4069	<	}
4070	<	if (_v) {
4071	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4072	<	}
4073	<	}
4074	<	}
5303	>	}
5304	>	if (obj4) {
5305	>	{
5306	>	if (PyString_Check(obj4))
5307	>	arg5 = std::string(PyString_AsString(obj4));
5308	>	else
5309	>	SWIG_exception(SWIG_TypeError, "string expected");
5310		}
5311		}
5312	<
5313	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
5312	>	if (obj5) {
5313	>	{
5314	>	if (PyString_Check(obj5))
5315	>	arg6 = std::string(PyString_AsString(obj5));
5316	>	else
5317	>	SWIG_exception(SWIG_TypeError, "string expected");
5318	>	}
5319	>	}
5320	>	if (obj6) {
5321	>	{
5322	>	if (PyString_Check(obj6))
5323	>	arg7 = std::string(PyString_AsString(obj6));
5324	>	else
5325	>	SWIG_exception(SWIG_TypeError, "string expected");
5326	>	}
5327	>	}
5328	>	if (obj7) {
5329	>	{
5330	>	if (PyString_Check(obj7))
5331	>	arg8 = std::string(PyString_AsString(obj7));
5332	>	else
5333	>	SWIG_exception(SWIG_TypeError, "string expected");
5334	>	}
5335	>	}
5336	>	if (obj8) {
5337	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5338	>	if (PyErr_Occurred()) SWIG_fail;
5339	>	}
5340	>	{
5341	>	try {
5342	>	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5343	>
5344	>	}catch (const BossSchedFailure & e) {
5345	>	PyErr_SetString ( SchedulerError, e.what() );
5346	>	return NULL;
5347	>	}catch (const std::exception& e) {
5348	>	PyErr_SetString ( BossError, e.what() );
5349	>	return NULL;
5350	>	}
5351	>	}
5352	>	resultobj = PyInt_FromLong((long)result);
5353	>	return resultobj;
5354	>	fail:
5355		return NULL;
5356		}
5357
#	Line 4092 | Line 5368 | static PyObject *_wrap_BossTask_query(Py
5368		std::string arg6 = (std::string) "" ;
5369		std::string arg7 = (std::string) "" ;
5370		std::string arg8 = (std::string) "" ;
5371	<	bool arg9 = (bool) false ;
5371	>	unsigned int arg9 = (unsigned int) 0 ;
5372	>	bool arg10 = (bool) false ;
5373		int result;
5374		std::string temp3 ;
5375		std::string temp4 ;
#	Line 4104 | Line 5381 | static PyObject *_wrap_BossTask_query(Py
5381		PyObject * obj6 = 0 ;
5382		PyObject * obj7 = 0 ;
5383		PyObject * obj8 = 0 ;
5384	+	PyObject * obj9 = 0 ;
5385
5386	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5386	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5387		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5388		if (obj2) {
5389		{
#	Line 4160 | Line 5438 | static PyObject *_wrap_BossTask_query(Py
5438		}
5439		}
5440		if (obj8) {
5441	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5441	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5442	>	if (PyErr_Occurred()) SWIG_fail;
5443	>	}
5444	>	if (obj9) {
5445	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5446		if (PyErr_Occurred()) SWIG_fail;
5447		}
5448		{
5449		try {
5450	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5450	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5451
5452	+	}catch (const BossSchedFailure & e) {
5453	+	PyErr_SetString ( SchedulerError, e.what() );
5454	+	return NULL;
5455		}catch (const std::exception& e) {
5456	<	SWIG_exception(SWIG_RuntimeError, e.what());
5456	>	PyErr_SetString ( BossError, e.what() );
5457	>	return NULL;
5458		}
5459		}
5460		resultobj = PyInt_FromLong((long)result);
#	Line 4226 | Line 5512 | static PyObject *_wrap_BossTask_query_ou
5512		try {
5513		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5514
5515	+	}catch (const BossSchedFailure & e) {
5516	+	PyErr_SetString ( SchedulerError, e.what() );
5517	+	return NULL;
5518		}catch (const std::exception& e) {
5519	<	SWIG_exception(SWIG_RuntimeError, e.what());
5519	>	PyErr_SetString ( BossError, e.what() );
5520	>	return NULL;
5521		}
5522		}
5523		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4248 | Line 5538 | static PyObject *_wrap_BossTask_clear(Py
5538		try {
5539		(arg1)->clear();
5540
5541	+	}catch (const BossSchedFailure & e) {
5542	+	PyErr_SetString ( SchedulerError, e.what() );
5543	+	return NULL;
5544		}catch (const std::exception& e) {
5545	<	SWIG_exception(SWIG_RuntimeError, e.what());
5545	>	PyErr_SetString ( BossError, e.what() );
5546	>	return NULL;
5547		}
5548		}
5549		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4259 | Line 5553 | static PyObject *_wrap_BossTask_clear(Py
5553		}
5554
5555
5556	<	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5557	<	PyObject *obj;
5558	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5559	<	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5560	<	Py_INCREF(obj);
5561	<	return Py_BuildValue((char *)"");
5556	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5557	>	PyObject *resultobj;
5558	>	BossTask *arg1 = (BossTask *) 0 ;
5559	>	PyObject *arg2 = (PyObject *) 0 ;
5560	>	BossAttributeContainer *arg3 = 0 ;
5561	>	PyObject * obj0 = 0 ;
5562	>	PyObject * obj1 = 0 ;
5563	>	PyObject * obj2 = 0 ;
5564	>
5565	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5566	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5567	>	arg2 = obj1;
5568	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5569	>	if (arg3 == NULL) {
5570	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5571	>	}
5572	>	{
5573	>	try {
5574	>	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5575	>
5576	>	}catch (const BossSchedFailure & e) {
5577	>	PyErr_SetString ( SchedulerError, e.what() );
5578	>	return NULL;
5579	>	}catch (const std::exception& e) {
5580	>	PyErr_SetString ( BossError, e.what() );
5581	>	return NULL;
5582	>	}
5583	>	}
5584	>	Py_INCREF(Py_None); resultobj = Py_None;
5585	>	return resultobj;
5586	>	fail:
5587	>	return NULL;
5588		}
5589	<	static PyObject *_wrap_prompt(PyObject *self, PyObject *args) {
5589	>
5590	>
5591	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5592		PyObject *resultobj;
5593	<	std::string *arg1 = 0 ;
5594	<	bool result;
5595	<	std::string temp1 ;
5593	>	BossTask *arg1 = (BossTask *) 0 ;
5594	>	BossJob *arg2 = (BossJob *) 0 ;
5595	>	PyObject *arg3 = (PyObject *) 0 ;
5596		PyObject * obj0 = 0 ;
5597	+	PyObject * obj1 = 0 ;
5598	+	PyObject * obj2 = 0 ;
5599
5600	<	if(!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) goto fail;
5600	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5601	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5602	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5603	>	arg3 = obj2;
5604		{
5605	<	if (PyString_Check(obj0)) {
5606	<	temp1 = std::string(PyString_AsString(obj0));
5607	<	arg1 = &temp1;
5605	>	try {
5606	>	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5607	>
5608	>	}catch (const BossSchedFailure & e) {
5609	>	PyErr_SetString ( SchedulerError, e.what() );
5610	>	return NULL;
5611	>	}catch (const std::exception& e) {
5612	>	PyErr_SetString ( BossError, e.what() );
5613	>	return NULL;
5614	>	}
5615	>	}
5616	>	Py_INCREF(Py_None); resultobj = Py_None;
5617	>	return resultobj;
5618	>	fail:
5619	>	return NULL;
5620	>	}
5621	>
5622	>
5623	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5624	>	PyObject *resultobj;
5625	>	BossTask *arg1 = (BossTask *) 0 ;
5626	>	PyObject *result;
5627	>	PyObject * obj0 = 0 ;
5628	>
5629	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5630	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5631	>	{
5632	>	try {
5633	>	result = (PyObject *)BossTask_jobsDict(arg1);
5634	>
5635	>	}catch (const BossSchedFailure & e) {
5636	>	PyErr_SetString ( SchedulerError, e.what() );
5637	>	return NULL;
5638	>	}catch (const std::exception& e) {
5639	>	PyErr_SetString ( BossError, e.what() );
5640	>	return NULL;
5641	>	}
5642	>	}
5643	>	resultobj = result;
5644	>	return resultobj;
5645	>	fail:
5646	>	return NULL;
5647	>	}
5648	>
5649	>
5650	>	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5651	>	PyObject *resultobj;
5652	>	BossTask *arg1 = (BossTask *) 0 ;
5653	>	std::string *arg2 = 0 ;
5654	>	PyObject *result;
5655	>	std::string temp2 ;
5656	>	PyObject * obj0 = 0 ;
5657	>	PyObject * obj1 = 0 ;
5658	>
5659	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5660	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5661	>	{
5662	>	if (PyString_Check(obj1)) {
5663	>	temp2 = std::string(PyString_AsString(obj1));
5664	>	arg2 = &temp2;
5665		}else {
5666		SWIG_exception(SWIG_TypeError, "string expected");
5667		}
5668		}
5669		{
5670		try {
5671	<	result = (bool)prompt((std::string const &)*arg1);
5671	>	result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5672
5673	+	}catch (const BossSchedFailure & e) {
5674	+	PyErr_SetString ( SchedulerError, e.what() );
5675	+	return NULL;
5676		}catch (const std::exception& e) {
5677	<	SWIG_exception(SWIG_RuntimeError, e.what());
5677	>	PyErr_SetString ( BossError, e.what() );
5678	>	return NULL;
5679		}
5680		}
5681	<	resultobj = PyInt_FromLong((long)result);
5681	>	resultobj = result;
5682	>	return resultobj;
5683	>	fail:
5684	>	return NULL;
5685	>	}
5686	>
5687	>
5688	>	static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
5689	>	PyObject *resultobj;
5690	>	BossTask *arg1 = (BossTask *) 0 ;
5691	>	std::string *arg2 = 0 ;
5692	>	PyObject *result;
5693	>	std::string temp2 ;
5694	>	PyObject * obj0 = 0 ;
5695	>	PyObject * obj1 = 0 ;
5696	>
5697	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5698	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5699	>	{
5700	>	if (PyString_Check(obj1)) {
5701	>	temp2 = std::string(PyString_AsString(obj1));
5702	>	arg2 = &temp2;
5703	>	}else {
5704	>	SWIG_exception(SWIG_TypeError, "string expected");
5705	>	}
5706	>	}
5707	>	{
5708	>	try {
5709	>	result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
5710	>
5711	>	}catch (const BossSchedFailure & e) {
5712	>	PyErr_SetString ( SchedulerError, e.what() );
5713	>	return NULL;
5714	>	}catch (const std::exception& e) {
5715	>	PyErr_SetString ( BossError, e.what() );
5716	>	return NULL;
5717	>	}
5718	>	}
5719	>	resultobj = result;
5720	>	return resultobj;
5721	>	fail:
5722	>	return NULL;
5723	>	}
5724	>
5725	>
5726	>	static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5727	>	PyObject *resultobj;
5728	>	BossTask *arg1 = (BossTask *) 0 ;
5729	>	PyObject *result;
5730	>	PyObject * obj0 = 0 ;
5731	>
5732	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5733	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5734	>	{
5735	>	try {
5736	>	result = (PyObject *)BossTask_jobStates(arg1);
5737	>
5738	>	}catch (const BossSchedFailure & e) {
5739	>	PyErr_SetString ( SchedulerError, e.what() );
5740	>	return NULL;
5741	>	}catch (const std::exception& e) {
5742	>	PyErr_SetString ( BossError, e.what() );
5743	>	return NULL;
5744	>	}
5745	>	}
5746	>	resultobj = result;
5747	>	return resultobj;
5748	>	fail:
5749	>	return NULL;
5750	>	}
5751	>
5752	>
5753	>	static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5754	>	PyObject *resultobj;
5755	>	BossTask *arg1 = (BossTask *) 0 ;
5756	>	PyObject *result;
5757	>	PyObject * obj0 = 0 ;
5758	>
5759	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5760	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5761	>	{
5762	>	try {
5763	>	result = (PyObject *)BossTask_jobStatistic(arg1);
5764	>
5765	>	}catch (const BossSchedFailure & e) {
5766	>	PyErr_SetString ( SchedulerError, e.what() );
5767	>	return NULL;
5768	>	}catch (const std::exception& e) {
5769	>	PyErr_SetString ( BossError, e.what() );
5770	>	return NULL;
5771	>	}
5772	>	}
5773	>	resultobj = result;
5774	>	return resultobj;
5775	>	fail:
5776	>	return NULL;
5777	>	}
5778	>
5779	>
5780	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5781	>	PyObject *resultobj;
5782	>	BossTask *arg1 = (BossTask *) 0 ;
5783	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5784	>	PyObject *result;
5785	>	PyObject * obj0 = 0 ;
5786	>	PyObject * obj1 = 0 ;
5787	>
5788	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5789	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5790	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5791	>	if (arg2 == NULL) {
5792	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5793	>	}
5794	>	{
5795	>	try {
5796	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5797	>
5798	>	}catch (const BossSchedFailure & e) {
5799	>	PyErr_SetString ( SchedulerError, e.what() );
5800	>	return NULL;
5801	>	}catch (const std::exception& e) {
5802	>	PyErr_SetString ( BossError, e.what() );
5803	>	return NULL;
5804	>	}
5805	>	}
5806	>	resultobj = result;
5807	>	return resultobj;
5808	>	fail:
5809	>	return NULL;
5810	>	}
5811	>
5812	>
5813	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5814	>	PyObject *resultobj;
5815	>	BossTask *arg1 = (BossTask *) 0 ;
5816	>	std::string *arg2 = 0 ;
5817	>	PyObject *result;
5818	>	std::string temp2 ;
5819	>	PyObject * obj0 = 0 ;
5820	>	PyObject * obj1 = 0 ;
5821	>
5822	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5823	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5824	>	{
5825	>	if (PyString_Check(obj1)) {
5826	>	temp2 = std::string(PyString_AsString(obj1));
5827	>	arg2 = &temp2;
5828	>	}else {
5829	>	SWIG_exception(SWIG_TypeError, "string expected");
5830	>	}
5831	>	}
5832	>	{
5833	>	try {
5834	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5835	>
5836	>	}catch (const BossSchedFailure & e) {
5837	>	PyErr_SetString ( SchedulerError, e.what() );
5838	>	return NULL;
5839	>	}catch (const std::exception& e) {
5840	>	PyErr_SetString ( BossError, e.what() );
5841	>	return NULL;
5842	>	}
5843	>	}
5844	>	resultobj = result;
5845	>	return resultobj;
5846	>	fail:
5847	>	return NULL;
5848	>	}
5849	>
5850	>
5851	>	static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5852	>	PyObject *resultobj;
5853	>	BossTask *arg1 = (BossTask *) 0 ;
5854	>	std::string *arg2 = 0 ;
5855	>	std::string *arg3 = 0 ;
5856	>	PyObject *result;
5857	>	std::string temp2 ;
5858	>	std::string temp3 ;
5859	>	PyObject * obj0 = 0 ;
5860	>	PyObject * obj1 = 0 ;
5861	>	PyObject * obj2 = 0 ;
5862	>
5863	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5864	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5865	>	{
5866	>	if (PyString_Check(obj1)) {
5867	>	temp2 = std::string(PyString_AsString(obj1));
5868	>	arg2 = &temp2;
5869	>	}else {
5870	>	SWIG_exception(SWIG_TypeError, "string expected");
5871	>	}
5872	>	}
5873	>	{
5874	>	if (PyString_Check(obj2)) {
5875	>	temp3 = std::string(PyString_AsString(obj2));
5876	>	arg3 = &temp3;
5877	>	}else {
5878	>	SWIG_exception(SWIG_TypeError, "string expected");
5879	>	}
5880	>	}
5881	>	{
5882	>	try {
5883	>	result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5884	>
5885	>	}catch (const BossSchedFailure & e) {
5886	>	PyErr_SetString ( SchedulerError, e.what() );
5887	>	return NULL;
5888	>	}catch (const std::exception& e) {
5889	>	PyErr_SetString ( BossError, e.what() );
5890	>	return NULL;
5891	>	}
5892	>	}
5893	>	resultobj = result;
5894		return resultobj;
5895		fail:
5896		return NULL;
5897		}
5898
5899
5900	+	static PyObject *_wrap_BossTask_programExec(PyObject *self, PyObject *args) {
5901	+	PyObject *resultobj;
5902	+	BossTask *arg1 = (BossTask *) 0 ;
5903	+	std::string *arg2 = 0 ;
5904	+	std::string *arg3 = 0 ;
5905	+	PyObject *result;
5906	+	std::string temp2 ;
5907	+	std::string temp3 ;
5908	+	PyObject * obj0 = 0 ;
5909	+	PyObject * obj1 = 0 ;
5910	+	PyObject * obj2 = 0 ;
5911	+
5912	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
5913	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5914	+	{
5915	+	if (PyString_Check(obj1)) {
5916	+	temp2 = std::string(PyString_AsString(obj1));
5917	+	arg2 = &temp2;
5918	+	}else {
5919	+	SWIG_exception(SWIG_TypeError, "string expected");
5920	+	}
5921	+	}
5922	+	{
5923	+	if (PyString_Check(obj2)) {
5924	+	temp3 = std::string(PyString_AsString(obj2));
5925	+	arg3 = &temp3;
5926	+	}else {
5927	+	SWIG_exception(SWIG_TypeError, "string expected");
5928	+	}
5929	+	}
5930	+	{
5931	+	try {
5932	+	result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5933	+
5934	+	}catch (const BossSchedFailure & e) {
5935	+	PyErr_SetString ( SchedulerError, e.what() );
5936	+	return NULL;
5937	+	}catch (const std::exception& e) {
5938	+	PyErr_SetString ( BossError, e.what() );
5939	+	return NULL;
5940	+	}
5941	+	}
5942	+	resultobj = result;
5943	+	return resultobj;
5944	+	fail:
5945	+	return NULL;
5946	+	}
5947	+
5948	+
5949	+	static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
5950	+	PyObject *resultobj;
5951	+	BossTask *arg1 = (BossTask *) 0 ;
5952	+	std::string *arg2 = 0 ;
5953	+	std::string *arg3 = 0 ;
5954	+	PyObject *result;
5955	+	std::string temp2 ;
5956	+	std::string temp3 ;
5957	+	PyObject * obj0 = 0 ;
5958	+	PyObject * obj1 = 0 ;
5959	+	PyObject * obj2 = 0 ;
5960	+
5961	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
5962	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5963	+	{
5964	+	if (PyString_Check(obj1)) {
5965	+	temp2 = std::string(PyString_AsString(obj1));
5966	+	arg2 = &temp2;
5967	+	}else {
5968	+	SWIG_exception(SWIG_TypeError, "string expected");
5969	+	}
5970	+	}
5971	+	{
5972	+	if (PyString_Check(obj2)) {
5973	+	temp3 = std::string(PyString_AsString(obj2));
5974	+	arg3 = &temp3;
5975	+	}else {
5976	+	SWIG_exception(SWIG_TypeError, "string expected");
5977	+	}
5978	+	}
5979	+	{
5980	+	try {
5981	+	result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5982	+
5983	+	}catch (const BossSchedFailure & e) {
5984	+	PyErr_SetString ( SchedulerError, e.what() );
5985	+	return NULL;
5986	+	}catch (const std::exception& e) {
5987	+	PyErr_SetString ( BossError, e.what() );
5988	+	return NULL;
5989	+	}
5990	+	}
5991	+	resultobj = result;
5992	+	return resultobj;
5993	+	fail:
5994	+	return NULL;
5995	+	}
5996	+
5997	+
5998	+	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5999	+	PyObject *obj;
6000	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6001	+	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
6002	+	Py_INCREF(obj);
6003	+	return Py_BuildValue((char *)"");
6004	+	}
6005		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
6006		PyObject *resultobj;
6007		std::string arg1 = (std::string) "" ;
6008	<	bool arg2 = (bool) false ;
6008	>	std::string arg2 = (std::string) "2" ;
6009	>	std::string arg3 = (std::string) "" ;
6010	>	std::string arg4 = (std::string) "" ;
6011	>	bool arg5 = (bool) false ;
6012		BossAdministratorSession *result;
6013		PyObject * obj0 = 0 ;
6014		PyObject * obj1 = 0 ;
6015	+	PyObject * obj2 = 0 ;
6016	+	PyObject * obj3 = 0 ;
6017	+	PyObject * obj4 = 0 ;
6018
6019	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
6019	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6020		if (obj0) {
6021		{
6022		if (PyString_Check(obj0))
#	Line 4315 | Line 6026 | static PyObject *_wrap_new_BossAdministr
6026		}
6027		}
6028		if (obj1) {
6029	<	arg2 = PyInt_AsLong(obj1) ? true : false;
6029	>	{
6030	>	if (PyString_Check(obj1))
6031	>	arg2 = std::string(PyString_AsString(obj1));
6032	>	else
6033	>	SWIG_exception(SWIG_TypeError, "string expected");
6034	>	}
6035	>	}
6036	>	if (obj2) {
6037	>	{
6038	>	if (PyString_Check(obj2))
6039	>	arg3 = std::string(PyString_AsString(obj2));
6040	>	else
6041	>	SWIG_exception(SWIG_TypeError, "string expected");
6042	>	}
6043	>	}
6044	>	if (obj3) {
6045	>	{
6046	>	if (PyString_Check(obj3))
6047	>	arg4 = std::string(PyString_AsString(obj3));
6048	>	else
6049	>	SWIG_exception(SWIG_TypeError, "string expected");
6050	>	}
6051	>	}
6052	>	if (obj4) {
6053	>	arg5 = PyInt_AsLong(obj4) ? true : false;
6054		if (PyErr_Occurred()) SWIG_fail;
6055		}
6056		{
6057		try {
6058	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
6058	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
6059
6060	+	}catch (const BossSchedFailure & e) {
6061	+	PyErr_SetString ( SchedulerError, e.what() );
6062	+	return NULL;
6063		}catch (const std::exception& e) {
6064	<	SWIG_exception(SWIG_RuntimeError, e.what());
6064	>	PyErr_SetString ( BossError, e.what() );
6065	>	return NULL;
6066		}
6067		}
6068		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4344 | Line 6083 | static PyObject *_wrap_delete_BossAdmini
6083		try {
6084		delete arg1;
6085
6086	+	}catch (const BossSchedFailure & e) {
6087	+	PyErr_SetString ( SchedulerError, e.what() );
6088	+	return NULL;
6089		}catch (const std::exception& e) {
6090	<	SWIG_exception(SWIG_RuntimeError, e.what());
6090	>	PyErr_SetString ( BossError, e.what() );
6091	>	return NULL;
6092		}
6093		}
6094		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4367 | Line 6110 | static PyObject *_wrap_BossAdministrator
6110		try {
6111		result = (int)(arg1)->configureDB();
6112
6113	+	}catch (const BossSchedFailure & e) {
6114	+	PyErr_SetString ( SchedulerError, e.what() );
6115	+	return NULL;
6116		}catch (const std::exception& e) {
6117	<	SWIG_exception(SWIG_RuntimeError, e.what());
6117	>	PyErr_SetString ( BossError, e.what() );
6118	>	return NULL;
6119		}
6120		}
6121		resultobj = PyInt_FromLong((long)result);
#	Line 4401 | Line 6148 | static PyObject *_wrap_BossAdministrator
6148		try {
6149		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
6150
6151	+	}catch (const BossSchedFailure & e) {
6152	+	PyErr_SetString ( SchedulerError, e.what() );
6153	+	return NULL;
6154		}catch (const std::exception& e) {
6155	<	SWIG_exception(SWIG_RuntimeError, e.what());
6155	>	PyErr_SetString ( BossError, e.what() );
6156	>	return NULL;
6157		}
6158		}
6159		resultobj = PyInt_FromLong((long)result);
#	Line 4435 | Line 6186 | static PyObject *_wrap_BossAdministrator
6186		try {
6187		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
6188
6189	+	}catch (const BossSchedFailure & e) {
6190	+	PyErr_SetString ( SchedulerError, e.what() );
6191	+	return NULL;
6192		}catch (const std::exception& e) {
6193	<	SWIG_exception(SWIG_RuntimeError, e.what());
6193	>	PyErr_SetString ( BossError, e.what() );
6194	>	return NULL;
6195		}
6196		}
6197		resultobj = PyInt_FromLong((long)result);
#	Line 4469 | Line 6224 | static PyObject *_wrap_BossAdministrator
6224		try {
6225		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
6226
6227	+	}catch (const BossSchedFailure & e) {
6228	+	PyErr_SetString ( SchedulerError, e.what() );
6229	+	return NULL;
6230		}catch (const std::exception& e) {
6231	<	SWIG_exception(SWIG_RuntimeError, e.what());
6231	>	PyErr_SetString ( BossError, e.what() );
6232	>	return NULL;
6233		}
6234		}
6235		resultobj = PyInt_FromLong((long)result);
#	Line 4503 | Line 6262 | static PyObject *_wrap_BossAdministrator
6262		try {
6263		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
6264
6265	+	}catch (const BossSchedFailure & e) {
6266	+	PyErr_SetString ( SchedulerError, e.what() );
6267	+	return NULL;
6268		}catch (const std::exception& e) {
6269	<	SWIG_exception(SWIG_RuntimeError, e.what());
6269	>	PyErr_SetString ( BossError, e.what() );
6270	>	return NULL;
6271		}
6272		}
6273		resultobj = PyInt_FromLong((long)result);
#	Line 4537 | Line 6300 | static PyObject *_wrap_BossAdministrator
6300		try {
6301		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
6302
6303	+	}catch (const BossSchedFailure & e) {
6304	+	PyErr_SetString ( SchedulerError, e.what() );
6305	+	return NULL;
6306		}catch (const std::exception& e) {
6307	<	SWIG_exception(SWIG_RuntimeError, e.what());
6307	>	PyErr_SetString ( BossError, e.what() );
6308	>	return NULL;
6309		}
6310		}
6311		resultobj = PyInt_FromLong((long)result);
#	Line 4603 | Line 6370 | static PyObject *_wrap_BossAdministrator
6370		try {
6371		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
6372
6373	+	}catch (const BossSchedFailure & e) {
6374	+	PyErr_SetString ( SchedulerError, e.what() );
6375	+	return NULL;
6376		}catch (const std::exception& e) {
6377	<	SWIG_exception(SWIG_RuntimeError, e.what());
6377	>	PyErr_SetString ( BossError, e.what() );
6378	>	return NULL;
6379		}
6380		}
6381		resultobj = PyInt_FromLong((long)result);
#	Line 4693 | Line 6464 | static PyObject *_wrap_BossAdministrator
6464		try {
6465		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
6466
6467	+	}catch (const BossSchedFailure & e) {
6468	+	PyErr_SetString ( SchedulerError, e.what() );
6469	+	return NULL;
6470		}catch (const std::exception& e) {
6471	<	SWIG_exception(SWIG_RuntimeError, e.what());
6471	>	PyErr_SetString ( BossError, e.what() );
6472	>	return NULL;
6473		}
6474		}
6475		resultobj = PyInt_FromLong((long)result);
#	Line 4769 | Line 6544 | static PyObject *_wrap_BossAdministrator
6544		try {
6545		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6546
6547	+	}catch (const BossSchedFailure & e) {
6548	+	PyErr_SetString ( SchedulerError, e.what() );
6549	+	return NULL;
6550		}catch (const std::exception& e) {
6551	<	SWIG_exception(SWIG_RuntimeError, e.what());
6551	>	PyErr_SetString ( BossError, e.what() );
6552	>	return NULL;
6553		}
6554		}
6555		resultobj = PyInt_FromLong((long)result);
#	Line 4798 | Line 6577 | static PyObject *_wrap_BossAdministrator
6577		std::string arg13 = (std::string) "" ;
6578		bool arg14 = (bool) false ;
6579		bool arg15 = (bool) false ;
6580	+	bool arg16 = (bool) false ;
6581	+	bool arg17 = (bool) false ;
6582		int result;
6583		std::string temp2 ;
6584		std::string temp11 ;
#	Line 4816 | Line 6597 | static PyObject *_wrap_BossAdministrator
6597		PyObject * obj12 = 0 ;
6598		PyObject * obj13 = 0 ;
6599		PyObject * obj14 = 0 ;
6600	+	PyObject * obj15 = 0 ;
6601	+	PyObject * obj16 = 0 ;
6602
6603	<	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;
6603	>	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;
6604		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6605		{
6606		if (PyString_Check(obj1)) {
#	Line 4925 | Line 6708 | static PyObject *_wrap_BossAdministrator
6708		arg15 = PyInt_AsLong(obj14) ? true : false;
6709		if (PyErr_Occurred()) SWIG_fail;
6710		}
6711	+	if (obj15) {
6712	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6713	+	if (PyErr_Occurred()) SWIG_fail;
6714	+	}
6715	+	if (obj16) {
6716	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6717	+	if (PyErr_Occurred()) SWIG_fail;
6718	+	}
6719		{
6720		try {
6721	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
6721	>	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);
6722
6723	+	}catch (const BossSchedFailure & e) {
6724	+	PyErr_SetString ( SchedulerError, e.what() );
6725	+	return NULL;
6726		}catch (const std::exception& e) {
6727	<	SWIG_exception(SWIG_RuntimeError, e.what());
6727	>	PyErr_SetString ( BossError, e.what() );
6728	>	return NULL;
6729		}
6730		}
6731		resultobj = PyInt_FromLong((long)result);
#	Line 4952 | Line 6747 | static PyObject *_wrap_BossAdministrator
6747		try {
6748		result = (arg1)->help();
6749
6750	+	}catch (const BossSchedFailure & e) {
6751	+	PyErr_SetString ( SchedulerError, e.what() );
6752	+	return NULL;
6753		}catch (const std::exception& e) {
6754	<	SWIG_exception(SWIG_RuntimeError, e.what());
6754	>	PyErr_SetString ( BossError, e.what() );
6755	>	return NULL;
6756		}
6757		}
6758		{
#	Line 4991 | Line 6790 | static PyObject *_wrap_BossAdministrator
6790		try {
6791		result = (arg1)->SQL(arg2,arg3);
6792
6793	+	}catch (const BossSchedFailure & e) {
6794	+	PyErr_SetString ( SchedulerError, e.what() );
6795	+	return NULL;
6796		}catch (const std::exception& e) {
6797	<	SWIG_exception(SWIG_RuntimeError, e.what());
6797	>	PyErr_SetString ( BossError, e.what() );
6798	>	return NULL;
6799		}
6800		}
6801		{
#	Line 5063 | Line 6866 | static PyObject *_wrap_BossAdministrator
6866		try {
6867		result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6868
6869	+	}catch (const BossSchedFailure & e) {
6870	+	PyErr_SetString ( SchedulerError, e.what() );
6871	+	return NULL;
6872	+	}catch (const std::exception& e) {
6873	+	PyErr_SetString ( BossError, e.what() );
6874	+	return NULL;
6875	+	}
6876	+	}
6877	+	resultobj = PyInt_FromLong((long)result);
6878	+	return resultobj;
6879	+	fail:
6880	+	return NULL;
6881	+	}
6882	+
6883	+
6884	+	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
6885	+	PyObject *resultobj;
6886	+	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6887	+	std::string arg2 ;
6888	+	int result;
6889	+	PyObject * obj0 = 0 ;
6890	+	PyObject * obj1 = 0 ;
6891	+
6892	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6893	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6894	+	{
6895	+	if (PyString_Check(obj1))
6896	+	arg2 = std::string(PyString_AsString(obj1));
6897	+	else
6898	+	SWIG_exception(SWIG_TypeError, "string expected");
6899	+	}
6900	+	{
6901	+	try {
6902	+	result = (int)(arg1)->registerPlugins(arg2);
6903	+
6904	+	}catch (const BossSchedFailure & e) {
6905	+	PyErr_SetString ( SchedulerError, e.what() );
6906	+	return NULL;
6907		}catch (const std::exception& e) {
6908	<	SWIG_exception(SWIG_RuntimeError, e.what());
6908	>	PyErr_SetString ( BossError, e.what() );
6909	>	return NULL;
6910		}
6911		}
6912		resultobj = PyInt_FromLong((long)result);
#	Line 5097 | Line 6939 | static PyMethodDef SwigMethods[] = {
6939		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6940		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6941		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6942	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6943	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6944	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6945	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6946	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6947	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6942	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6943	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6944	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6945	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6946	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6947	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6948	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6949	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6950	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6951	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6952	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6953	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6954	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6955	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6956		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6957		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6958	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6959		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6960		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6961		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6962	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6963	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6964	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6965	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6966		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6967		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6968		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5119 | Line 6974 | static PyMethodDef SwigMethods[] = {
6974		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6975		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6976		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6977	+	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
6978	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6979	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
6980	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6981	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6982	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6983	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6984	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6985	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6986	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6987		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5123	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5124	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
6988		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
5126	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6989		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6990		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
6991	<	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6992	<	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6993	<	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
6994	<	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6995	<	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6991	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6992	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6993	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6994	>	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
6995	>	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
6996		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6997		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6998		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
6999		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7000	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7001		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
7002	<	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5140	<	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7002	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7003		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
7004		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
5143	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7005		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7006		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7007		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
#	Line 5148 | Line 7009 | static PyMethodDef SwigMethods[] = {
7009		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
7010		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
7011		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7012	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7013	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7014	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7015		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7016		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7017		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7018	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7019	+	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7020	+	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7021	+	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7022	+	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7023	+	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7024	+	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7025	+	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7026	+	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7027	+	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7028	+	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7029	+	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7030		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5155	–	{ (char *)"prompt", _wrap_prompt, METH_VARARGS },
7031		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7032		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
7033		{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
#	Line 5168 | Line 7043 | static PyMethodDef SwigMethods[] = {
7043		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
7044		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
7045		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
7046	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
7047		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
7048		{ NULL, NULL }
7049		};
#	Line 5175 | Line 7051 | static PyMethodDef SwigMethods[] = {
7051
7052		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7053
5178	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7054		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}};
7055	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7056		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}};
7057	+	static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7058	+	static swig_type_info _swigt__p_std__vectorTBossTask_p_t[] = {{"_p_std__vectorTBossTask_p_t", 0, "std::vector<BossTask * > *", 0},{"_p_std__vectorTBossTask_p_t"},{0}};
7059	+	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7060		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}};
7061		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7062		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7063		static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7064	<	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7064	>	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7065		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7066	+	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7067		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
7068		static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
7069		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
#	Line 5195 | Line 7075 | static swig_type_info _swigt__p_std__vec
7075		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7076
7077		static swig_type_info *swig_types_initial[] = {
5198	–	_swigt__p_XMLDoc,
7078		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
7079	+	_swigt__p_XMLDoc,
7080		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7081	+	_swigt__p_BossProgramExec,
7082	+	_swigt__p_std__vectorTBossTask_p_t,
7083	+	_swigt__p_BossChain,
7084		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
7085		_swigt__p_BossTask,
7086		_swigt__p_BossTaskException,
7087		_swigt__p_std__ostream,
7088	<	_swigt__p_BossAttributeContainer,
7088	>	_swigt__p_BossProgram,
7089		_swigt__p_printOption,
7090	+	_swigt__p_BossAttributeContainer,
7091		_swigt__p_BossJob,
7092		_swigt__p_BossDatabase,
7093		_swigt__p_BossSession,
#	Line 5255 | Line 7139 | SWIGEXPORT(void) SWIG_init(void) {
7139		}
7140		SWIG_InstallConstants(d,swig_const_table);
7141
7142	+
7143	+	// define custom exceptions
7144	+	PyObject *e;
7145	+	PyMethodDef tp_methods = {
7146	+	NULL, NULL, 0, NULL
7147	+	};
7148	+	e = Py_InitModule("BossSession", &tp_methods);
7149	+	// generic BOSS exception
7150	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
7151	+	Py_INCREF(BossError);
7152	+	PyModule_AddObject(e, "BossError", BossError);
7153	+	// scheduler interaction BOSS exception
7154	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
7155	+	Py_INCREF(SchedulerError);
7156	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
7157	+
7158		}
7159

Diff Legend

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