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.3 by gcodispo, Tue Oct 24 14:11:24 2006 UTC vs.
Revision 1.21 by gcodispo, Tue Feb 20 09:57:08 2007 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t swig_types[0]
658	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[1]
659	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[2]
660	<	#define  SWIGTYPE_p_XMLDoc swig_types[3]
657	>	#define  SWIGTYPE_p_XMLDoc swig_types[0]
658	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
659	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660	>	#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[3]
661		#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662		#define  SWIGTYPE_p_std__ostream swig_types[5]
663		#define  SWIGTYPE_p_BossTask swig_types[6]
664		#define  SWIGTYPE_p_BossTaskException swig_types[7]
665	<	#define  SWIGTYPE_p_std__string swig_types[8]
666	<	#define  SWIGTYPE_p_printOption swig_types[9]
667	<	#define  SWIGTYPE_p_BossDatabase swig_types[10]
668	<	#define  SWIGTYPE_p_BossJob swig_types[11]
665	>	#define  SWIGTYPE_p_printOption swig_types[8]
666	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[9]
667	>	#define  SWIGTYPE_p_BossJob swig_types[10]
668	>	#define  SWIGTYPE_p_BossDatabase swig_types[11]
669		#define  SWIGTYPE_p_BossSession swig_types[12]
670		#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671		#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672		#define  SWIGTYPE_p_BossAdministratorSession swig_types[15]
673	<	#define  SWIGTYPE_p_jobStates swig_types[16]
673	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674		#define  SWIGTYPE_p_BossTask__job_iterator swig_types[17]
675	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[18]
675	>	#define  SWIGTYPE_p_jobStates swig_types[18]
676		static swig_type_info *swig_types[20];
677
678		/* -------- TYPES TABLE (END) -------- */
#	Line 851 | Line 851 | PyObject *std_maplstd_stringcstd_string_
851		" for iterator support");
852		#endif
853		}
854	+	std::string std_vectorlstd_string_g_pop___(std::vector<std::string > *self){
855	+	if (self->size() == 0)
856	+	throw std::out_of_range("pop from empty vector");
857	+	std::string x = self->back();
858	+	self->pop_back();
859	+	return x;
860	+	}
861	+	std::string std_vectorlstd_string_g___getitem_____(std::vector<std::string > *self,int i){
862	+	int size = int(self->size());
863	+	if (i<0) i += size;
864	+	if (i>=0 && i<size)
865	+	return (*self)[i];
866	+	else
867	+	throw std::out_of_range("vector index out of range");
868	+	}
869	+	std::vector<std::string > std_vectorlstd_string_g___getslice_____(std::vector<std::string > *self,int i,int j){
870	+	int size = int(self->size());
871	+	if (i<0) i = size+i;
872	+	if (j<0) j = size+j;
873	+	if (i<0) i = 0;
874	+	if (j>size) j = size;
875	+	std::vector<std::string > tmp(j-i);
876	+	std::copy(self->begin()+i,self->begin()+j,tmp.begin());
877	+	return tmp;
878	+	}
879	+	void std_vectorlstd_string_g___setitem_____(std::vector<std::string > *self,int i,std::string x){
880	+	int size = int(self->size());
881	+	if (i<0) i+= size;
882	+	if (i>=0 && i<size)
883	+	(*self)[i] = x;
884	+	else
885	+	throw std::out_of_range("vector index out of range");
886	+	}
887	+	void std_vectorlstd_string_g___setslice_____(std::vector<std::string > *self,int i,int j,std::vector<std::string > const &v){
888	+	int size = int(self->size());
889	+	if (i<0) i = size+i;
890	+	if (j<0) j = size+j;
891	+	if (i<0) i = 0;
892	+	if (j>size) j = size;
893	+	if (int(v.size()) == j-i) {
894	+	std::copy(v.begin(),v.end(),self->begin()+i);
895	+	} else {
896	+	self->erase(self->begin()+i,self->begin()+j);
897	+	if (i+1 <= int(self->size()))
898	+	self->insert(self->begin()+i,v.begin(),v.end());
899	+	else
900	+	self->insert(self->end(),v.begin(),v.end());
901	+	}
902	+	}
903	+	void std_vectorlstd_string_g___delitem_____(std::vector<std::string > *self,int i){
904	+	int size = int(self->size());
905	+	if (i<0) i+= size;
906	+	if (i>=0 && i<size)
907	+	self->erase(self->begin()+i);
908	+	else
909	+	throw std::out_of_range("vector index out of range");
910	+	}
911	+	void std_vectorlstd_string_g___delslice_____(std::vector<std::string > *self,int i,int j){
912	+	int size = int(self->size());
913	+	if (i<0) i = size+i;
914	+	if (j<0) j = size+j;
915	+	if (i<0) i = 0;
916	+	if (j>size) j = size;
917	+	self->erase(self->begin()+i,self->begin()+j);
918	+	}
919
920	+	static PyObject * BossError;
921	+	static PyObject * SchedulerError;
922		#include "BossSession.h"
923		#include "BossAdministratorSession.h"
924		#include "BossTask.h"
#	Line 861 | Line 928 | PyObject *std_maplstd_stringcstd_string_
928		#include "BossDBObject.h"
929		#include "BossProgram.h"
930		#include "BossProgramExec.h"
931	<
932	<	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){
933	<	self->jobQuery ( filter_opt, taskRange, jobRange, subn,
934	<	type, user, after, before, avoidCheck);
931	>	#include "BossDatabase.h"
932	>	#include "BossScheduler.h"
933	>	#include "BossDeclaration.h"
934	>
935	>	PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
936	>	PyObject *  my_list = PyList_New( my_vec.size());
937	>	unsigned int index = 0;
938	>	for ( std::vector<std::string>::const_iterator it = my_vec.begin ();
939	>	it != my_vec.end(); ++it, ++index) {
940	>	PyList_SetItem( my_list, index, PyString_FromString( it->c_str() ));
941	>	}
942	>	return my_list;
943	>	}
944	>	PyObject *BossSession_CHTools(BossSession *self){
945	>	std::vector<std::string> my_vec = self->showCHTools();
946	>	return BossSession_show( self, my_vec );
947	>	}
948	>	PyObject *BossSession_ProgramTypes(BossSession *self){
949	>	std::vector<std::string> my_vec = self->showProgramTypes();
950	>	return BossSession_show( self, my_vec );
951	>	}
952	>	PyObject *BossSession_RTMons(BossSession *self){
953	>	std::vector<std::string> my_vec = self->showRTMon();
954	>	return BossSession_show( self, my_vec );
955	>	}
956	>	PyObject *BossSession_schedulers(BossSession *self){
957	>	std::vector<std::string> my_vec = self->showSchedulers();
958	>	return BossSession_show( self, my_vec );
959	>	}
960	>	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){
961	>	std::vector<std::string> my_vec = self->listMatch( scheduler,
962	>	schclassad,
963	>	keepfile,
964	>	taskid,
965	>	jobid,
966	>	timeout);
967	>	return BossSession_show( self, my_vec );
968	>	}
969	>	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,unsigned int timeout,bool avoidCheck){
970	>	if ( !avoidCheck ) {
971	>	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
972	>	type, user, after, before, timeout );
973	>	}
974		PyObject * job_dict = PyList_New(0);
975		std::vector <std::string>
976		taskList = self->selectTasks( taskRange, before, after, user);
#	Line 872 | Line 978 | PyObject *BossSession_queryTasks(BossSes
978		it!= taskList.end(); ++it ) {
979		PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
980		}
875	–
876	–	//       int size = taskList.size();
877	–	//       PyObject * job_dict = PyList_New(0);
878	–	//       for ( unsigned int i = 0; i < size; ++i ) {
879	–	//      PyList_SetItem(job_dict,i, );
880	–	//      self->makeBossTask( *it );
881	–	//       }
981		return  job_dict;
982		}
983	+	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
984	+	std::string tmp;
985	+	BossAttributeContainer::const_iterator it_end = obj.end ();
986	+	for (BossAttributeContainer::const_iterator it = obj.begin ();
987	+	it != it_end; ++it) {
988	+	tmp = (*it).first.name ();
989	+	char * key = new char[ tmp.size() ];
990	+	key = strdup(tmp.c_str());
991	+	tmp = (*it).second.value ();
992	+	PyObject * val = PyString_FromString( tmp.c_str() );
993	+	PyDict_SetItemString( dict, key, val );
994	+	delete [] key;
995	+	}
996	+	return dict;
997	+	}
998		PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
999
1000		PyObject * job_dict = PyDict_New();
887	–
1001		std::string tmp;
1002
1003		BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1004	<	BossAttributeContainer::const_iterator it_end = obj.end ();
892	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
893	<	it != it_end; ++it) {
894	<	tmp = (*it).first.name ();
895	<	char * key = new char[ tmp.size() ];
896	<	key = strdup(tmp.c_str());
897	<	tmp = (*it).second.value ();
898	<	PyObject * val = PyString_FromString( tmp.c_str() );
899	<	PyDict_SetItemString( job_dict, key, val );
900	<	delete [] key;
901	<	}
1004	>	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1005
1006		std::set<std::string> sch = (*jit)->getSchedulerElements();
1007		std::set<std::string>::const_iterator sch_end =  sch.end();
#	Line 914 | Line 1017 | PyObject *BossTask_jobDict(BossTask cons
1017		}
1018		return job_dict;
1019		}
1020	<	PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
1020	>	PyObject *BossTask_jobsDict(BossTask *self){
1021
1022		PyObject * job_dict = PyDict_New();
1023	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1024		for (BossTask::job_iterator jit = self->job_begin ();
1025		jit != self->job_end (); ++jit) {
1026		std::string id = (*jit)->chainId();
#	Line 932 | Line 1036 | PyObject *BossTask_progDict(BossTask con
1036
1037		std::string tmp;
1038
935	–	BossAttributeContainer::const_iterator it;
936	–	BossAttributeContainer::const_iterator it_end;
937	–
1039		// PROGRAM
1040		BossAttributeContainer obj =
1041		(programs_it->first).getTableEntries("PROGRAM");
1042	<	it_end = obj.end ();
942	<	for ( it = obj.begin (); it != it_end; ++it) {
943	<	tmp = (*it).first.name ();
944	<	char * key = new char[ tmp.size() ];
945	<	key = strdup(tmp.c_str());
946	<	tmp = (*it).second.value ();
947	<	PyObject * val = PyString_FromString( tmp.c_str() );
948	<	PyDict_SetItemString( job_dict, key, val );
949	<	delete [] key;
950	<	}
1042	>	BossTask_appendToPyDict ( self, job_dict, obj );
1043
1044		// PROGRAM_EXEC
1045		obj.clear();
1046		obj = (programs_it->second).getTableEntries("PROGRAM_EXEC");
1047	<	it_end = obj.end ();
956	<	for ( it = obj.begin (); it != it_end; ++it) {
957	<	tmp = (*it).first.name ();
958	<	char * key = new char[ tmp.size() ];
959	<	key = strdup(tmp.c_str());
960	<	tmp = (*it).second.value ();
961	<	PyObject * val = PyString_FromString( tmp.c_str() );
962	<	PyDict_SetItemString( job_dict, key, val );
963	<	delete [] key;
964	<	}
965	<
1047	>	BossTask_appendToPyDict ( self, job_dict, obj );
1048
1049		// SPECIFICS
1050	<	std::vector < BossAttributeContainer >::const_iterator it2;
1051	<	std::vector < BossAttributeContainer >::const_iterator it2_end = (programs_it->second).specEnd ();
1052	<	for ( it2 = (programs_it->second).specBegin (); it2 != it2_end; ++it2) {
1053	<	it_end = it2->end ();
972	<	for ( it = it2->begin (); it != it_end; ++it) {
973	<	tmp = (*it).first.name ();
974	<	char * key = new char[ tmp.size() ];
975	<	key = strdup(tmp.c_str());
976	<	tmp = (*it).second.value ();
977	<	PyObject * val = PyString_FromString( tmp.c_str() );
978	<	PyDict_SetItemString( job_dict, key, val );
979	<	delete [] key;
980	<	}
1050	>	std::vector < BossAttributeContainer >::const_iterator it;
1051	>	std::vector < BossAttributeContainer >::const_iterator it_end = (programs_it->second).specEnd ();
1052	>	for ( it = (programs_it->second).specBegin (); it != it_end; ++it) {
1053	>	BossTask_appendToPyDict ( self, job_dict, *it );
1054		}
1055		return job_dict;
1056		}
#	Line 1016 | Line 1089 | static PyObject *_wrap_new_objectMap__SW
1089		try {
1090		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1091
1092	+	}catch (const BossSchedFailure & e) {
1093	+	PyErr_SetString ( SchedulerError, e.what() );
1094	+	return NULL;
1095		}catch (const std::exception& e) {
1096	<	SWIG_exception(SWIG_RuntimeError, e.what());
1096	>	PyErr_SetString ( BossError, e.what() );
1097	>	return NULL;
1098		}
1099		}
1100		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1075 | Line 1152 | static PyObject *_wrap_new_objectMap__SW
1152		try {
1153		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1154
1155	+	}catch (const BossSchedFailure & e) {
1156	+	PyErr_SetString ( SchedulerError, e.what() );
1157	+	return NULL;
1158		}catch (const std::exception& e) {
1159	<	SWIG_exception(SWIG_RuntimeError, e.what());
1159	>	PyErr_SetString ( BossError, e.what() );
1160	>	return NULL;
1161		}
1162		}
1163		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1190 | Line 1271 | static PyObject *_wrap_objectMap___len__
1271		try {
1272		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1273
1274	+	}catch (const BossSchedFailure & e) {
1275	+	PyErr_SetString ( SchedulerError, e.what() );
1276	+	return NULL;
1277		}catch (const std::exception& e) {
1278	<	SWIG_exception(SWIG_RuntimeError, e.what());
1278	>	PyErr_SetString ( BossError, e.what() );
1279	>	return NULL;
1280		}
1281		}
1282		resultobj = PyInt_FromLong((long)result);
#	Line 1212 | Line 1297 | static PyObject *_wrap_objectMap_clear(P
1297		try {
1298		(arg1)->clear();
1299
1300	+	}catch (const BossSchedFailure & e) {
1301	+	PyErr_SetString ( SchedulerError, e.what() );
1302	+	return NULL;
1303		}catch (const std::exception& e) {
1304	<	SWIG_exception(SWIG_RuntimeError, e.what());
1304	>	PyErr_SetString ( BossError, e.what() );
1305	>	return NULL;
1306		}
1307		}
1308		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1235 | Line 1324 | static PyObject *_wrap_objectMap___nonze
1324		try {
1325		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1326
1327	+	}catch (const BossSchedFailure & e) {
1328	+	PyErr_SetString ( SchedulerError, e.what() );
1329	+	return NULL;
1330		}catch (const std::exception& e) {
1331	<	SWIG_exception(SWIG_RuntimeError, e.what());
1331	>	PyErr_SetString ( BossError, e.what() );
1332	>	return NULL;
1333		}
1334		}
1335		resultobj = PyInt_FromLong((long)result);
#	Line 1307 | Line 1400 | static PyObject *_wrap_objectMap___setit
1400		try {
1401		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1402
1403	+	}catch (const BossSchedFailure & e) {
1404	+	PyErr_SetString ( SchedulerError, e.what() );
1405	+	return NULL;
1406		}catch (const std::exception& e) {
1407	<	SWIG_exception(SWIG_RuntimeError, e.what());
1407	>	PyErr_SetString ( BossError, e.what() );
1408	>	return NULL;
1409		}
1410		}
1411		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1369 | Line 1466 | static PyObject *_wrap_objectMap_has_key
1466		try {
1467		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1468
1469	+	}catch (const BossSchedFailure & e) {
1470	+	PyErr_SetString ( SchedulerError, e.what() );
1471	+	return NULL;
1472		}catch (const std::exception& e) {
1473	<	SWIG_exception(SWIG_RuntimeError, e.what());
1473	>	PyErr_SetString ( BossError, e.what() );
1474	>	return NULL;
1475		}
1476		}
1477		resultobj = PyInt_FromLong((long)result);
#	Line 1392 | Line 1493 | static PyObject *_wrap_objectMap_keys(Py
1493		try {
1494		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1495
1496	+	}catch (const BossSchedFailure & e) {
1497	+	PyErr_SetString ( SchedulerError, e.what() );
1498	+	return NULL;
1499		}catch (const std::exception& e) {
1500	<	SWIG_exception(SWIG_RuntimeError, e.what());
1500	>	PyErr_SetString ( BossError, e.what() );
1501	>	return NULL;
1502		}
1503		}
1504		resultobj = result;
#	Line 1415 | Line 1520 | static PyObject *_wrap_objectMap_values(
1520		try {
1521		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1522
1523	+	}catch (const BossSchedFailure & e) {
1524	+	PyErr_SetString ( SchedulerError, e.what() );
1525	+	return NULL;
1526		}catch (const std::exception& e) {
1527	<	SWIG_exception(SWIG_RuntimeError, e.what());
1527	>	PyErr_SetString ( BossError, e.what() );
1528	>	return NULL;
1529		}
1530		}
1531		resultobj = result;
#	Line 1438 | Line 1547 | static PyObject *_wrap_objectMap_items(P
1547		try {
1548		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1549
1550	+	}catch (const BossSchedFailure & e) {
1551	+	PyErr_SetString ( SchedulerError, e.what() );
1552	+	return NULL;
1553		}catch (const std::exception& e) {
1554	<	SWIG_exception(SWIG_RuntimeError, e.what());
1554	>	PyErr_SetString ( BossError, e.what() );
1555	>	return NULL;
1556		}
1557		}
1558		resultobj = result;
#	Line 1469 | Line 1582 | static PyObject *_wrap_objectMap___conta
1582		try {
1583		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1584
1585	+	}catch (const BossSchedFailure & e) {
1586	+	PyErr_SetString ( SchedulerError, e.what() );
1587	+	return NULL;
1588		}catch (const std::exception& e) {
1589	<	SWIG_exception(SWIG_RuntimeError, e.what());
1589	>	PyErr_SetString ( BossError, e.what() );
1590	>	return NULL;
1591		}
1592		}
1593		resultobj = PyInt_FromLong((long)result);
#	Line 1515 | Line 1632 | static PyObject *_wrap_delete_objectMap(
1632		try {
1633		delete arg1;
1634
1635	+	}catch (const BossSchedFailure & e) {
1636	+	PyErr_SetString ( SchedulerError, e.what() );
1637	+	return NULL;
1638		}catch (const std::exception& e) {
1639	<	SWIG_exception(SWIG_RuntimeError, e.what());
1639	>	PyErr_SetString ( BossError, e.what() );
1640	>	return NULL;
1641		}
1642		}
1643		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1533 | Line 1654 | static PyObject * objectMap_swigregister
1654		Py_INCREF(obj);
1655		return Py_BuildValue((char *)"");
1656		}
1657	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
1657	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1658		PyObject *resultobj;
1659	<	BossSession *arg1 = (BossSession *) 0 ;
1660	<	int arg2 = (int) SCHEDULED ;
1540	<	std::string const &arg3_defvalue = "all" ;
1541	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
1542	<	std::string const &arg4_defvalue = "all" ;
1543	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
1544	<	std::string const &arg5_defvalue = "" ;
1545	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
1546	<	std::string arg6 = (std::string) "" ;
1547	<	std::string arg7 = (std::string) "" ;
1548	<	std::string arg8 = (std::string) "" ;
1549	<	std::string arg9 = (std::string) "" ;
1550	<	bool arg10 = (bool) false ;
1551	<	PyObject *result;
1552	<	std::string temp3 ;
1553	<	std::string temp4 ;
1554	<	std::string temp5 ;
1659	>	unsigned int arg1 = (unsigned int) 0 ;
1660	>	std::vector<std::string > *result;
1661		PyObject * obj0 = 0 ;
1556	–	PyObject * obj2 = 0 ;
1557	–	PyObject * obj3 = 0 ;
1558	–	PyObject * obj4 = 0 ;
1559	–	PyObject * obj5 = 0 ;
1560	–	PyObject * obj6 = 0 ;
1561	–	PyObject * obj7 = 0 ;
1562	–	PyObject * obj8 = 0 ;
1563	–	PyObject * obj9 = 0 ;
1662
1663	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
1664	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1665	<	if (obj2) {
1666	<	{
1667	<	if (PyString_Check(obj2)) {
1668	<	temp3 = std::string(PyString_AsString(obj2));
1669	<	arg3 = &temp3;
1670	<	}else {
1671	<	SWIG_exception(SWIG_TypeError, "string expected");
1663	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1664	>	if (obj0) {
1665	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1666	>	if (PyErr_Occurred()) SWIG_fail;
1667	>	}
1668	>	{
1669	>	try {
1670	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1671	>
1672	>	}catch (const BossSchedFailure & e) {
1673	>	PyErr_SetString ( SchedulerError, e.what() );
1674	>	return NULL;
1675	>	}catch (const std::exception& e) {
1676	>	PyErr_SetString ( BossError, e.what() );
1677	>	return NULL;
1678	>	}
1679	>	}
1680	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1681	>	return resultobj;
1682	>	fail:
1683	>	return NULL;
1684	>	}
1685	>
1686	>
1687	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1688	>	PyObject *resultobj;
1689	>	unsigned int arg1 ;
1690	>	std::string *arg2 = 0 ;
1691	>	std::vector<std::string > *result;
1692	>	std::string temp2 ;
1693	>	PyObject * obj0 = 0 ;
1694	>	PyObject * obj1 = 0 ;
1695	>
1696	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1697	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1698	>	if (PyErr_Occurred()) SWIG_fail;
1699	>	{
1700	>	if (PyString_Check(obj1)) {
1701	>	temp2 = std::string(PyString_AsString(obj1));
1702	>	arg2 = &temp2;
1703	>	}else {
1704	>	SWIG_exception(SWIG_TypeError, "string expected");
1705	>	}
1706	>	}
1707	>	{
1708	>	try {
1709	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1710	>
1711	>	}catch (const BossSchedFailure & e) {
1712	>	PyErr_SetString ( SchedulerError, e.what() );
1713	>	return NULL;
1714	>	}catch (const std::exception& e) {
1715	>	PyErr_SetString ( BossError, e.what() );
1716	>	return NULL;
1717	>	}
1718	>	}
1719	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1720	>	return resultobj;
1721	>	fail:
1722	>	return NULL;
1723	>	}
1724	>
1725	>
1726	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1727	>	PyObject *resultobj;
1728	>	std::vector<std::string > *arg1 = 0 ;
1729	>	std::vector<std::string > *result;
1730	>	std::vector<std::string > temp1 ;
1731	>	std::vector<std::string > *v1 ;
1732	>	PyObject * obj0 = 0 ;
1733	>
1734	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1735	>	{
1736	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1737	>	unsigned int size = (PyTuple_Check(obj0) ?
1738	>	PyTuple_Size(obj0) :
1739	>	PyList_Size(obj0));
1740	>	temp1 = std::vector<std::string >(size);
1741	>	arg1 = &temp1;
1742	>	for (unsigned int i=0; i<size; i++) {
1743	>	PyObject* o = PySequence_GetItem(obj0,i);
1744	>	if (PyString_Check(o)) {
1745	>	temp1[i] = (std::string)(\
1746	>	SwigString_AsString(o));
1747	>	Py_DECREF(o);
1748	>	}else {
1749	>	Py_DECREF(o);
1750	>	PyErr_SetString(PyExc_TypeError,
1751	>	"vector<""std::string""> expected");
1752	>	SWIG_fail;
1753	>	}
1754		}
1755	+	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1756	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1757	+	arg1 = v1;
1758	+	}else {
1759	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1760	+	SWIG_fail;
1761		}
1762		}
1763	<	if (obj3) {
1763	>	{
1764	>	try {
1765	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1766	>
1767	>	}catch (const BossSchedFailure & e) {
1768	>	PyErr_SetString ( SchedulerError, e.what() );
1769	>	return NULL;
1770	>	}catch (const std::exception& e) {
1771	>	PyErr_SetString ( BossError, e.what() );
1772	>	return NULL;
1773	>	}
1774	>	}
1775	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1776	>	return resultobj;
1777	>	fail:
1778	>	return NULL;
1779	>	}
1780	>
1781	>
1782	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1783	>	int argc;
1784	>	PyObject *argv[3];
1785	>	int ii;
1786	>
1787	>	argc = PyObject_Length(args);
1788	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1789	>	argv[ii] = PyTuple_GetItem(args,ii);
1790	>	}
1791	>	if ((argc >= 0) && (argc <= 1)) {
1792	>	int _v;
1793	>	if (argc <= 0) {
1794	>	return _wrap_new_vector_string__SWIG_0(self,args);
1795	>	}
1796		{
1797	<	if (PyString_Check(obj3)) {
1798	<	temp4 = std::string(PyString_AsString(obj3));
1799	<	arg4 = &temp4;
1800	<	}else {
1583	<	SWIG_exception(SWIG_TypeError, "string expected");
1584	<	}
1797	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1798	>	}
1799	>	if (_v) {
1800	>	return _wrap_new_vector_string__SWIG_0(self,args);
1801		}
1802		}
1803	<	if (obj4) {
1803	>	if (argc == 1) {
1804	>	int _v;
1805		{
1806	<	if (PyString_Check(obj4)) {
1807	<	temp5 = std::string(PyString_AsString(obj4));
1808	<	arg5 = &temp5;
1806	>	/* native sequence? */
1807	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1808	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1809	>	PyTuple_Size(argv[0]) :
1810	>	PyList_Size(argv[0]));
1811	>	if (size == 0) {
1812	>	/* an empty sequence can be of any type */
1813	>	_v = 1;
1814	>	}else {
1815	>	/* check the first element only */
1816	>	PyObject* o = PySequence_GetItem(argv[0],0);
1817	>	if (PyString_Check(o))
1818	>	_v = 1;
1819	>	else
1820	>	_v = 0;
1821	>	Py_DECREF(o);
1822	>	}
1823		}else {
1824	<	SWIG_exception(SWIG_TypeError, "string expected");
1824	>	/* wrapped vector? */
1825	>	std::vector<std::string >* v;
1826	>	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1827	>	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1828	>	_v = 1;
1829	>	else
1830	>	_v = 0;
1831		}
1832		}
1833	+	if (_v) {
1834	+	return _wrap_new_vector_string__SWIG_2(self,args);
1835	+	}
1836		}
1837	<	if (obj5) {
1837	>	if (argc == 2) {
1838	>	int _v;
1839		{
1840	<	if (PyString_Check(obj5))
1841	<	arg6 = std::string(PyString_AsString(obj5));
1842	<	else
1843	<	SWIG_exception(SWIG_TypeError, "string expected");
1840	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1841	>	}
1842	>	if (_v) {
1843	>	{
1844	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1845	>	}
1846	>	if (_v) {
1847	>	return _wrap_new_vector_string__SWIG_1(self,args);
1848	>	}
1849		}
1850		}
1851	<	if (obj6) {
1852	<	{
1853	<	if (PyString_Check(obj6))
1854	<	arg7 = std::string(PyString_AsString(obj6));
1855	<	else
1856	<	SWIG_exception(SWIG_TypeError, "string expected");
1851	>
1852	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1853	>	return NULL;
1854	>	}
1855	>
1856	>
1857	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1858	>	PyObject *resultobj;
1859	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1860	>	unsigned int result;
1861	>	std::vector<std::string > temp1 ;
1862	>	std::vector<std::string > *v1 ;
1863	>	PyObject * obj0 = 0 ;
1864	>
1865	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1866	>	{
1867	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1868	>	unsigned int size = (PyTuple_Check(obj0) ?
1869	>	PyTuple_Size(obj0) :
1870	>	PyList_Size(obj0));
1871	>	temp1 = std::vector<std::string >(size);
1872	>	arg1 = &temp1;
1873	>	for (unsigned int i=0; i<size; i++) {
1874	>	PyObject* o = PySequence_GetItem(obj0,i);
1875	>	if (PyString_Check(o)) {
1876	>	temp1[i] = (std::string)(\
1877	>	SwigString_AsString(o));
1878	>	Py_DECREF(o);
1879	>	}else {
1880	>	Py_DECREF(o);
1881	>	PyErr_SetString(PyExc_TypeError,
1882	>	"vector<""std::string""> expected");
1883	>	SWIG_fail;
1884	>	}
1885	>	}
1886	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1887	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1888	>	arg1 = v1;
1889	>	}else {
1890	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1891	>	SWIG_fail;
1892		}
1893		}
1894	<	if (obj7) {
1895	<	{
1896	<	if (PyString_Check(obj7))
1897	<	arg8 = std::string(PyString_AsString(obj7));
1898	<	else
1899	<	SWIG_exception(SWIG_TypeError, "string expected");
1894	>	{
1895	>	try {
1896	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1897	>
1898	>	}catch (const BossSchedFailure & e) {
1899	>	PyErr_SetString ( SchedulerError, e.what() );
1900	>	return NULL;
1901	>	}catch (const std::exception& e) {
1902	>	PyErr_SetString ( BossError, e.what() );
1903	>	return NULL;
1904		}
1905		}
1906	<	if (obj8) {
1907	<	{
1908	<	if (PyString_Check(obj8))
1909	<	arg9 = std::string(PyString_AsString(obj8));
1910	<	else
1911	<	SWIG_exception(SWIG_TypeError, "string expected");
1906	>	resultobj = PyInt_FromLong((long)result);
1907	>	return resultobj;
1908	>	fail:
1909	>	return NULL;
1910	>	}
1911	>
1912	>
1913	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1914	>	PyObject *resultobj;
1915	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1916	>	bool result;
1917	>	std::vector<std::string > temp1 ;
1918	>	std::vector<std::string > *v1 ;
1919	>	PyObject * obj0 = 0 ;
1920	>
1921	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1922	>	{
1923	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1924	>	unsigned int size = (PyTuple_Check(obj0) ?
1925	>	PyTuple_Size(obj0) :
1926	>	PyList_Size(obj0));
1927	>	temp1 = std::vector<std::string >(size);
1928	>	arg1 = &temp1;
1929	>	for (unsigned int i=0; i<size; i++) {
1930	>	PyObject* o = PySequence_GetItem(obj0,i);
1931	>	if (PyString_Check(o)) {
1932	>	temp1[i] = (std::string)(\
1933	>	SwigString_AsString(o));
1934	>	Py_DECREF(o);
1935	>	}else {
1936	>	Py_DECREF(o);
1937	>	PyErr_SetString(PyExc_TypeError,
1938	>	"vector<""std::string""> expected");
1939	>	SWIG_fail;
1940	>	}
1941	>	}
1942	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1943	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1944	>	arg1 = v1;
1945	>	}else {
1946	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1947	>	SWIG_fail;
1948		}
1949		}
1950	<	if (obj9) {
1951	<	arg10 = PyInt_AsLong(obj9) ? true : false;
1952	<	if (PyErr_Occurred()) SWIG_fail;
1950	>	{
1951	>	try {
1952	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1953	>
1954	>	}catch (const BossSchedFailure & e) {
1955	>	PyErr_SetString ( SchedulerError, e.what() );
1956	>	return NULL;
1957	>	}catch (const std::exception& e) {
1958	>	PyErr_SetString ( BossError, e.what() );
1959	>	return NULL;
1960	>	}
1961	>	}
1962	>	resultobj = PyInt_FromLong((long)result);
1963	>	return resultobj;
1964	>	fail:
1965	>	return NULL;
1966	>	}
1967	>
1968	>
1969	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1970	>	PyObject *resultobj;
1971	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1972	>	PyObject * obj0 = 0 ;
1973	>
1974	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1975	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1976	>	{
1977	>	try {
1978	>	(arg1)->clear();
1979	>
1980	>	}catch (const BossSchedFailure & e) {
1981	>	PyErr_SetString ( SchedulerError, e.what() );
1982	>	return NULL;
1983	>	}catch (const std::exception& e) {
1984	>	PyErr_SetString ( BossError, e.what() );
1985	>	return NULL;
1986	>	}
1987	>	}
1988	>	Py_INCREF(Py_None); resultobj = Py_None;
1989	>	return resultobj;
1990	>	fail:
1991	>	return NULL;
1992	>	}
1993	>
1994	>
1995	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1996	>	PyObject *resultobj;
1997	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1998	>	std::string arg2 ;
1999	>	PyObject * obj0 = 0 ;
2000	>	PyObject * obj1 = 0 ;
2001	>
2002	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
2003	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2004	>	{
2005	>	if (PyString_Check(obj1))
2006	>	arg2 = std::string(PyString_AsString(obj1));
2007	>	else
2008	>	SWIG_exception(SWIG_TypeError, "string expected");
2009		}
2010		{
2011		try {
2012	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2012	>	(arg1)->push_back(arg2);
2013
2014	+	}catch (const BossSchedFailure & e) {
2015	+	PyErr_SetString ( SchedulerError, e.what() );
2016	+	return NULL;
2017		}catch (const std::exception& e) {
2018	<	SWIG_exception(SWIG_RuntimeError, e.what());
2018	>	PyErr_SetString ( BossError, e.what() );
2019	>	return NULL;
2020		}
2021		}
2022	<	resultobj = result;
2022	>	Py_INCREF(Py_None); resultobj = Py_None;
2023	>	return resultobj;
2024	>	fail:
2025	>	return NULL;
2026	>	}
2027	>
2028	>
2029	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
2030	>	PyObject *resultobj;
2031	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2032	>	std::string result;
2033	>	PyObject * obj0 = 0 ;
2034	>
2035	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
2036	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2037	>	{
2038	>	try {
2039	>	result = std_vectorlstd_string_g_pop___(arg1);
2040	>
2041	>	}catch (std::out_of_range& e) {
2042	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2043	>	}
2044	>	}
2045	>	{
2046	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2047	>	}
2048	>	return resultobj;
2049	>	fail:
2050	>	return NULL;
2051	>	}
2052	>
2053	>
2054	>	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
2055	>	PyObject *resultobj;
2056	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2057	>	int arg2 ;
2058	>	std::string result;
2059	>	PyObject * obj0 = 0 ;
2060	>
2061	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2062	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2063	>	{
2064	>	try {
2065	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2066	>
2067	>	}catch (std::out_of_range& e) {
2068	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2069	>	}
2070	>	}
2071	>	{
2072	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2073	>	}
2074	>	return resultobj;
2075	>	fail:
2076	>	return NULL;
2077	>	}
2078	>
2079	>
2080	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2081	>	PyObject *resultobj;
2082	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2083	>	int arg2 ;
2084	>	int arg3 ;
2085	>	std::vector<std::string > result;
2086	>	PyObject * obj0 = 0 ;
2087	>
2088	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2089	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2090	>	{
2091	>	try {
2092	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2093	>
2094	>	}catch (const BossSchedFailure & e) {
2095	>	PyErr_SetString ( SchedulerError, e.what() );
2096	>	return NULL;
2097	>	}catch (const std::exception& e) {
2098	>	PyErr_SetString ( BossError, e.what() );
2099	>	return NULL;
2100	>	}
2101	>	}
2102	>	{
2103	>	resultobj = PyTuple_New((&result)->size());
2104	>	for (unsigned int i=0; i<(&result)->size(); i++)
2105	>	PyTuple_SetItem(resultobj,i,
2106	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2107	>	}
2108	>	return resultobj;
2109	>	fail:
2110	>	return NULL;
2111	>	}
2112	>
2113	>
2114	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2115	>	PyObject *resultobj;
2116	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2117	>	int arg2 ;
2118	>	std::string arg3 ;
2119	>	PyObject * obj0 = 0 ;
2120	>	PyObject * obj2 = 0 ;
2121	>
2122	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2123	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2124	>	{
2125	>	if (PyString_Check(obj2))
2126	>	arg3 = std::string(PyString_AsString(obj2));
2127	>	else
2128	>	SWIG_exception(SWIG_TypeError, "string expected");
2129	>	}
2130	>	{
2131	>	try {
2132	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2133	>
2134	>	}catch (std::out_of_range& e) {
2135	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2136	>	}
2137	>	}
2138	>	Py_INCREF(Py_None); resultobj = Py_None;
2139	>	return resultobj;
2140	>	fail:
2141	>	return NULL;
2142	>	}
2143	>
2144	>
2145	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2146	>	PyObject *resultobj;
2147	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2148	>	int arg2 ;
2149	>	int arg3 ;
2150	>	std::vector<std::string > *arg4 = 0 ;
2151	>	std::vector<std::string > temp4 ;
2152	>	std::vector<std::string > *v4 ;
2153	>	PyObject * obj0 = 0 ;
2154	>	PyObject * obj3 = 0 ;
2155	>
2156	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2157	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2158	>	{
2159	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2160	>	unsigned int size = (PyTuple_Check(obj3) ?
2161	>	PyTuple_Size(obj3) :
2162	>	PyList_Size(obj3));
2163	>	temp4 = std::vector<std::string >(size);
2164	>	arg4 = &temp4;
2165	>	for (unsigned int i=0; i<size; i++) {
2166	>	PyObject* o = PySequence_GetItem(obj3,i);
2167	>	if (PyString_Check(o)) {
2168	>	temp4[i] = (std::string)(\
2169	>	SwigString_AsString(o));
2170	>	Py_DECREF(o);
2171	>	}else {
2172	>	Py_DECREF(o);
2173	>	PyErr_SetString(PyExc_TypeError,
2174	>	"vector<""std::string""> expected");
2175	>	SWIG_fail;
2176	>	}
2177	>	}
2178	>	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2179	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2180	>	arg4 = v4;
2181	>	}else {
2182	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2183	>	SWIG_fail;
2184	>	}
2185	>	}
2186	>	{
2187	>	try {
2188	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2189	>
2190	>	}catch (const BossSchedFailure & e) {
2191	>	PyErr_SetString ( SchedulerError, e.what() );
2192	>	return NULL;
2193	>	}catch (const std::exception& e) {
2194	>	PyErr_SetString ( BossError, e.what() );
2195	>	return NULL;
2196	>	}
2197	>	}
2198	>	Py_INCREF(Py_None); resultobj = Py_None;
2199	>	return resultobj;
2200	>	fail:
2201	>	return NULL;
2202	>	}
2203	>
2204	>
2205	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2206	>	PyObject *resultobj;
2207	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2208	>	int arg2 ;
2209	>	PyObject * obj0 = 0 ;
2210	>
2211	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2212	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2213	>	{
2214	>	try {
2215	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2216	>
2217	>	}catch (std::out_of_range& e) {
2218	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2219	>	}
2220	>	}
2221	>	Py_INCREF(Py_None); resultobj = Py_None;
2222		return resultobj;
2223		fail:
2224		return NULL;
2225		}
2226
2227
2228	+	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2229	+	PyObject *resultobj;
2230	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2231	+	int arg2 ;
2232	+	int arg3 ;
2233	+	PyObject * obj0 = 0 ;
2234	+
2235	+	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2236	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2237	+	{
2238	+	try {
2239	+	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2240	+
2241	+	}catch (const BossSchedFailure & e) {
2242	+	PyErr_SetString ( SchedulerError, e.what() );
2243	+	return NULL;
2244	+	}catch (const std::exception& e) {
2245	+	PyErr_SetString ( BossError, e.what() );
2246	+	return NULL;
2247	+	}
2248	+	}
2249	+	Py_INCREF(Py_None); resultobj = Py_None;
2250	+	return resultobj;
2251	+	fail:
2252	+	return NULL;
2253	+	}
2254	+
2255	+
2256	+	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2257	+	PyObject *resultobj;
2258	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2259	+	PyObject * obj0 = 0 ;
2260	+
2261	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2262	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2263	+	{
2264	+	try {
2265	+	delete arg1;
2266	+
2267	+	}catch (const BossSchedFailure & e) {
2268	+	PyErr_SetString ( SchedulerError, e.what() );
2269	+	return NULL;
2270	+	}catch (const std::exception& e) {
2271	+	PyErr_SetString ( BossError, e.what() );
2272	+	return NULL;
2273	+	}
2274	+	}
2275	+	Py_INCREF(Py_None); resultobj = Py_None;
2276	+	return resultobj;
2277	+	fail:
2278	+	return NULL;
2279	+	}
2280	+
2281	+
2282	+	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2283	+	PyObject *obj;
2284	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2285	+	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2286	+	Py_INCREF(obj);
2287	+	return Py_BuildValue((char *)"");
2288	+	}
2289		static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2290		PyObject *resultobj;
2291		std::string arg1 = (std::string) "" ;
2292	+	std::string arg2 = (std::string) "2" ;
2293	+	std::string arg3 = (std::string) "" ;
2294	+	std::string arg4 = (std::string) "" ;
2295		BossSession *result;
2296		PyObject * obj0 = 0 ;
2297	+	PyObject * obj1 = 0 ;
2298	+	PyObject * obj2 = 0 ;
2299	+	PyObject * obj3 = 0 ;
2300
2301	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2301	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2302		if (obj0) {
2303		{
2304		if (PyString_Check(obj0))
#	Line 1660 | Line 2307 | static PyObject *_wrap_new_BossSession(P
2307		SWIG_exception(SWIG_TypeError, "string expected");
2308		}
2309		}
2310	+	if (obj1) {
2311	+	{
2312	+	if (PyString_Check(obj1))
2313	+	arg2 = std::string(PyString_AsString(obj1));
2314	+	else
2315	+	SWIG_exception(SWIG_TypeError, "string expected");
2316	+	}
2317	+	}
2318	+	if (obj2) {
2319	+	{
2320	+	if (PyString_Check(obj2))
2321	+	arg3 = std::string(PyString_AsString(obj2));
2322	+	else
2323	+	SWIG_exception(SWIG_TypeError, "string expected");
2324	+	}
2325	+	}
2326	+	if (obj3) {
2327	+	{
2328	+	if (PyString_Check(obj3))
2329	+	arg4 = std::string(PyString_AsString(obj3));
2330	+	else
2331	+	SWIG_exception(SWIG_TypeError, "string expected");
2332	+	}
2333	+	}
2334		{
2335		try {
2336	<	result = (BossSession *)new BossSession(arg1);
2336	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2337
2338	+	}catch (const BossSchedFailure & e) {
2339	+	PyErr_SetString ( SchedulerError, e.what() );
2340	+	return NULL;
2341		}catch (const std::exception& e) {
2342	<	SWIG_exception(SWIG_RuntimeError, e.what());
2342	>	PyErr_SetString ( BossError, e.what() );
2343	>	return NULL;
2344		}
2345		}
2346		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
#	Line 1686 | Line 2361 | static PyObject *_wrap_delete_BossSessio
2361		try {
2362		delete arg1;
2363
2364	+	}catch (const BossSchedFailure & e) {
2365	+	PyErr_SetString ( SchedulerError, e.what() );
2366	+	return NULL;
2367	+	}catch (const std::exception& e) {
2368	+	PyErr_SetString ( BossError, e.what() );
2369	+	return NULL;
2370	+	}
2371	+	}
2372	+	Py_INCREF(Py_None); resultobj = Py_None;
2373	+	return resultobj;
2374	+	fail:
2375	+	return NULL;
2376	+	}
2377	+
2378	+
2379	+	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2380	+	PyObject *resultobj;
2381	+	BossSession *arg1 = (BossSession *) 0 ;
2382	+	PyObject * obj0 = 0 ;
2383	+
2384	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2385	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2386	+	{
2387	+	try {
2388	+	(arg1)->resetDB();
2389	+
2390	+	}catch (const BossSchedFailure & e) {
2391	+	PyErr_SetString ( SchedulerError, e.what() );
2392	+	return NULL;
2393	+	}catch (const std::exception& e) {
2394	+	PyErr_SetString ( BossError, e.what() );
2395	+	return NULL;
2396	+	}
2397	+	}
2398	+	Py_INCREF(Py_None); resultobj = Py_None;
2399	+	return resultobj;
2400	+	fail:
2401	+	return NULL;
2402	+	}
2403	+
2404	+
2405	+	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2406	+	PyObject *resultobj;
2407	+	BossSession *arg1 = (BossSession *) 0 ;
2408	+	PyObject * obj0 = 0 ;
2409	+
2410	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2411	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2412	+	{
2413	+	try {
2414	+	(arg1)->clear();
2415	+
2416	+	}catch (const BossSchedFailure & e) {
2417	+	PyErr_SetString ( SchedulerError, e.what() );
2418	+	return NULL;
2419		}catch (const std::exception& e) {
2420	<	SWIG_exception(SWIG_RuntimeError, e.what());
2420	>	PyErr_SetString ( BossError, e.what() );
2421	>	return NULL;
2422		}
2423		}
2424		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1723 | Line 2454 | static PyObject *_wrap_BossSession_makeB
2454		try {
2455		result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2456
2457	+	}catch (const BossSchedFailure & e) {
2458	+	PyErr_SetString ( SchedulerError, e.what() );
2459	+	return NULL;
2460		}catch (const std::exception& e) {
2461	<	SWIG_exception(SWIG_RuntimeError, e.what());
2461	>	PyErr_SetString ( BossError, e.what() );
2462	>	return NULL;
2463		}
2464		}
2465		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
#	Line 1748 | Line 2483 | static PyObject *_wrap_BossSession_destr
2483		try {
2484		(arg1)->destroyBossTask(arg2);
2485
2486	+	}catch (const BossSchedFailure & e) {
2487	+	PyErr_SetString ( SchedulerError, e.what() );
2488	+	return NULL;
2489		}catch (const std::exception& e) {
2490	<	SWIG_exception(SWIG_RuntimeError, e.what());
2490	>	PyErr_SetString ( BossError, e.what() );
2491	>	return NULL;
2492		}
2493		}
2494		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1759 | Line 2498 | static PyObject *_wrap_BossSession_destr
2498		}
2499
2500
2501	<	static PyObject *_wrap_BossSession_BossShowCHTools(PyObject *self, PyObject *args) {
2501	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2502		PyObject *resultobj;
2503		BossSession *arg1 = (BossSession *) 0 ;
2504		std::vector<std::string > result;
2505		PyObject * obj0 = 0 ;
2506
2507	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowCHTools",&obj0)) goto fail;
2507	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2508		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2509		{
2510		try {
2511	<	result = (arg1)->BossShowCHTools();
2511	>	result = (arg1)->showCHTools();
2512
2513	+	}catch (const BossSchedFailure & e) {
2514	+	PyErr_SetString ( SchedulerError, e.what() );
2515	+	return NULL;
2516		}catch (const std::exception& e) {
2517	<	SWIG_exception(SWIG_RuntimeError, e.what());
2517	>	PyErr_SetString ( BossError, e.what() );
2518	>	return NULL;
2519		}
2520		}
2521		{
2522	<	std::vector<std::string > * resultptr;
2523	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2524	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2522	>	resultobj = PyTuple_New((&result)->size());
2523	>	for (unsigned int i=0; i<(&result)->size(); i++)
2524	>	PyTuple_SetItem(resultobj,i,
2525	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2526		}
2527		return resultobj;
2528		fail:
#	Line 1786 | Line 2530 | static PyObject *_wrap_BossSession_BossS
2530		}
2531
2532
2533	<	static PyObject *_wrap_BossSession_BossShowProgramTypes(PyObject *self, PyObject *args) {
2533	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2534		PyObject *resultobj;
2535		BossSession *arg1 = (BossSession *) 0 ;
2536		std::vector<std::string > result;
2537		PyObject * obj0 = 0 ;
2538
2539	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowProgramTypes",&obj0)) goto fail;
2539	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2540		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2541		{
2542		try {
2543	<	result = (arg1)->BossShowProgramTypes();
2543	>	result = (arg1)->showProgramTypes();
2544
2545	+	}catch (const BossSchedFailure & e) {
2546	+	PyErr_SetString ( SchedulerError, e.what() );
2547	+	return NULL;
2548		}catch (const std::exception& e) {
2549	<	SWIG_exception(SWIG_RuntimeError, e.what());
2549	>	PyErr_SetString ( BossError, e.what() );
2550	>	return NULL;
2551		}
2552		}
2553		{
2554	<	std::vector<std::string > * resultptr;
2555	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2556	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2554	>	resultobj = PyTuple_New((&result)->size());
2555	>	for (unsigned int i=0; i<(&result)->size(); i++)
2556	>	PyTuple_SetItem(resultobj,i,
2557	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2558		}
2559		return resultobj;
2560		fail:
#	Line 1813 | Line 2562 | static PyObject *_wrap_BossSession_BossS
2562		}
2563
2564
2565	<	static PyObject *_wrap_BossSession_BossShowRTMon(PyObject *self, PyObject *args) {
2565	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2566		PyObject *resultobj;
2567		BossSession *arg1 = (BossSession *) 0 ;
2568		std::vector<std::string > result;
2569		PyObject * obj0 = 0 ;
2570
2571	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowRTMon",&obj0)) goto fail;
2571	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2572		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2573		{
2574		try {
2575	<	result = (arg1)->BossShowRTMon();
2575	>	result = (arg1)->showRTMon();
2576
2577	+	}catch (const BossSchedFailure & e) {
2578	+	PyErr_SetString ( SchedulerError, e.what() );
2579	+	return NULL;
2580		}catch (const std::exception& e) {
2581	<	SWIG_exception(SWIG_RuntimeError, e.what());
2581	>	PyErr_SetString ( BossError, e.what() );
2582	>	return NULL;
2583		}
2584		}
2585		{
2586	<	std::vector<std::string > * resultptr;
2587	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2588	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2586	>	resultobj = PyTuple_New((&result)->size());
2587	>	for (unsigned int i=0; i<(&result)->size(); i++)
2588	>	PyTuple_SetItem(resultobj,i,
2589	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2590		}
2591		return resultobj;
2592		fail:
#	Line 1840 | Line 2594 | static PyObject *_wrap_BossSession_BossS
2594		}
2595
2596
2597	<	static PyObject *_wrap_BossSession_BossShowSchedulers(PyObject *self, PyObject *args) {
2597	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2598		PyObject *resultobj;
2599		BossSession *arg1 = (BossSession *) 0 ;
2600		std::vector<std::string > result;
2601		PyObject * obj0 = 0 ;
2602
2603	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowSchedulers",&obj0)) goto fail;
2603	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2604		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2605		{
2606		try {
2607	<	result = (arg1)->BossShowSchedulers();
2607	>	result = (arg1)->showSchedulers();
2608
2609	+	}catch (const BossSchedFailure & e) {
2610	+	PyErr_SetString ( SchedulerError, e.what() );
2611	+	return NULL;
2612		}catch (const std::exception& e) {
2613	<	SWIG_exception(SWIG_RuntimeError, e.what());
2613	>	PyErr_SetString ( BossError, e.what() );
2614	>	return NULL;
2615		}
2616		}
2617		{
2618	<	std::vector<std::string > * resultptr;
2619	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2620	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2618	>	resultobj = PyTuple_New((&result)->size());
2619	>	for (unsigned int i=0; i<(&result)->size(); i++)
2620	>	PyTuple_SetItem(resultobj,i,
2621	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2622		}
2623		return resultobj;
2624		fail:
#	Line 1867 | Line 2626 | static PyObject *_wrap_BossSession_BossS
2626		}
2627
2628
2629	<	static PyObject *_wrap_BossSession_BossDefaultCHTool(PyObject *self, PyObject *args) {
2629	>	static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
2630		PyObject *resultobj;
2631		BossSession *arg1 = (BossSession *) 0 ;
2632		std::string result;
2633		PyObject * obj0 = 0 ;
2634
2635	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultCHTool",&obj0)) goto fail;
2635	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) goto fail;
2636		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2637		{
2638		try {
2639	<	result = (arg1)->BossDefaultCHTool();
2639	>	result = (arg1)->defaultCHTool();
2640
2641	+	}catch (const BossSchedFailure & e) {
2642	+	PyErr_SetString ( SchedulerError, e.what() );
2643	+	return NULL;
2644		}catch (const std::exception& e) {
2645	<	SWIG_exception(SWIG_RuntimeError, e.what());
2645	>	PyErr_SetString ( BossError, e.what() );
2646	>	return NULL;
2647		}
2648		}
2649		{
#	Line 1892 | Line 2655 | static PyObject *_wrap_BossSession_BossD
2655		}
2656
2657
2658	<	static PyObject *_wrap_BossSession_BossDefaultProgramType(PyObject *self, PyObject *args) {
2658	>	static PyObject *_wrap_BossSession_defaultProgramType(PyObject *self, PyObject *args) {
2659		PyObject *resultobj;
2660		BossSession *arg1 = (BossSession *) 0 ;
2661		std::string result;
2662		PyObject * obj0 = 0 ;
2663
2664	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultProgramType",&obj0)) goto fail;
2664	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) goto fail;
2665		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2666		{
2667		try {
2668	<	result = (arg1)->BossDefaultProgramType();
2668	>	result = (arg1)->defaultProgramType();
2669
2670	+	}catch (const BossSchedFailure & e) {
2671	+	PyErr_SetString ( SchedulerError, e.what() );
2672	+	return NULL;
2673		}catch (const std::exception& e) {
2674	<	SWIG_exception(SWIG_RuntimeError, e.what());
2674	>	PyErr_SetString ( BossError, e.what() );
2675	>	return NULL;
2676		}
2677		}
2678		{
#	Line 1917 | Line 2684 | static PyObject *_wrap_BossSession_BossD
2684		}
2685
2686
2687	<	static PyObject *_wrap_BossSession_BossDefaultRTMon(PyObject *self, PyObject *args) {
2687	>	static PyObject *_wrap_BossSession_defaultRTMon(PyObject *self, PyObject *args) {
2688		PyObject *resultobj;
2689		BossSession *arg1 = (BossSession *) 0 ;
2690		std::string result;
2691		PyObject * obj0 = 0 ;
2692
2693	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultRTMon",&obj0)) goto fail;
2693	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) goto fail;
2694		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2695		{
2696		try {
2697	<	result = (arg1)->BossDefaultRTMon();
2697	>	result = (arg1)->defaultRTMon();
2698
2699	+	}catch (const BossSchedFailure & e) {
2700	+	PyErr_SetString ( SchedulerError, e.what() );
2701	+	return NULL;
2702		}catch (const std::exception& e) {
2703	<	SWIG_exception(SWIG_RuntimeError, e.what());
2703	>	PyErr_SetString ( BossError, e.what() );
2704	>	return NULL;
2705		}
2706		}
2707		{
#	Line 1942 | Line 2713 | static PyObject *_wrap_BossSession_BossD
2713		}
2714
2715
2716	<	static PyObject *_wrap_BossSession_BossDefaultScheduler(PyObject *self, PyObject *args) {
2716	>	static PyObject *_wrap_BossSession_defaultScheduler(PyObject *self, PyObject *args) {
2717		PyObject *resultobj;
2718		BossSession *arg1 = (BossSession *) 0 ;
2719		std::string result;
2720		PyObject * obj0 = 0 ;
2721
2722	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultScheduler",&obj0)) goto fail;
2722	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) goto fail;
2723		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2724		{
2725		try {
2726	<	result = (arg1)->BossDefaultScheduler();
2726	>	result = (arg1)->defaultScheduler();
2727
2728	+	}catch (const BossSchedFailure & e) {
2729	+	PyErr_SetString ( SchedulerError, e.what() );
2730	+	return NULL;
2731		}catch (const std::exception& e) {
2732	<	SWIG_exception(SWIG_RuntimeError, e.what());
2732	>	PyErr_SetString ( BossError, e.what() );
2733	>	return NULL;
2734		}
2735		}
2736		{
#	Line 1967 | Line 2742 | static PyObject *_wrap_BossSession_BossD
2742		}
2743
2744
2745	<	static PyObject *_wrap_BossSession_BossVersion(PyObject *self, PyObject *args) {
2745	>	static PyObject *_wrap_BossSession_version(PyObject *self, PyObject *args) {
2746		PyObject *resultobj;
2747		BossSession *arg1 = (BossSession *) 0 ;
2748		std::string result;
2749		PyObject * obj0 = 0 ;
2750
2751	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossVersion",&obj0)) goto fail;
2751	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) goto fail;
2752		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2753		{
2754		try {
2755	<	result = (arg1)->BossVersion();
2755	>	result = (arg1)->version();
2756
2757	+	}catch (const BossSchedFailure & e) {
2758	+	PyErr_SetString ( SchedulerError, e.what() );
2759	+	return NULL;
2760		}catch (const std::exception& e) {
2761	<	SWIG_exception(SWIG_RuntimeError, e.what());
2761	>	PyErr_SetString ( BossError, e.what() );
2762	>	return NULL;
2763		}
2764		}
2765		{
#	Line 1992 | Line 2771 | static PyObject *_wrap_BossSession_BossV
2771		}
2772
2773
2774	<	static PyObject *_wrap_BossSession_BossClientID(PyObject *self, PyObject *args) {
2774	>	static PyObject *_wrap_BossSession_clientID(PyObject *self, PyObject *args) {
2775		PyObject *resultobj;
2776		BossSession *arg1 = (BossSession *) 0 ;
2777		std::string result;
2778		PyObject * obj0 = 0 ;
2779
2780	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossClientID",&obj0)) goto fail;
2780	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) goto fail;
2781		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2782		{
2783		try {
2784	<	result = (arg1)->BossClientID();
2784	>	result = (arg1)->clientID();
2785
2786	+	}catch (const BossSchedFailure & e) {
2787	+	PyErr_SetString ( SchedulerError, e.what() );
2788	+	return NULL;
2789		}catch (const std::exception& e) {
2790	<	SWIG_exception(SWIG_RuntimeError, e.what());
2790	>	PyErr_SetString ( BossError, e.what() );
2791	>	return NULL;
2792		}
2793		}
2794		{
#	Line 2035 | Line 2818 | static PyObject *_wrap_BossSession_showC
2818		try {
2819		result = (int)(arg1)->showConfigs(arg2);
2820
2821	+	}catch (const BossSchedFailure & e) {
2822	+	PyErr_SetString ( SchedulerError, e.what() );
2823	+	return NULL;
2824		}catch (const std::exception& e) {
2825	<	SWIG_exception(SWIG_RuntimeError, e.what());
2826	<	}
2041	<	}
2042	<	resultobj = PyInt_FromLong((long)result);
2043	<	return resultobj;
2044	<	fail:
2045	<	return NULL;
2046	<	}
2047	<
2048	<
2049	<	static PyObject *_wrap_BossSession_purgeTasks(PyObject *self, PyObject *args) {
2050	<	PyObject *resultobj;
2051	<	BossSession *arg1 = (BossSession *) 0 ;
2052	<	std::string *arg2 = 0 ;
2053	<	std::string *arg3 = 0 ;
2054	<	std::string *arg4 = 0 ;
2055	<	std::string const &arg5_defvalue = "0" ;
2056	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2057	<	int result;
2058	<	std::string temp2 ;
2059	<	std::string temp3 ;
2060	<	std::string temp4 ;
2061	<	std::string temp5 ;
2062	<	PyObject * obj0 = 0 ;
2063	<	PyObject * obj1 = 0 ;
2064	<	PyObject * obj2 = 0 ;
2065	<	PyObject * obj3 = 0 ;
2066	<	PyObject * obj4 = 0 ;
2067	<
2068	<	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossSession_purgeTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
2069	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2070	<	{
2071	<	if (PyString_Check(obj1)) {
2072	<	temp2 = std::string(PyString_AsString(obj1));
2073	<	arg2 = &temp2;
2074	<	}else {
2075	<	SWIG_exception(SWIG_TypeError, "string expected");
2076	<	}
2077	<	}
2078	<	{
2079	<	if (PyString_Check(obj2)) {
2080	<	temp3 = std::string(PyString_AsString(obj2));
2081	<	arg3 = &temp3;
2082	<	}else {
2083	<	SWIG_exception(SWIG_TypeError, "string expected");
2084	<	}
2085	<	}
2086	<	{
2087	<	if (PyString_Check(obj3)) {
2088	<	temp4 = std::string(PyString_AsString(obj3));
2089	<	arg4 = &temp4;
2090	<	}else {
2091	<	SWIG_exception(SWIG_TypeError, "string expected");
2092	<	}
2093	<	}
2094	<	if (obj4) {
2095	<	{
2096	<	if (PyString_Check(obj4)) {
2097	<	temp5 = std::string(PyString_AsString(obj4));
2098	<	arg5 = &temp5;
2099	<	}else {
2100	<	SWIG_exception(SWIG_TypeError, "string expected");
2101	<	}
2102	<	}
2103	<	}
2104	<	{
2105	<	try {
2106	<	result = (int)(arg1)->purgeTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
2107	<
2108	<	}catch (const std::exception& e) {
2109	<	SWIG_exception(SWIG_RuntimeError, e.what());
2825	>	PyErr_SetString ( BossError, e.what() );
2826	>	return NULL;
2827		}
2828		}
2829		resultobj = PyInt_FromLong((long)result);
#	Line 2116 | Line 2833 | static PyObject *_wrap_BossSession_purge
2833		}
2834
2835
2836	<	static PyObject *_wrap_BossSession_BossRTupdate(PyObject *self, PyObject *args) {
2836	>	static PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2837		PyObject *resultobj;
2838		BossSession *arg1 = (BossSession *) 0 ;
2839		std::string arg2 = (std::string) "all" ;
#	Line 2128 | Line 2845 | static PyObject *_wrap_BossSession_BossR
2845		PyObject * obj2 = 0 ;
2846		PyObject * obj3 = 0 ;
2847
2848	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_BossRTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
2848	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
2849		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2850		if (obj1) {
2851		{
#	Line 2156 | Line 2873 | static PyObject *_wrap_BossSession_BossR
2873		}
2874		{
2875		try {
2876	<	result = (int)(arg1)->BossRTupdate(arg2,arg3,arg4);
2876	>	result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2877
2878	+	}catch (const BossSchedFailure & e) {
2879	+	PyErr_SetString ( SchedulerError, e.what() );
2880	+	return NULL;
2881		}catch (const std::exception& e) {
2882	<	SWIG_exception(SWIG_RuntimeError, e.what());
2882	>	PyErr_SetString ( BossError, e.what() );
2883	>	return NULL;
2884		}
2885		}
2886		resultobj = PyInt_FromLong((long)result);
#	Line 2169 | Line 2890 | static PyObject *_wrap_BossSession_BossR
2890		}
2891
2892
2893	<	static PyObject *_wrap_BossSession_BossListMatch(PyObject *self, PyObject *args) {
2893	>	static PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
2894		PyObject *resultobj;
2895		BossSession *arg1 = (BossSession *) 0 ;
2896		std::string *arg2 = 0 ;
2897		std::string *arg3 = 0 ;
2898	<	std::ostream &arg4_defvalue = std::cout ;
2899	<	std::ostream *arg4 = (std::ostream *) &arg4_defvalue ;
2900	<	bool arg5 = (bool) false ;
2898	>	bool arg4 = (bool) false ;
2899	>	std::string const &arg5_defvalue = "" ;
2900	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2901		std::string const &arg6_defvalue = "" ;
2902		std::string *arg6 = (std::string *) &arg6_defvalue ;
2903	<	std::string const &arg7_defvalue = "" ;
2904	<	std::string *arg7 = (std::string *) &arg7_defvalue ;
2184	<	int result;
2903	>	unsigned int arg7 = (unsigned int) 0 ;
2904	>	std::vector<std::string > result;
2905		std::string temp2 ;
2906		std::string temp3 ;
2907	+	std::string temp5 ;
2908		std::string temp6 ;
2188	–	std::string temp7 ;
2909		PyObject * obj0 = 0 ;
2910		PyObject * obj1 = 0 ;
2911		PyObject * obj2 = 0 ;
#	Line 2194 | Line 2914 | static PyObject *_wrap_BossSession_BossL
2914		PyObject * obj5 = 0 ;
2915		PyObject * obj6 = 0 ;
2916
2917	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_BossListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2917	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2918		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2919		{
2920		if (PyString_Check(obj1)) {
#	Line 2213 | Line 2933 | static PyObject *_wrap_BossSession_BossL
2933		}
2934		}
2935		if (obj3) {
2936	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2937	<	if (arg4 == NULL) {
2218	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2219	<	}
2936	>	arg4 = PyInt_AsLong(obj3) ? true : false;
2937	>	if (PyErr_Occurred()) SWIG_fail;
2938		}
2939		if (obj4) {
2940	<	arg5 = PyInt_AsLong(obj4) ? true : false;
2941	<	if (PyErr_Occurred()) SWIG_fail;
2940	>	{
2941	>	if (PyString_Check(obj4)) {
2942	>	temp5 = std::string(PyString_AsString(obj4));
2943	>	arg5 = &temp5;
2944	>	}else {
2945	>	SWIG_exception(SWIG_TypeError, "string expected");
2946	>	}
2947	>	}
2948		}
2949		if (obj5) {
2950		{
#	Line 2233 | Line 2957 | static PyObject *_wrap_BossSession_BossL
2957		}
2958		}
2959		if (obj6) {
2960	<	{
2961	<	if (PyString_Check(obj6)) {
2238	<	temp7 = std::string(PyString_AsString(obj6));
2239	<	arg7 = &temp7;
2240	<	}else {
2241	<	SWIG_exception(SWIG_TypeError, "string expected");
2242	<	}
2243	<	}
2960	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
2961	>	if (PyErr_Occurred()) SWIG_fail;
2962		}
2963		{
2964		try {
2965	<	result = (int)(arg1)->BossListMatch((std::string const &)*arg2,(std::string const &)*arg3,*arg4,arg5,(std::string const &)*arg6,(std::string const &)*arg7);
2965	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
2966
2967	+	}catch (const BossSchedFailure & e) {
2968	+	PyErr_SetString ( SchedulerError, e.what() );
2969	+	return NULL;
2970		}catch (const std::exception& e) {
2971	<	SWIG_exception(SWIG_RuntimeError, e.what());
2971	>	PyErr_SetString ( BossError, e.what() );
2972	>	return NULL;
2973		}
2974		}
2975	<	resultobj = PyInt_FromLong((long)result);
2975	>	{
2976	>	resultobj = PyTuple_New((&result)->size());
2977	>	for (unsigned int i=0; i<(&result)->size(); i++)
2978	>	PyTuple_SetItem(resultobj,i,
2979	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2980	>	}
2981		return resultobj;
2982		fail:
2983		return NULL;
2984		}
2985
2986
2987	<	static PyObject *_wrap_BossSession_jobQuery(PyObject *self, PyObject *args) {
2987	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
2988		PyObject *resultobj;
2989		BossSession *arg1 = (BossSession *) 0 ;
2990		int arg2 = (int) SCHEDULED ;
#	Line 2271 | Line 2998 | static PyObject *_wrap_BossSession_jobQu
2998		std::string arg7 = (std::string) "" ;
2999		std::string arg8 = (std::string) "" ;
3000		std::string arg9 = (std::string) "" ;
3001	<	bool arg10 = (bool) false ;
2275	<	SwigValueWrapper< std::vector<BossJob * > > result;
3001	>	unsigned int arg10 = (unsigned int) 0 ;
3002		std::string temp3 ;
3003		std::string temp4 ;
3004		std::string temp5 ;
#	Line 2286 | Line 3012 | static PyObject *_wrap_BossSession_jobQu
3012		PyObject * obj8 = 0 ;
3013		PyObject * obj9 = 0 ;
3014
3015	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_jobQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3015	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3016		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3017		if (obj2) {
3018		{
#	Line 2351 | Line 3077 | static PyObject *_wrap_BossSession_jobQu
3077		}
3078		}
3079		if (obj9) {
3080	<	arg10 = PyInt_AsLong(obj9) ? true : false;
3080	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3081		if (PyErr_Occurred()) SWIG_fail;
3082		}
3083		{
3084		try {
3085	<	result = (arg1)->jobQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3085	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3086
3087	+	}catch (const BossSchedFailure & e) {
3088	+	PyErr_SetString ( SchedulerError, e.what() );
3089	+	return NULL;
3090		}catch (const std::exception& e) {
3091	<	SWIG_exception(SWIG_RuntimeError, e.what());
3091	>	PyErr_SetString ( BossError, e.what() );
3092	>	return NULL;
3093		}
3094		}
3095	<	{
2366	<	std::vector<BossJob * > * resultptr;
2367	<	resultptr = new std::vector<BossJob * >((std::vector<BossJob * > &) result);
2368	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossJob_p_t, 1);
2369	<	}
3095	>	Py_INCREF(Py_None); resultobj = Py_None;
3096		return resultobj;
3097		fail:
3098		return NULL;
3099		}
3100
3101
3102	<	static PyObject *_wrap_BossSession_queryPrint(PyObject *self, PyObject *args) {
3102	>	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3103		PyObject *resultobj;
3104		BossSession *arg1 = (BossSession *) 0 ;
3105	<	SwigValueWrapper< std::vector<BossJob * > > arg2 ;
3106	<	std::ostream &arg3_defvalue = std::cout ;
3107	<	std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
3108	<	jobStates const &arg4_defvalue = SCHEDULED ;
3109	<	jobStates *arg4 = (jobStates *) &arg4_defvalue ;
3110	<	printOption const &arg5_defvalue = NORMAL ;
3111	<	printOption *arg5 = (printOption *) &arg5_defvalue ;
3112	<	std::string const &arg6_defvalue = "" ;
3113	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
3114	<	std::vector<BossJob * > *argp2 ;
3115	<	std::string temp6 ;
3105	>	std::string const &arg2_defvalue = "all" ;
3106	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3107	>	std::string const &arg3_defvalue = "" ;
3108	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3109	>	std::string const &arg4_defvalue = "" ;
3110	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3111	>	std::string const &arg5_defvalue = "" ;
3112	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3113	>	std::vector<std::string > result;
3114	>	std::string temp2 ;
3115	>	std::string temp3 ;
3116	>	std::string temp4 ;
3117	>	std::string temp5 ;
3118		PyObject * obj0 = 0 ;
3119		PyObject * obj1 = 0 ;
3120		PyObject * obj2 = 0 ;
3121		PyObject * obj3 = 0 ;
3122		PyObject * obj4 = 0 ;
2395	–	PyObject * obj5 = 0 ;
3123
3124	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossSession_queryPrint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3124	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3125		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3126	<	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3127	<	arg2 = *argp2;
3126	>	if (obj1) {
3127	>	{
3128	>	if (PyString_Check(obj1)) {
3129	>	temp2 = std::string(PyString_AsString(obj1));
3130	>	arg2 = &temp2;
3131	>	}else {
3132	>	SWIG_exception(SWIG_TypeError, "string expected");
3133	>	}
3134	>	}
3135	>	}
3136		if (obj2) {
3137	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3138	<	if (arg3 == NULL) {
3139	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3137	>	{
3138	>	if (PyString_Check(obj2)) {
3139	>	temp3 = std::string(PyString_AsString(obj2));
3140	>	arg3 = &temp3;
3141	>	}else {
3142	>	SWIG_exception(SWIG_TypeError, "string expected");
3143	>	}
3144		}
3145		}
3146		if (obj3) {
3147	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3148	<	if (arg4 == NULL) {
3149	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3147	>	{
3148	>	if (PyString_Check(obj3)) {
3149	>	temp4 = std::string(PyString_AsString(obj3));
3150	>	arg4 = &temp4;
3151	>	}else {
3152	>	SWIG_exception(SWIG_TypeError, "string expected");
3153	>	}
3154		}
3155		}
3156		if (obj4) {
2414	–	if ((SWIG_ConvertPtr(obj4,(void **) &arg5, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2415	–	if (arg5 == NULL) {
2416	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2417	–	}
2418	–	}
2419	–	if (obj5) {
3157		{
3158	<	if (PyString_Check(obj5)) {
3159	<	temp6 = std::string(PyString_AsString(obj5));
3160	<	arg6 = &temp6;
3158	>	if (PyString_Check(obj4)) {
3159	>	temp5 = std::string(PyString_AsString(obj4));
3160	>	arg5 = &temp5;
3161		}else {
3162		SWIG_exception(SWIG_TypeError, "string expected");
3163		}
#	Line 2428 | Line 3165 | static PyObject *_wrap_BossSession_query
3165		}
3166		{
3167		try {
3168	<	(arg1)->queryPrint(arg2,*arg3,(jobStates const &)*arg4,(printOption const &)*arg5,(std::string const &)*arg6);
3168	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3169
3170	+	}catch (const BossSchedFailure & e) {
3171	+	PyErr_SetString ( SchedulerError, e.what() );
3172	+	return NULL;
3173		}catch (const std::exception& e) {
3174	<	SWIG_exception(SWIG_RuntimeError, e.what());
3174	>	PyErr_SetString ( BossError, e.what() );
3175	>	return NULL;
3176		}
3177		}
3178	<	Py_INCREF(Py_None); resultobj = Py_None;
3178	>	{
3179	>	resultobj = PyTuple_New((&result)->size());
3180	>	for (unsigned int i=0; i<(&result)->size(); i++)
3181	>	PyTuple_SetItem(resultobj,i,
3182	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3183	>	}
3184		return resultobj;
3185		fail:
3186		return NULL;
3187		}
3188
3189
3190	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3190	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3191		PyObject *resultobj;
3192		BossSession *arg1 = (BossSession *) 0 ;
3193	<	std::string const &arg2_defvalue = "all" ;
3194	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2449	<	std::string const &arg3_defvalue = "" ;
3193	>	int arg2 = (int) SCHEDULED ;
3194	>	std::string const &arg3_defvalue = "all" ;
3195		std::string *arg3 = (std::string *) &arg3_defvalue ;
3196	<	std::string const &arg4_defvalue = "" ;
3196	>	std::string const &arg4_defvalue = "all" ;
3197		std::string *arg4 = (std::string *) &arg4_defvalue ;
3198		std::string const &arg5_defvalue = "" ;
3199		std::string *arg5 = (std::string *) &arg5_defvalue ;
3200	<	std::vector<std::string > result;
3201	<	std::string temp2 ;
3200	>	std::string arg6 = (std::string) "" ;
3201	>	std::string arg7 = (std::string) "" ;
3202	>	std::string arg8 = (std::string) "" ;
3203	>	std::string arg9 = (std::string) "" ;
3204	>	unsigned int arg10 = (unsigned int) 0 ;
3205	>	bool arg11 = (bool) false ;
3206	>	SwigValueWrapper< std::vector<BossTask * > > result;
3207		std::string temp3 ;
3208		std::string temp4 ;
3209		std::string temp5 ;
3210		PyObject * obj0 = 0 ;
2461	–	PyObject * obj1 = 0 ;
3211		PyObject * obj2 = 0 ;
3212		PyObject * obj3 = 0 ;
3213		PyObject * obj4 = 0 ;
3214	+	PyObject * obj5 = 0 ;
3215	+	PyObject * obj6 = 0 ;
3216	+	PyObject * obj7 = 0 ;
3217	+	PyObject * obj8 = 0 ;
3218	+	PyObject * obj9 = 0 ;
3219	+	PyObject * obj10 = 0 ;
3220
3221	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3221	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3222		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2468	–	if (obj1) {
2469	–	{
2470	–	if (PyString_Check(obj1)) {
2471	–	temp2 = std::string(PyString_AsString(obj1));
2472	–	arg2 = &temp2;
2473	–	}else {
2474	–	SWIG_exception(SWIG_TypeError, "string expected");
2475	–	}
2476	–	}
2477	–	}
3223		if (obj2) {
3224		{
3225		if (PyString_Check(obj2)) {
#	Line 2505 | Line 3250 | static PyObject *_wrap_BossSession_selec
3250		}
3251		}
3252		}
3253	+	if (obj5) {
3254	+	{
3255	+	if (PyString_Check(obj5))
3256	+	arg6 = std::string(PyString_AsString(obj5));
3257	+	else
3258	+	SWIG_exception(SWIG_TypeError, "string expected");
3259	+	}
3260	+	}
3261	+	if (obj6) {
3262	+	{
3263	+	if (PyString_Check(obj6))
3264	+	arg7 = std::string(PyString_AsString(obj6));
3265	+	else
3266	+	SWIG_exception(SWIG_TypeError, "string expected");
3267	+	}
3268	+	}
3269	+	if (obj7) {
3270	+	{
3271	+	if (PyString_Check(obj7))
3272	+	arg8 = std::string(PyString_AsString(obj7));
3273	+	else
3274	+	SWIG_exception(SWIG_TypeError, "string expected");
3275	+	}
3276	+	}
3277	+	if (obj8) {
3278	+	{
3279	+	if (PyString_Check(obj8))
3280	+	arg9 = std::string(PyString_AsString(obj8));
3281	+	else
3282	+	SWIG_exception(SWIG_TypeError, "string expected");
3283	+	}
3284	+	}
3285	+	if (obj9) {
3286	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3287	+	if (PyErr_Occurred()) SWIG_fail;
3288	+	}
3289	+	if (obj10) {
3290	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3291	+	if (PyErr_Occurred()) SWIG_fail;
3292	+	}
3293		{
3294		try {
3295	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3295	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3296
3297	+	}catch (const BossSchedFailure & e) {
3298	+	PyErr_SetString ( SchedulerError, e.what() );
3299	+	return NULL;
3300		}catch (const std::exception& e) {
3301	<	SWIG_exception(SWIG_RuntimeError, e.what());
3301	>	PyErr_SetString ( BossError, e.what() );
3302	>	return NULL;
3303		}
3304		}
3305		{
3306	<	std::vector<std::string > * resultptr;
3307	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3308	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3306	>	std::vector<BossTask * > * resultptr;
3307	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3308	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3309		}
3310		return resultobj;
3311		fail:
#	Line 2524 | Line 3313 | static PyObject *_wrap_BossSession_selec
3313		}
3314
3315
3316	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
2528	<	PyObject *obj;
2529	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2530	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
2531	<	Py_INCREF(obj);
2532	<	return Py_BuildValue((char *)"");
2533	<	}
2534	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3316	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3317		PyObject *resultobj;
3318	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3319	<	char *arg2 ;
3318	>	BossSession *arg1 = (BossSession *) 0 ;
3319	>	std::vector<std::string > *arg2 = 0 ;
3320	>	PyObject *result;
3321		PyObject * obj0 = 0 ;
3322	+	PyObject * obj1 = 0 ;
3323
3324	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3325	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3324	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3325	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3326	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3327	>	if (arg2 == NULL) {
3328	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3329	>	}
3330		{
3331	<	if (arg2) {
3332	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3333	<	strcpy((char *) arg1->key,arg2);
3334	<	}else {
3335	<	arg1->key = 0;
3331	>	try {
3332	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3333	>
3334	>	}catch (const BossSchedFailure & e) {
3335	>	PyErr_SetString ( SchedulerError, e.what() );
3336	>	return NULL;
3337	>	}catch (const std::exception& e) {
3338	>	PyErr_SetString ( BossError, e.what() );
3339	>	return NULL;
3340		}
3341		}
3342	<	Py_INCREF(Py_None); resultobj = Py_None;
3342	>	resultobj = result;
3343		return resultobj;
3344		fail:
3345		return NULL;
3346		}
3347
3348
3349	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3349	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3350		PyObject *resultobj;
3351	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3352	<	char *result;
3351	>	BossSession *arg1 = (BossSession *) 0 ;
3352	>	PyObject *result;
3353		PyObject * obj0 = 0 ;
3354
3355	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3356	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3357	<	result = (char *) ((arg1)->key);
3358	<
3359	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3355	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3356	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3357	>	{
3358	>	try {
3359	>	result = (PyObject *)BossSession_CHTools(arg1);
3360	>
3361	>	}catch (const BossSchedFailure & e) {
3362	>	PyErr_SetString ( SchedulerError, e.what() );
3363	>	return NULL;
3364	>	}catch (const std::exception& e) {
3365	>	PyErr_SetString ( BossError, e.what() );
3366	>	return NULL;
3367	>	}
3368	>	}
3369	>	resultobj = result;
3370		return resultobj;
3371		fail:
3372		return NULL;
3373		}
3374
3375
3376	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3376	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3377		PyObject *resultobj;
3378	<	char *arg1 ;
3379	<	BossTaskException *result;
3378	>	BossSession *arg1 = (BossSession *) 0 ;
3379	>	PyObject *result;
3380	>	PyObject * obj0 = 0 ;
3381
3382	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3382	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3383	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3384		{
3385		try {
3386	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3386	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3387
3388	+	}catch (const BossSchedFailure & e) {
3389	+	PyErr_SetString ( SchedulerError, e.what() );
3390	+	return NULL;
3391		}catch (const std::exception& e) {
3392	<	SWIG_exception(SWIG_RuntimeError, e.what());
3392	>	PyErr_SetString ( BossError, e.what() );
3393	>	return NULL;
3394		}
3395		}
3396	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3396	>	resultobj = result;
3397		return resultobj;
3398		fail:
3399		return NULL;
3400		}
3401
3402
3403	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3403	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3404		PyObject *resultobj;
3405	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3406	<	char *result;
3405	>	BossSession *arg1 = (BossSession *) 0 ;
3406	>	PyObject *result;
3407		PyObject * obj0 = 0 ;
3408
3409	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3410	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3409	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3410	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3411		{
3412		try {
3413	<	result = (char *)((BossTaskException const *)arg1)->what();
3413	>	result = (PyObject *)BossSession_RTMons(arg1);
3414
3415	+	}catch (const BossSchedFailure & e) {
3416	+	PyErr_SetString ( SchedulerError, e.what() );
3417	+	return NULL;
3418		}catch (const std::exception& e) {
3419	<	SWIG_exception(SWIG_RuntimeError, e.what());
3419	>	PyErr_SetString ( BossError, e.what() );
3420	>	return NULL;
3421		}
3422		}
3423	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3423	>	resultobj = result;
3424		return resultobj;
3425		fail:
3426		return NULL;
3427		}
3428
3429
3430	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3430	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3431		PyObject *resultobj;
3432	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3432	>	BossSession *arg1 = (BossSession *) 0 ;
3433	>	PyObject *result;
3434		PyObject * obj0 = 0 ;
3435
3436	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3437	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3436	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3437	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3438		{
3439		try {
3440	<	delete arg1;
3440	>	result = (PyObject *)BossSession_schedulers(arg1);
3441
3442	+	}catch (const BossSchedFailure & e) {
3443	+	PyErr_SetString ( SchedulerError, e.what() );
3444	+	return NULL;
3445		}catch (const std::exception& e) {
3446	<	SWIG_exception(SWIG_RuntimeError, e.what());
3446	>	PyErr_SetString ( BossError, e.what() );
3447	>	return NULL;
3448		}
3449		}
3450	<	Py_INCREF(Py_None); resultobj = Py_None;
3450	>	resultobj = result;
3451		return resultobj;
3452		fail:
3453		return NULL;
3454		}
3455
3456
3457	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
2641	<	PyObject *obj;
2642	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2643	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
2644	<	Py_INCREF(obj);
2645	<	return Py_BuildValue((char *)"");
2646	<	}
2647	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3457	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3458		PyObject *resultobj;
3459	<	BossTask *arg1 = (BossTask *) 0 ;
3460	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3459	>	BossSession *arg1 = (BossSession *) 0 ;
3460	>	std::string *arg2 = 0 ;
3461	>	std::string *arg3 = 0 ;
3462	>	std::string const &arg4_defvalue = "" ;
3463	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3464	>	std::string const &arg5_defvalue = "" ;
3465	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3466	>	unsigned int arg6 = (unsigned int) 0 ;
3467	>	bool arg7 = (bool) false ;
3468		PyObject *result;
3469	+	std::string temp2 ;
3470	+	std::string temp3 ;
3471	+	std::string temp4 ;
3472	+	std::string temp5 ;
3473		PyObject * obj0 = 0 ;
3474		PyObject * obj1 = 0 ;
3475	+	PyObject * obj2 = 0 ;
3476	+	PyObject * obj3 = 0 ;
3477	+	PyObject * obj4 = 0 ;
3478	+	PyObject * obj5 = 0 ;
3479	+	PyObject * obj6 = 0 ;
3480
3481	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3482	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3483	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3484	<	if (arg2 == NULL) {
3485	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3481	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3482	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3483	>	{
3484	>	if (PyString_Check(obj1)) {
3485	>	temp2 = std::string(PyString_AsString(obj1));
3486	>	arg2 = &temp2;
3487	>	}else {
3488	>	SWIG_exception(SWIG_TypeError, "string expected");
3489	>	}
3490	>	}
3491	>	{
3492	>	if (PyString_Check(obj2)) {
3493	>	temp3 = std::string(PyString_AsString(obj2));
3494	>	arg3 = &temp3;
3495	>	}else {
3496	>	SWIG_exception(SWIG_TypeError, "string expected");
3497	>	}
3498	>	}
3499	>	if (obj3) {
3500	>	{
3501	>	if (PyString_Check(obj3)) {
3502	>	temp4 = std::string(PyString_AsString(obj3));
3503	>	arg4 = &temp4;
3504	>	}else {
3505	>	SWIG_exception(SWIG_TypeError, "string expected");
3506	>	}
3507	>	}
3508	>	}
3509	>	if (obj4) {
3510	>	{
3511	>	if (PyString_Check(obj4)) {
3512	>	temp5 = std::string(PyString_AsString(obj4));
3513	>	arg5 = &temp5;
3514	>	}else {
3515	>	SWIG_exception(SWIG_TypeError, "string expected");
3516	>	}
3517	>	}
3518	>	}
3519	>	if (obj5) {
3520	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3521	>	if (PyErr_Occurred()) SWIG_fail;
3522	>	}
3523	>	if (obj6) {
3524	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3525	>	if (PyErr_Occurred()) SWIG_fail;
3526		}
3527		{
3528		try {
3529	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3529	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3530
3531	+	}catch (const BossSchedFailure & e) {
3532	+	PyErr_SetString ( SchedulerError, e.what() );
3533	+	return NULL;
3534		}catch (const std::exception& e) {
3535	<	SWIG_exception(SWIG_RuntimeError, e.what());
3535	>	PyErr_SetString ( BossError, e.what() );
3536	>	return NULL;
3537		}
3538		}
3539		resultobj = result;
#	Line 2673 | Line 3543 | static PyObject *_wrap_BossTask_jobDict(
3543		}
3544
3545
3546	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3546	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3547		PyObject *resultobj;
3548	<	BossTask *arg1 = (BossTask *) 0 ;
3548	>	BossSession *arg1 = (BossSession *) 0 ;
3549	>	int arg2 = (int) SCHEDULED ;
3550	>	std::string const &arg3_defvalue = "all" ;
3551	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3552	>	std::string const &arg4_defvalue = "all" ;
3553	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3554	>	std::string const &arg5_defvalue = "" ;
3555	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3556	>	std::string arg6 = (std::string) "" ;
3557	>	std::string arg7 = (std::string) "" ;
3558	>	std::string arg8 = (std::string) "" ;
3559	>	std::string arg9 = (std::string) "" ;
3560	>	unsigned int arg10 = (unsigned int) 0 ;
3561	>	bool arg11 = (bool) false ;
3562		PyObject *result;
3563	+	std::string temp3 ;
3564	+	std::string temp4 ;
3565	+	std::string temp5 ;
3566		PyObject * obj0 = 0 ;
3567	+	PyObject * obj2 = 0 ;
3568	+	PyObject * obj3 = 0 ;
3569	+	PyObject * obj4 = 0 ;
3570	+	PyObject * obj5 = 0 ;
3571	+	PyObject * obj6 = 0 ;
3572	+	PyObject * obj7 = 0 ;
3573	+	PyObject * obj8 = 0 ;
3574	+	PyObject * obj9 = 0 ;
3575	+	PyObject * obj10 = 0 ;
3576
3577	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3578	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3577	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3578	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3579	>	if (obj2) {
3580	>	{
3581	>	if (PyString_Check(obj2)) {
3582	>	temp3 = std::string(PyString_AsString(obj2));
3583	>	arg3 = &temp3;
3584	>	}else {
3585	>	SWIG_exception(SWIG_TypeError, "string expected");
3586	>	}
3587	>	}
3588	>	}
3589	>	if (obj3) {
3590	>	{
3591	>	if (PyString_Check(obj3)) {
3592	>	temp4 = std::string(PyString_AsString(obj3));
3593	>	arg4 = &temp4;
3594	>	}else {
3595	>	SWIG_exception(SWIG_TypeError, "string expected");
3596	>	}
3597	>	}
3598	>	}
3599	>	if (obj4) {
3600	>	{
3601	>	if (PyString_Check(obj4)) {
3602	>	temp5 = std::string(PyString_AsString(obj4));
3603	>	arg5 = &temp5;
3604	>	}else {
3605	>	SWIG_exception(SWIG_TypeError, "string expected");
3606	>	}
3607	>	}
3608	>	}
3609	>	if (obj5) {
3610	>	{
3611	>	if (PyString_Check(obj5))
3612	>	arg6 = std::string(PyString_AsString(obj5));
3613	>	else
3614	>	SWIG_exception(SWIG_TypeError, "string expected");
3615	>	}
3616	>	}
3617	>	if (obj6) {
3618	>	{
3619	>	if (PyString_Check(obj6))
3620	>	arg7 = std::string(PyString_AsString(obj6));
3621	>	else
3622	>	SWIG_exception(SWIG_TypeError, "string expected");
3623	>	}
3624	>	}
3625	>	if (obj7) {
3626	>	{
3627	>	if (PyString_Check(obj7))
3628	>	arg8 = std::string(PyString_AsString(obj7));
3629	>	else
3630	>	SWIG_exception(SWIG_TypeError, "string expected");
3631	>	}
3632	>	}
3633	>	if (obj8) {
3634	>	{
3635	>	if (PyString_Check(obj8))
3636	>	arg9 = std::string(PyString_AsString(obj8));
3637	>	else
3638	>	SWIG_exception(SWIG_TypeError, "string expected");
3639	>	}
3640	>	}
3641	>	if (obj9) {
3642	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3643	>	if (PyErr_Occurred()) SWIG_fail;
3644	>	}
3645	>	if (obj10) {
3646	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3647	>	if (PyErr_Occurred()) SWIG_fail;
3648	>	}
3649		{
3650		try {
3651	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3651	>	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3652
3653	+	}catch (const BossSchedFailure & e) {
3654	+	PyErr_SetString ( SchedulerError, e.what() );
3655	+	return NULL;
3656		}catch (const std::exception& e) {
3657	<	SWIG_exception(SWIG_RuntimeError, e.what());
3657	>	PyErr_SetString ( BossError, e.what() );
3658	>	return NULL;
3659		}
3660		}
3661		resultobj = result;
#	Line 2696 | Line 3665 | static PyObject *_wrap_BossTask_jobsMap_
3665		}
3666
3667
3668	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3669	<	int argc;
3670	<	PyObject *argv[2];
3671	<	int ii;
3668	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3669	>	PyObject *obj;
3670	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3671	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3672	>	Py_INCREF(obj);
3673	>	return Py_BuildValue((char *)"");
3674	>	}
3675	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3676	>	PyObject *resultobj;
3677	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3678	>	char *arg2 ;
3679	>	PyObject * obj0 = 0 ;
3680
3681	<	argc = PyObject_Length(args);
3682	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3683	<	argv[ii] = PyTuple_GetItem(args,ii);
3684	<	}
3685	<	if (argc == 1) {
3686	<	int _v;
3687	<	{
3688	<	void *ptr;
2712	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
2713	<	_v = 0;
2714	<	PyErr_Clear();
2715	<	}else {
2716	<	_v = 1;
2717	<	}
2718	<	}
2719	<	if (_v) {
2720	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
3681	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3682	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3683	>	{
3684	>	if (arg2) {
3685	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3686	>	strcpy((char *) arg1->key,arg2);
3687	>	}else {
3688	>	arg1->key = 0;
3689		}
3690		}
3691	<
3692	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3691	>	Py_INCREF(Py_None); resultobj = Py_None;
3692	>	return resultobj;
3693	>	fail:
3694		return NULL;
3695		}
3696
3697
3698	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3698	>	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3699		PyObject *resultobj;
3700	<	BossTask *arg1 = (BossTask *) 0 ;
3701	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
2733	<	PyObject *result;
3700	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3701	>	char *result;
3702		PyObject * obj0 = 0 ;
2735	–	PyObject * obj1 = 0 ;
3703
3704	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3705	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3706	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3707	<	if (arg2 == NULL) {
3708	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3709	<	}
3704	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3705	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3706	>	result = (char *) ((arg1)->key);
3707	>
3708	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3709	>	return resultobj;
3710	>	fail:
3711	>	return NULL;
3712	>	}
3713	>
3714	>
3715	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3716	>	PyObject *resultobj;
3717	>	char *arg1 ;
3718	>	BossTaskException *result;
3719	>
3720	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3721		{
3722		try {
3723	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3723	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3724
3725	+	}catch (const BossSchedFailure & e) {
3726	+	PyErr_SetString ( SchedulerError, e.what() );
3727	+	return NULL;
3728		}catch (const std::exception& e) {
3729	<	SWIG_exception(SWIG_RuntimeError, e.what());
3729	>	PyErr_SetString ( BossError, e.what() );
3730	>	return NULL;
3731		}
3732		}
3733	<	resultobj = result;
3733	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3734		return resultobj;
3735		fail:
3736		return NULL;
3737		}
3738
3739
3740	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
3740	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3741		PyObject *resultobj;
3742	<	BossTask *arg1 = (BossTask *) 0 ;
3743	<	std::string *arg2 = 0 ;
2762	<	PyObject *result;
2763	<	std::string temp2 ;
3742	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3743	>	char *result;
3744		PyObject * obj0 = 0 ;
2765	–	PyObject * obj1 = 0 ;
3745
3746	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3747	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3746	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3747	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3748		{
3749	<	if (PyString_Check(obj1)) {
3750	<	temp2 = std::string(PyString_AsString(obj1));
3751	<	arg2 = &temp2;
3752	<	}else {
3753	<	SWIG_exception(SWIG_TypeError, "string expected");
3749	>	try {
3750	>	result = (char *)((BossTaskException const *)arg1)->what();
3751	>
3752	>	}catch (const BossSchedFailure & e) {
3753	>	PyErr_SetString ( SchedulerError, e.what() );
3754	>	return NULL;
3755	>	}catch (const std::exception& e) {
3756	>	PyErr_SetString ( BossError, e.what() );
3757	>	return NULL;
3758		}
3759		}
3760	+	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3761	+	return resultobj;
3762	+	fail:
3763	+	return NULL;
3764	+	}
3765	+
3766	+
3767	+	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3768	+	PyObject *resultobj;
3769	+	BossTaskException *arg1 = (BossTaskException *) 0 ;
3770	+	PyObject * obj0 = 0 ;
3771	+
3772	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3773	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3774		{
3775		try {
3776	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3776	>	delete arg1;
3777
3778	+	}catch (const BossSchedFailure & e) {
3779	+	PyErr_SetString ( SchedulerError, e.what() );
3780	+	return NULL;
3781		}catch (const std::exception& e) {
3782	<	SWIG_exception(SWIG_RuntimeError, e.what());
3782	>	PyErr_SetString ( BossError, e.what() );
3783	>	return NULL;
3784		}
3785		}
3786	<	resultobj = result;
3786	>	Py_INCREF(Py_None); resultobj = Py_None;
3787		return resultobj;
3788		fail:
3789		return NULL;
3790		}
3791
3792
3793	+	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3794	+	PyObject *obj;
3795	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3796	+	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3797	+	Py_INCREF(obj);
3798	+	return Py_BuildValue((char *)"");
3799	+	}
3800		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3801		PyObject *resultobj;
3802		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 2801 | Line 3809 | static PyObject *_wrap_new_BossTask__SWI
3809		try {
3810		result = (BossTask *)new BossTask(arg1);
3811
3812	+	}catch (const BossSchedFailure & e) {
3813	+	PyErr_SetString ( SchedulerError, e.what() );
3814	+	return NULL;
3815		}catch (const std::exception& e) {
3816	<	SWIG_exception(SWIG_RuntimeError, e.what());
3816	>	PyErr_SetString ( BossError, e.what() );
3817	>	return NULL;
3818		}
3819		}
3820		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 2835 | Line 3847 | static PyObject *_wrap_new_BossTask__SWI
3847		try {
3848		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3849
3850	+	}catch (const BossSchedFailure & e) {
3851	+	PyErr_SetString ( SchedulerError, e.what() );
3852	+	return NULL;
3853		}catch (const std::exception& e) {
3854	<	SWIG_exception(SWIG_RuntimeError, e.what());
3854	>	PyErr_SetString ( BossError, e.what() );
3855	>	return NULL;
3856		}
3857		}
3858		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 2857 | Line 3873 | static PyObject *_wrap_delete_BossTask(P
3873		try {
3874		delete arg1;
3875
3876	+	}catch (const BossSchedFailure & e) {
3877	+	PyErr_SetString ( SchedulerError, e.what() );
3878	+	return NULL;
3879		}catch (const std::exception& e) {
3880	<	SWIG_exception(SWIG_RuntimeError, e.what());
3880	>	PyErr_SetString ( BossError, e.what() );
3881	>	return NULL;
3882		}
3883		}
3884		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2883 | Line 3903 | static PyObject *_wrap_new_BossTask__SWI
3903		try {
3904		result = (BossTask *)new BossTask((BossTask const &)*arg1);
3905
3906	+	}catch (const BossSchedFailure & e) {
3907	+	PyErr_SetString ( SchedulerError, e.what() );
3908	+	return NULL;
3909		}catch (const std::exception& e) {
3910	<	SWIG_exception(SWIG_RuntimeError, e.what());
3910	>	PyErr_SetString ( BossError, e.what() );
3911	>	return NULL;
3912		}
3913		}
3914		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 2974 | Line 3998 | static PyObject *_wrap_BossTask_id(PyObj
3998		result = (std::string *) &_result_ref;
3999		}
4000
4001	+	}catch (const BossSchedFailure & e) {
4002	+	PyErr_SetString ( SchedulerError, e.what() );
4003	+	return NULL;
4004		}catch (const std::exception& e) {
4005	<	SWIG_exception(SWIG_RuntimeError, e.what());
4005	>	PyErr_SetString ( BossError, e.what() );
4006	>	return NULL;
4007		}
4008		}
4009		{
#	Line 3002 | Line 4030 | static PyObject *_wrap_BossTask_name(PyO
4030		result = (std::string *) &_result_ref;
4031		}
4032
4033	+	}catch (const BossSchedFailure & e) {
4034	+	PyErr_SetString ( SchedulerError, e.what() );
4035	+	return NULL;
4036		}catch (const std::exception& e) {
4037	<	SWIG_exception(SWIG_RuntimeError, e.what());
4037	>	PyErr_SetString ( BossError, e.what() );
4038	>	return NULL;
4039		}
4040		}
4041		{
#	Line 3015 | Line 4047 | static PyObject *_wrap_BossTask_name(PyO
4047		}
4048
4049
4050	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
4050	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4051		PyObject *resultobj;
4052		BossTask *arg1 = (BossTask *) 0 ;
4053	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4053	>	std::map<std::string,std::string > result;
4054		PyObject * obj0 = 0 ;
4055
4056	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4056	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4057		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4058		{
4059		try {
4060	<	result = ((BossTask const *)arg1)->jobsMap();
4060	>	result = ((BossTask const *)arg1)->taskMap();
4061
4062	+	}catch (const BossSchedFailure & e) {
4063	+	PyErr_SetString ( SchedulerError, e.what() );
4064	+	return NULL;
4065		}catch (const std::exception& e) {
4066	<	SWIG_exception(SWIG_RuntimeError, e.what());
4066	>	PyErr_SetString ( BossError, e.what() );
4067	>	return NULL;
4068		}
4069		}
4070		{
4071	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4072	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4073	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4071	>	resultobj = PyDict_New();
4072	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4073	>	PyDict_SetItem(resultobj,
4074	>	SwigString_FromString(i->first),
4075	>	SwigString_FromString(i->second));
4076	>	}
4077		}
4078		return resultobj;
4079		fail:
#	Line 3042 | Line 4081 | static PyObject *_wrap_BossTask_jobsMap_
4081		}
4082
4083
4084	<	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4084	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4085		PyObject *resultobj;
4086		BossTask *arg1 = (BossTask *) 0 ;
4087	<	unsigned int arg2 ;
3049	<	std::map<std::string,std::string > result;
4087	>	BossTask::job_iterator result;
4088		PyObject * obj0 = 0 ;
3051	–	PyObject * obj1 = 0 ;
4089
4090	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4090	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4091		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3055	–	arg2 = (unsigned int) PyInt_AsLong(obj1);
3056	–	if (PyErr_Occurred()) SWIG_fail;
4092		{
4093		try {
4094	<	result = ((BossTask const *)arg1)->jobMap(arg2);
4094	>	result = ((BossTask const *)arg1)->job_begin();
4095
4096	+	}catch (const BossSchedFailure & e) {
4097	+	PyErr_SetString ( SchedulerError, e.what() );
4098	+	return NULL;
4099		}catch (const std::exception& e) {
4100	<	SWIG_exception(SWIG_RuntimeError, e.what());
4100	>	PyErr_SetString ( BossError, e.what() );
4101	>	return NULL;
4102		}
4103		}
4104		{
4105	<	resultobj = PyDict_New();
4106	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4107	<	PyDict_SetItem(resultobj,
4108	<	SwigString_FromString(i->first),
4109	<	SwigString_FromString(i->second));
4105	>	BossTask::job_iterator * resultptr;
4106	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4107	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4108	>	}
4109	>	return resultobj;
4110	>	fail:
4111	>	return NULL;
4112	>	}
4113	>
4114	>
4115	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4116	>	PyObject *resultobj;
4117	>	BossTask *arg1 = (BossTask *) 0 ;
4118	>	BossTask::job_iterator result;
4119	>	PyObject * obj0 = 0 ;
4120	>
4121	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4122	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4123	>	{
4124	>	try {
4125	>	result = ((BossTask const *)arg1)->job_end();
4126	>
4127	>	}catch (const BossSchedFailure & e) {
4128	>	PyErr_SetString ( SchedulerError, e.what() );
4129	>	return NULL;
4130	>	}catch (const std::exception& e) {
4131	>	PyErr_SetString ( BossError, e.what() );
4132	>	return NULL;
4133		}
4134		}
4135	+	{
4136	+	BossTask::job_iterator * resultptr;
4137	+	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4138	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4139	+	}
4140		return resultobj;
4141		fail:
4142		return NULL;
4143		}
4144
4145
4146	<	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4146	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4147	>	PyObject *resultobj;
4148	>	BossTask *arg1 = (BossTask *) 0 ;
4149	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4150	>	PyObject * obj0 = 0 ;
4151	>
4152	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4153	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4154	>	{
4155	>	try {
4156	>	result = ((BossTask const *)arg1)->jobsMap();
4157	>
4158	>	}catch (const BossSchedFailure & e) {
4159	>	PyErr_SetString ( SchedulerError, e.what() );
4160	>	return NULL;
4161	>	}catch (const std::exception& e) {
4162	>	PyErr_SetString ( BossError, e.what() );
4163	>	return NULL;
4164	>	}
4165	>	}
4166	>	{
4167	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4168	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4169	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4170	>	}
4171	>	return resultobj;
4172	>	fail:
4173	>	return NULL;
4174	>	}
4175	>
4176	>
4177	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4178		PyObject *resultobj;
4179		BossTask *arg1 = (BossTask *) 0 ;
4180		SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
#	Line 3099 | Line 4197 | static PyObject *_wrap_BossTask_jobMap__
4197		try {
4198		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4199
4200	+	}catch (const BossSchedFailure & e) {
4201	+	PyErr_SetString ( SchedulerError, e.what() );
4202	+	return NULL;
4203		}catch (const std::exception& e) {
4204	<	SWIG_exception(SWIG_RuntimeError, e.what());
4204	>	PyErr_SetString ( BossError, e.what() );
4205	>	return NULL;
4206		}
4207		}
4208		{
#	Line 3112 | Line 4214 | static PyObject *_wrap_BossTask_jobMap__
4214		}
4215
4216
4217	+	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4218	+	PyObject *resultobj;
4219	+	BossTask *arg1 = (BossTask *) 0 ;
4220	+	unsigned int arg2 ;
4221	+	std::map<std::string,std::string > result;
4222	+	PyObject * obj0 = 0 ;
4223	+	PyObject * obj1 = 0 ;
4224	+
4225	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4226	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4227	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
4228	+	if (PyErr_Occurred()) SWIG_fail;
4229	+	{
4230	+	try {
4231	+	result = ((BossTask const *)arg1)->jobMap(arg2);
4232	+
4233	+	}catch (const BossSchedFailure & e) {
4234	+	PyErr_SetString ( SchedulerError, e.what() );
4235	+	return NULL;
4236	+	}catch (const std::exception& e) {
4237	+	PyErr_SetString ( BossError, e.what() );
4238	+	return NULL;
4239	+	}
4240	+	}
4241	+	{
4242	+	resultobj = PyDict_New();
4243	+	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4244	+	PyDict_SetItem(resultobj,
4245	+	SwigString_FromString(i->first),
4246	+	SwigString_FromString(i->second));
4247	+	}
4248	+	}
4249	+	return resultobj;
4250	+	fail:
4251	+	return NULL;
4252	+	}
4253	+
4254	+
4255		static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4256		int argc;
4257		PyObject *argv[4];
#	Line 3137 | Line 4277 | static PyObject *_wrap_BossTask_jobMap(P
4277		_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4278		}
4279		if (_v) {
4280	<	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4280	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4281		}
4282		}
4283		}
#	Line 3173 | Line 4313 | static PyObject *_wrap_BossTask_jobMap(P
4313		}
4314		}
4315		if (_v) {
4316	<	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4316	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4317		}
4318		}
4319		}
#	Line 3184 | Line 4324 | static PyObject *_wrap_BossTask_jobMap(P
4324		}
4325
4326
4327	<	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;
3195	<	{
3196	<	try {
3197	<	result = ((BossTask const *)arg1)->job_begin();
3198	<
3199	<	}catch (const std::exception& e) {
3200	<	SWIG_exception(SWIG_RuntimeError, e.what());
3201	<	}
3202	<	}
3203	<	{
3204	<	BossTask::job_iterator * resultptr;
3205	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3206	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3207	<	}
3208	<	return resultobj;
3209	<	fail:
3210	<	return NULL;
3211	<	}
3212	<
3213	<
3214	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4327	>	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4328		PyObject *resultobj;
4329		BossTask *arg1 = (BossTask *) 0 ;
4330	<	BossTask::job_iterator result;
4330	>	BossJob *arg2 = (BossJob *) 0 ;
4331	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4332		PyObject * obj0 = 0 ;
4333	+	PyObject * obj1 = 0 ;
4334
4335	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4335	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4336		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4337	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4338		{
4339		try {
4340	<	result = ((BossTask const *)arg1)->job_end();
4340	>	result = ((BossTask const *)arg1)->programsMap((BossJob 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	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4352	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4353	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4354		}
4355		return resultobj;
4356		fail:
#	Line 3253 | Line 4373 | static PyObject *_wrap_BossTask_queryJob
4373		try {
4374		result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4375
4376	+	}catch (const BossSchedFailure & e) {
4377	+	PyErr_SetString ( SchedulerError, e.what() );
4378	+	return NULL;
4379		}catch (const std::exception& e) {
4380	<	SWIG_exception(SWIG_RuntimeError, e.what());
4380	>	PyErr_SetString ( BossError, e.what() );
4381	>	return NULL;
4382		}
4383		}
4384		{
#	Line 3268 | Line 4392 | static PyObject *_wrap_BossTask_queryJob
4392		}
4393
4394
3271	–	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
3272	–	PyObject *resultobj;
3273	–	BossTask *arg1 = (BossTask *) 0 ;
3274	–	BossJob *arg2 = (BossJob *) 0 ;
3275	–	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3276	–	PyObject * obj0 = 0 ;
3277	–	PyObject * obj1 = 0 ;
3278	–
3279	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
3280	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3281	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3282	–	{
3283	–	try {
3284	–	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
3285	–
3286	–	}catch (const std::exception& e) {
3287	–	SWIG_exception(SWIG_RuntimeError, e.what());
3288	–	}
3289	–	}
3290	–	{
3291	–	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3292	–	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3293	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3294	–	}
3295	–	return resultobj;
3296	–	fail:
3297	–	return NULL;
3298	–	}
3299	–
3300	–
4395		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4396		PyObject *resultobj;
4397		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3334 | Line 4428 | static PyObject *_wrap_BossTask_declare_
4428		try {
4429		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4430
4431	+	}catch (const BossSchedFailure & e) {
4432	+	PyErr_SetString ( SchedulerError, e.what() );
4433	+	return NULL;
4434		}catch (const std::exception& e) {
4435	<	SWIG_exception(SWIG_RuntimeError, e.what());
4435	>	PyErr_SetString ( BossError, e.what() );
4436	>	return NULL;
4437		}
4438		}
4439		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3373 | Line 4471 | static PyObject *_wrap_BossTask_declare_
4471		try {
4472		(arg1)->declare(arg2,(std::string const &)*arg3);
4473
4474	+	}catch (const BossSchedFailure & e) {
4475	+	PyErr_SetString ( SchedulerError, e.what() );
4476	+	return NULL;
4477		}catch (const std::exception& e) {
4478	<	SWIG_exception(SWIG_RuntimeError, e.what());
4478	>	PyErr_SetString ( BossError, e.what() );
4479	>	return NULL;
4480		}
4481		}
4482		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3472 | Line 4574 | static PyObject *_wrap_BossTask_remove(P
4574		try {
4575		(arg1)->remove();
4576
4577	+	}catch (const BossSchedFailure & e) {
4578	+	PyErr_SetString ( SchedulerError, e.what() );
4579	+	return NULL;
4580		}catch (const std::exception& e) {
4581	<	SWIG_exception(SWIG_RuntimeError, e.what());
4581	>	PyErr_SetString ( BossError, e.what() );
4582	>	return NULL;
4583		}
4584		}
4585		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3508 | Line 4614 | static PyObject *_wrap_BossTask_archive(
4614		try {
4615		(arg1)->archive((std::string const &)*arg2);
4616
4617	+	}catch (const BossSchedFailure & e) {
4618	+	PyErr_SetString ( SchedulerError, e.what() );
4619	+	return NULL;
4620		}catch (const std::exception& e) {
4621	<	SWIG_exception(SWIG_RuntimeError, e.what());
4621	>	PyErr_SetString ( BossError, e.what() );
4622	>	return NULL;
4623		}
4624		}
4625		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3519 | Line 4629 | static PyObject *_wrap_BossTask_archive(
4629		}
4630
4631
3522	–	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3523	–	PyObject *resultobj;
3524	–	BossTask *arg1 = (BossTask *) 0 ;
3525	–	std::map<std::string,std::string > result;
3526	–	PyObject * obj0 = 0 ;
3527	–
3528	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3529	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3530	–	{
3531	–	try {
3532	–	result = ((BossTask const *)arg1)->taskMap();
3533	–
3534	–	}catch (const std::exception& e) {
3535	–	SWIG_exception(SWIG_RuntimeError, e.what());
3536	–	}
3537	–	}
3538	–	{
3539	–	resultobj = PyDict_New();
3540	–	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3541	–	PyDict_SetItem(resultobj,
3542	–	SwigString_FromString(i->first),
3543	–	SwigString_FromString(i->second));
3544	–	}
3545	–	}
3546	–	return resultobj;
3547	–	fail:
3548	–	return NULL;
3549	–	}
3550	–
3551	–
4632		static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4633		PyObject *resultobj;
4634		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3562 | Line 4642 | static PyObject *_wrap_BossTask_submit(P
4642		std::string *arg5 = (std::string *) &arg5_defvalue ;
4643		std::string const &arg6_defvalue = "" ;
4644		std::string *arg6 = (std::string *) &arg6_defvalue ;
4645	<	bool arg7 = (bool) false ;
4645	>	unsigned int arg7 = (unsigned int) 0 ;
4646	>	bool arg8 = (bool) false ;
4647		int result;
4648		std::string temp2 ;
4649		std::string temp3 ;
#	Line 3576 | Line 4657 | static PyObject *_wrap_BossTask_submit(P
4657		PyObject * obj4 = 0 ;
4658		PyObject * obj5 = 0 ;
4659		PyObject * obj6 = 0 ;
4660	+	PyObject * obj7 = 0 ;
4661
4662	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4662	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4663		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4664		if (obj1) {
4665		{
#	Line 3630 | Line 4712 | static PyObject *_wrap_BossTask_submit(P
4712		}
4713		}
4714		if (obj6) {
4715	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4715	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4716	>	if (PyErr_Occurred()) SWIG_fail;
4717	>	}
4718	>	if (obj7) {
4719	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4720		if (PyErr_Occurred()) SWIG_fail;
4721		}
4722		{
4723		try {
4724	<	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);
4724	>	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);
4725
4726	+	}catch (const BossSchedFailure & e) {
4727	+	PyErr_SetString ( SchedulerError, e.what() );
4728	+	return NULL;
4729		}catch (const std::exception& e) {
4730	<	SWIG_exception(SWIG_RuntimeError, e.what());
4730	>	PyErr_SetString ( BossError, e.what() );
4731	>	return NULL;
4732		}
4733		}
4734		resultobj = PyInt_FromLong((long)result);
#	Line 3677 | Line 4767 | static PyObject *_wrap_BossTask_reSubmit
4767		try {
4768		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4769
4770	+	}catch (const BossSchedFailure & e) {
4771	+	PyErr_SetString ( SchedulerError, e.what() );
4772	+	return NULL;
4773		}catch (const std::exception& e) {
4774	<	SWIG_exception(SWIG_RuntimeError, e.what());
4774	>	PyErr_SetString ( BossError, e.what() );
4775	>	return NULL;
4776		}
4777		}
4778		resultobj = PyInt_FromLong((long)result);
#	Line 3692 | Line 4786 | static PyObject *_wrap_BossTask_kill(PyO
4786		PyObject *resultobj;
4787		BossTask *arg1 = (BossTask *) 0 ;
4788		std::string *arg2 = 0 ;
4789	<	bool arg3 = (bool) false ;
4789	>	unsigned int arg3 = (unsigned int) 0 ;
4790	>	bool arg4 = (bool) false ;
4791		int result;
4792		std::string temp2 ;
4793		PyObject * obj0 = 0 ;
4794		PyObject * obj1 = 0 ;
4795		PyObject * obj2 = 0 ;
4796	+	PyObject * obj3 = 0 ;
4797
4798	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4798	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
4799		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4800		{
4801		if (PyString_Check(obj1)) {
#	Line 3710 | Line 4806 | static PyObject *_wrap_BossTask_kill(PyO
4806		}
4807		}
4808		if (obj2) {
4809	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4809	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
4810	>	if (PyErr_Occurred()) SWIG_fail;
4811	>	}
4812	>	if (obj3) {
4813	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4814		if (PyErr_Occurred()) SWIG_fail;
4815		}
4816		{
4817		try {
4818	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4818	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
4819
4820	+	}catch (const BossSchedFailure & e) {
4821	+	PyErr_SetString ( SchedulerError, e.what() );
4822	+	return NULL;
4823		}catch (const std::exception& e) {
4824	<	SWIG_exception(SWIG_RuntimeError, e.what());
4824	>	PyErr_SetString ( BossError, e.what() );
4825	>	return NULL;
4826		}
4827		}
4828		resultobj = PyInt_FromLong((long)result);
#	Line 3728 | Line 4832 | static PyObject *_wrap_BossTask_kill(PyO
4832		}
4833
4834
4835	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
4835	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4836		PyObject *resultobj;
4837		BossTask *arg1 = (BossTask *) 0 ;
4838		std::string const &arg2_defvalue = "all" ;
4839		std::string *arg2 = (std::string *) &arg2_defvalue ;
4840		std::string const &arg3_defvalue = "" ;
4841		std::string *arg3 = (std::string *) &arg3_defvalue ;
4842	<	bool arg4 = (bool) false ;
4842	>	unsigned int arg4 = (unsigned int) 0 ;
4843		bool arg5 = (bool) false ;
4844	+	bool arg6 = (bool) false ;
4845		int result;
4846		std::string temp2 ;
4847		std::string temp3 ;
#	Line 3745 | Line 4850 | static PyObject *_wrap_BossTask_getOutpu
4850		PyObject * obj2 = 0 ;
4851		PyObject * obj3 = 0 ;
4852		PyObject * obj4 = 0 ;
4853	+	PyObject * obj5 = 0 ;
4854
4855	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4855	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
4856		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4857		if (obj1) {
4858		{
#	Line 3769 | Line 4875 | static PyObject *_wrap_BossTask_getOutpu
4875		}
4876		}
4877		if (obj3) {
4878	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4878	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
4879		if (PyErr_Occurred()) SWIG_fail;
4880		}
4881		if (obj4) {
4882		arg5 = PyInt_AsLong(obj4) ? true : false;
4883		if (PyErr_Occurred()) SWIG_fail;
4884		}
4885	+	if (obj5) {
4886	+	arg6 = PyInt_AsLong(obj5) ? true : false;
4887	+	if (PyErr_Occurred()) SWIG_fail;
4888	+	}
4889		{
4890		try {
4891	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4891	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
4892
4893	+	}catch (const BossSchedFailure & e) {
4894	+	PyErr_SetString ( SchedulerError, e.what() );
4895	+	return NULL;
4896		}catch (const std::exception& e) {
4897	<	SWIG_exception(SWIG_RuntimeError, e.what());
4897	>	PyErr_SetString ( BossError, e.what() );
4898	>	return NULL;
4899		}
4900		}
4901		resultobj = PyInt_FromLong((long)result);
#	Line 3791 | Line 4905 | static PyObject *_wrap_BossTask_getOutpu
4905		}
4906
4907
4908	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
4908	>	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4909		PyObject *resultobj;
4910		BossTask *arg1 = (BossTask *) 0 ;
4911	<	std::string const &arg2_defvalue = "" ;
4912	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
4913	<	bool arg3 = (bool) false ;
4914	<	bool arg4 = (bool) false ;
4911	>	int arg2 = (int) SCHEDULED ;
4912	>	std::string const &arg3_defvalue = "all" ;
4913	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4914	>	std::string const &arg4_defvalue = "" ;
4915	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4916	>	std::string arg5 = (std::string) "" ;
4917	>	std::string arg6 = (std::string) "" ;
4918	>	std::string arg7 = (std::string) "" ;
4919	>	std::string arg8 = (std::string) "" ;
4920		int result;
4921	<	std::string temp2 ;
4921	>	std::string temp3 ;
4922	>	std::string temp4 ;
4923		PyObject * obj0 = 0 ;
3804	–	PyObject * obj1 = 0 ;
4924		PyObject * obj2 = 0 ;
4925		PyObject * obj3 = 0 ;
4926	+	PyObject * obj4 = 0 ;
4927	+	PyObject * obj5 = 0 ;
4928	+	PyObject * obj6 = 0 ;
4929	+	PyObject * obj7 = 0 ;
4930
4931	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4931	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4932		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4933	<	if (obj1) {
4933	>	if (obj2) {
4934		{
4935	<	if (PyString_Check(obj1)) {
4936	<	temp2 = std::string(PyString_AsString(obj1));
4937	<	arg2 = &temp2;
4935	>	if (PyString_Check(obj2)) {
4936	>	temp3 = std::string(PyString_AsString(obj2));
4937	>	arg3 = &temp3;
4938		}else {
4939		SWIG_exception(SWIG_TypeError, "string expected");
4940		}
4941		}
4942		}
3820	–	if (obj2) {
3821	–	arg3 = PyInt_AsLong(obj2) ? true : false;
3822	–	if (PyErr_Occurred()) SWIG_fail;
3823	–	}
4943		if (obj3) {
4944	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4945	<	if (PyErr_Occurred()) SWIG_fail;
4946	<	}
4947	<	{
4948	<	try {
4949	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
4950	<
3832	<	}catch (const std::exception& e) {
3833	<	SWIG_exception(SWIG_RuntimeError, e.what());
4944	>	{
4945	>	if (PyString_Check(obj3)) {
4946	>	temp4 = std::string(PyString_AsString(obj3));
4947	>	arg4 = &temp4;
4948	>	}else {
4949	>	SWIG_exception(SWIG_TypeError, "string expected");
4950	>	}
4951		}
4952		}
4953	<	resultobj = PyInt_FromLong((long)result);
4954	<	return resultobj;
4955	<	fail:
4956	<	return NULL;
4957	<	}
4958	<
4959	<
3843	<	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
3844	<	int argc;
3845	<	PyObject *argv[6];
3846	<	int ii;
3847	<
3848	<	argc = PyObject_Length(args);
3849	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
3850	<	argv[ii] = PyTuple_GetItem(args,ii);
4953	>	if (obj4) {
4954	>	{
4955	>	if (PyString_Check(obj4))
4956	>	arg5 = std::string(PyString_AsString(obj4));
4957	>	else
4958	>	SWIG_exception(SWIG_TypeError, "string expected");
4959	>	}
4960		}
4961	<	if ((argc >= 1) && (argc <= 5)) {
3853	<	int _v;
4961	>	if (obj5) {
4962		{
4963	<	void *ptr;
4964	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4965	<	_v = 0;
4966	<	PyErr_Clear();
3859	<	}else {
3860	<	_v = 1;
3861	<	}
4963	>	if (PyString_Check(obj5))
4964	>	arg6 = std::string(PyString_AsString(obj5));
4965	>	else
4966	>	SWIG_exception(SWIG_TypeError, "string expected");
4967		}
4968	<	if (_v) {
4969	<	if (argc <= 1) {
4970	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4971	<	}
4972	<	{
4973	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4974	<	}
3870	<	if (_v) {
3871	<	if (argc <= 2) {
3872	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
3873	<	}
3874	<	{
3875	<	_v = PyString_Check(argv[2]) ? 1 : 0;
3876	<	}
3877	<	if (_v) {
3878	<	if (argc <= 3) {
3879	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
3880	<	}
3881	<	{
3882	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
3883	<	}
3884	<	if (_v) {
3885	<	if (argc <= 4) {
3886	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
3887	<	}
3888	<	{
3889	<	_v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
3890	<	}
3891	<	if (_v) {
3892	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
3893	<	}
3894	<	}
3895	<	}
3896	<	}
4968	>	}
4969	>	if (obj6) {
4970	>	{
4971	>	if (PyString_Check(obj6))
4972	>	arg7 = std::string(PyString_AsString(obj6));
4973	>	else
4974	>	SWIG_exception(SWIG_TypeError, "string expected");
4975		}
4976		}
4977	<	if ((argc >= 1) && (argc <= 4)) {
3900	<	int _v;
4977	>	if (obj7) {
4978		{
4979	<	void *ptr;
4980	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4981	<	_v = 0;
4982	<	PyErr_Clear();
3906	<	}else {
3907	<	_v = 1;
3908	<	}
4979	>	if (PyString_Check(obj7))
4980	>	arg8 = std::string(PyString_AsString(obj7));
4981	>	else
4982	>	SWIG_exception(SWIG_TypeError, "string expected");
4983		}
4984	<	if (_v) {
4985	<	if (argc <= 1) {
4986	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4987	<	}
4988	<	{
4989	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4990	<	}
4991	<	if (_v) {
4992	<	if (argc <= 2) {
4993	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4994	<	}
3921	<	{
3922	<	_v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
3923	<	}
3924	<	if (_v) {
3925	<	if (argc <= 3) {
3926	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
3927	<	}
3928	<	{
3929	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
3930	<	}
3931	<	if (_v) {
3932	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
3933	<	}
3934	<	}
3935	<	}
4984	>	}
4985	>	{
4986	>	try {
4987	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4988	>
4989	>	}catch (const BossSchedFailure & e) {
4990	>	PyErr_SetString ( SchedulerError, e.what() );
4991	>	return NULL;
4992	>	}catch (const std::exception& e) {
4993	>	PyErr_SetString ( BossError, e.what() );
4994	>	return NULL;
4995		}
4996		}
4997	<
4998	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
4997	>	resultobj = PyInt_FromLong((long)result);
4998	>	return resultobj;
4999	>	fail:
5000		return NULL;
5001		}
5002
#	Line 3953 | Line 5013 | static PyObject *_wrap_BossTask_query(Py
5013		std::string arg6 = (std::string) "" ;
5014		std::string arg7 = (std::string) "" ;
5015		std::string arg8 = (std::string) "" ;
5016	<	bool arg9 = (bool) false ;
5016	>	unsigned int arg9 = (unsigned int) 0 ;
5017	>	bool arg10 = (bool) false ;
5018		int result;
5019		std::string temp3 ;
5020		std::string temp4 ;
#	Line 3965 | Line 5026 | static PyObject *_wrap_BossTask_query(Py
5026		PyObject * obj6 = 0 ;
5027		PyObject * obj7 = 0 ;
5028		PyObject * obj8 = 0 ;
5029	+	PyObject * obj9 = 0 ;
5030
5031	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5031	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5032		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5033		if (obj2) {
5034		{
#	Line 4021 | Line 5083 | static PyObject *_wrap_BossTask_query(Py
5083		}
5084		}
5085		if (obj8) {
5086	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5086	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5087	>	if (PyErr_Occurred()) SWIG_fail;
5088	>	}
5089	>	if (obj9) {
5090	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5091		if (PyErr_Occurred()) SWIG_fail;
5092		}
5093		{
5094		try {
5095	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5095	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5096
5097	+	}catch (const BossSchedFailure & e) {
5098	+	PyErr_SetString ( SchedulerError, e.what() );
5099	+	return NULL;
5100		}catch (const std::exception& e) {
5101	<	SWIG_exception(SWIG_RuntimeError, e.what());
5101	>	PyErr_SetString ( BossError, e.what() );
5102	>	return NULL;
5103		}
5104		}
5105		resultobj = PyInt_FromLong((long)result);
#	Line 4087 | Line 5157 | static PyObject *_wrap_BossTask_query_ou
5157		try {
5158		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5159
5160	+	}catch (const BossSchedFailure & e) {
5161	+	PyErr_SetString ( SchedulerError, e.what() );
5162	+	return NULL;
5163		}catch (const std::exception& e) {
5164	<	SWIG_exception(SWIG_RuntimeError, e.what());
5164	>	PyErr_SetString ( BossError, e.what() );
5165	>	return NULL;
5166		}
5167		}
5168		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4109 | Line 5183 | static PyObject *_wrap_BossTask_clear(Py
5183		try {
5184		(arg1)->clear();
5185
5186	+	}catch (const BossSchedFailure & e) {
5187	+	PyErr_SetString ( SchedulerError, e.what() );
5188	+	return NULL;
5189		}catch (const std::exception& e) {
5190	<	SWIG_exception(SWIG_RuntimeError, e.what());
5190	>	PyErr_SetString ( BossError, e.what() );
5191	>	return NULL;
5192		}
5193		}
5194		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4120 | Line 5198 | static PyObject *_wrap_BossTask_clear(Py
5198		}
5199
5200
5201	<	static PyObject *_wrap_BossTask_prompt(PyObject *self, PyObject *args) {
5201	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5202	>	PyObject *resultobj;
5203	>	BossTask *arg1 = (BossTask *) 0 ;
5204	>	PyObject *arg2 = (PyObject *) 0 ;
5205	>	BossAttributeContainer *arg3 = 0 ;
5206	>	PyObject *result;
5207	>	PyObject * obj0 = 0 ;
5208	>	PyObject * obj1 = 0 ;
5209	>	PyObject * obj2 = 0 ;
5210	>
5211	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5212	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5213	>	arg2 = obj1;
5214	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5215	>	if (arg3 == NULL) {
5216	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5217	>	}
5218	>	{
5219	>	try {
5220	>	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5221	>
5222	>	}catch (const BossSchedFailure & e) {
5223	>	PyErr_SetString ( SchedulerError, e.what() );
5224	>	return NULL;
5225	>	}catch (const std::exception& e) {
5226	>	PyErr_SetString ( BossError, e.what() );
5227	>	return NULL;
5228	>	}
5229	>	}
5230	>	resultobj = result;
5231	>	return resultobj;
5232	>	fail:
5233	>	return NULL;
5234	>	}
5235	>
5236	>
5237	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5238	>	PyObject *resultobj;
5239	>	BossTask *arg1 = (BossTask *) 0 ;
5240	>	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5241	>	PyObject *result;
5242	>	PyObject * obj0 = 0 ;
5243	>	PyObject * obj1 = 0 ;
5244	>
5245	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5246	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5247	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5248	>	if (arg2 == NULL) {
5249	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5250	>	}
5251	>	{
5252	>	try {
5253	>	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5254	>
5255	>	}catch (const BossSchedFailure & e) {
5256	>	PyErr_SetString ( SchedulerError, e.what() );
5257	>	return NULL;
5258	>	}catch (const std::exception& e) {
5259	>	PyErr_SetString ( BossError, e.what() );
5260	>	return NULL;
5261	>	}
5262	>	}
5263	>	resultobj = result;
5264	>	return resultobj;
5265	>	fail:
5266	>	return NULL;
5267	>	}
5268	>
5269	>
5270	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5271	>	PyObject *resultobj;
5272	>	BossTask *arg1 = (BossTask *) 0 ;
5273	>	PyObject *result;
5274	>	PyObject * obj0 = 0 ;
5275	>
5276	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5277	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5278	>	{
5279	>	try {
5280	>	result = (PyObject *)BossTask_jobsDict(arg1);
5281	>
5282	>	}catch (const BossSchedFailure & e) {
5283	>	PyErr_SetString ( SchedulerError, e.what() );
5284	>	return NULL;
5285	>	}catch (const std::exception& e) {
5286	>	PyErr_SetString ( BossError, e.what() );
5287	>	return NULL;
5288	>	}
5289	>	}
5290	>	resultobj = result;
5291	>	return resultobj;
5292	>	fail:
5293	>	return NULL;
5294	>	}
5295	>
5296	>
5297	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5298	>	PyObject *resultobj;
5299	>	BossTask *arg1 = (BossTask *) 0 ;
5300	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5301	>	PyObject *result;
5302	>	PyObject * obj0 = 0 ;
5303	>	PyObject * obj1 = 0 ;
5304	>
5305	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5306	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5307	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5308	>	if (arg2 == NULL) {
5309	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5310	>	}
5311	>	{
5312	>	try {
5313	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5314	>
5315	>	}catch (const BossSchedFailure & e) {
5316	>	PyErr_SetString ( SchedulerError, e.what() );
5317	>	return NULL;
5318	>	}catch (const std::exception& e) {
5319	>	PyErr_SetString ( BossError, e.what() );
5320	>	return NULL;
5321	>	}
5322	>	}
5323	>	resultobj = result;
5324	>	return resultobj;
5325	>	fail:
5326	>	return NULL;
5327	>	}
5328	>
5329	>
5330	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5331		PyObject *resultobj;
5332		BossTask *arg1 = (BossTask *) 0 ;
5333		std::string *arg2 = 0 ;
5334	<	bool result;
5334	>	PyObject *result;
5335		std::string temp2 ;
5336		PyObject * obj0 = 0 ;
5337		PyObject * obj1 = 0 ;
5338
5339	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_prompt",&obj0,&obj1)) goto fail;
5339	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5340		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5341		{
5342		if (PyString_Check(obj1)) {
#	Line 4141 | Line 5348 | static PyObject *_wrap_BossTask_prompt(P
5348		}
5349		{
5350		try {
5351	<	result = (bool)(arg1)->prompt((std::string const &)*arg2);
5351	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5352
5353	+	}catch (const BossSchedFailure & e) {
5354	+	PyErr_SetString ( SchedulerError, e.what() );
5355	+	return NULL;
5356		}catch (const std::exception& e) {
5357	<	SWIG_exception(SWIG_RuntimeError, e.what());
5357	>	PyErr_SetString ( BossError, e.what() );
5358	>	return NULL;
5359		}
5360		}
5361	<	resultobj = PyInt_FromLong((long)result);
5361	>	resultobj = result;
5362		return resultobj;
5363		fail:
5364		return NULL;
#	Line 4164 | Line 5375 | static PyObject * BossTask_swigregister(
5375		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5376		PyObject *resultobj;
5377		std::string arg1 = (std::string) "" ;
5378	<	bool arg2 = (bool) false ;
5378	>	std::string arg2 = (std::string) "2" ;
5379	>	std::string arg3 = (std::string) "" ;
5380	>	std::string arg4 = (std::string) "" ;
5381	>	bool arg5 = (bool) false ;
5382		BossAdministratorSession *result;
5383		PyObject * obj0 = 0 ;
5384		PyObject * obj1 = 0 ;
5385	+	PyObject * obj2 = 0 ;
5386	+	PyObject * obj3 = 0 ;
5387	+	PyObject * obj4 = 0 ;
5388
5389	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
5389	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5390		if (obj0) {
5391		{
5392		if (PyString_Check(obj0))
#	Line 4179 | Line 5396 | static PyObject *_wrap_new_BossAdministr
5396		}
5397		}
5398		if (obj1) {
5399	<	arg2 = PyInt_AsLong(obj1) ? true : false;
5399	>	{
5400	>	if (PyString_Check(obj1))
5401	>	arg2 = std::string(PyString_AsString(obj1));
5402	>	else
5403	>	SWIG_exception(SWIG_TypeError, "string expected");
5404	>	}
5405	>	}
5406	>	if (obj2) {
5407	>	{
5408	>	if (PyString_Check(obj2))
5409	>	arg3 = std::string(PyString_AsString(obj2));
5410	>	else
5411	>	SWIG_exception(SWIG_TypeError, "string expected");
5412	>	}
5413	>	}
5414	>	if (obj3) {
5415	>	{
5416	>	if (PyString_Check(obj3))
5417	>	arg4 = std::string(PyString_AsString(obj3));
5418	>	else
5419	>	SWIG_exception(SWIG_TypeError, "string expected");
5420	>	}
5421	>	}
5422	>	if (obj4) {
5423	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5424		if (PyErr_Occurred()) SWIG_fail;
5425		}
5426		{
5427		try {
5428	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
5428	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5429
5430	+	}catch (const BossSchedFailure & e) {
5431	+	PyErr_SetString ( SchedulerError, e.what() );
5432	+	return NULL;
5433		}catch (const std::exception& e) {
5434	<	SWIG_exception(SWIG_RuntimeError, e.what());
5434	>	PyErr_SetString ( BossError, e.what() );
5435	>	return NULL;
5436		}
5437		}
5438		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4208 | Line 5453 | static PyObject *_wrap_delete_BossAdmini
5453		try {
5454		delete arg1;
5455
5456	+	}catch (const BossSchedFailure & e) {
5457	+	PyErr_SetString ( SchedulerError, e.what() );
5458	+	return NULL;
5459		}catch (const std::exception& e) {
5460	<	SWIG_exception(SWIG_RuntimeError, e.what());
5460	>	PyErr_SetString ( BossError, e.what() );
5461	>	return NULL;
5462		}
5463		}
5464		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4219 | Line 5468 | static PyObject *_wrap_delete_BossAdmini
5468		}
5469
5470
5471	+	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
5472	+	PyObject *resultobj;
5473	+	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5474	+	int result;
5475	+	PyObject * obj0 = 0 ;
5476	+
5477	+	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
5478	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5479	+	{
5480	+	try {
5481	+	result = (int)(arg1)->configureDB();
5482	+
5483	+	}catch (const BossSchedFailure & e) {
5484	+	PyErr_SetString ( SchedulerError, e.what() );
5485	+	return NULL;
5486	+	}catch (const std::exception& e) {
5487	+	PyErr_SetString ( BossError, e.what() );
5488	+	return NULL;
5489	+	}
5490	+	}
5491	+	resultobj = PyInt_FromLong((long)result);
5492	+	return resultobj;
5493	+	fail:
5494	+	return NULL;
5495	+	}
5496	+
5497	+
5498		static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
5499		PyObject *resultobj;
5500		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
#	Line 4242 | Line 5518 | static PyObject *_wrap_BossAdministrator
5518		try {
5519		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5520
5521	+	}catch (const BossSchedFailure & e) {
5522	+	PyErr_SetString ( SchedulerError, e.what() );
5523	+	return NULL;
5524		}catch (const std::exception& e) {
5525	<	SWIG_exception(SWIG_RuntimeError, e.what());
5525	>	PyErr_SetString ( BossError, e.what() );
5526	>	return NULL;
5527		}
5528		}
5529		resultobj = PyInt_FromLong((long)result);
#	Line 4276 | Line 5556 | static PyObject *_wrap_BossAdministrator
5556		try {
5557		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5558
5559	+	}catch (const BossSchedFailure & e) {
5560	+	PyErr_SetString ( SchedulerError, e.what() );
5561	+	return NULL;
5562		}catch (const std::exception& e) {
5563	<	SWIG_exception(SWIG_RuntimeError, e.what());
5563	>	PyErr_SetString ( BossError, e.what() );
5564	>	return NULL;
5565		}
5566		}
5567		resultobj = PyInt_FromLong((long)result);
#	Line 4310 | Line 5594 | static PyObject *_wrap_BossAdministrator
5594		try {
5595		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5596
5597	+	}catch (const BossSchedFailure & e) {
5598	+	PyErr_SetString ( SchedulerError, e.what() );
5599	+	return NULL;
5600		}catch (const std::exception& e) {
5601	<	SWIG_exception(SWIG_RuntimeError, e.what());
5601	>	PyErr_SetString ( BossError, e.what() );
5602	>	return NULL;
5603		}
5604		}
5605		resultobj = PyInt_FromLong((long)result);
#	Line 4344 | Line 5632 | static PyObject *_wrap_BossAdministrator
5632		try {
5633		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5634
5635	+	}catch (const BossSchedFailure & e) {
5636	+	PyErr_SetString ( SchedulerError, e.what() );
5637	+	return NULL;
5638		}catch (const std::exception& e) {
5639	<	SWIG_exception(SWIG_RuntimeError, e.what());
5639	>	PyErr_SetString ( BossError, e.what() );
5640	>	return NULL;
5641		}
5642		}
5643		resultobj = PyInt_FromLong((long)result);
#	Line 4378 | Line 5670 | static PyObject *_wrap_BossAdministrator
5670		try {
5671		result = (int)(arg1)->deleteScheduler((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);
#	Line 4444 | Line 5740 | static PyObject *_wrap_BossAdministrator
5740		try {
5741		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5742
5743	+	}catch (const BossSchedFailure & e) {
5744	+	PyErr_SetString ( SchedulerError, e.what() );
5745	+	return NULL;
5746		}catch (const std::exception& e) {
5747	<	SWIG_exception(SWIG_RuntimeError, e.what());
5747	>	PyErr_SetString ( BossError, e.what() );
5748	>	return NULL;
5749		}
5750		}
5751		resultobj = PyInt_FromLong((long)result);
#	Line 4534 | Line 5834 | static PyObject *_wrap_BossAdministrator
5834		try {
5835		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5836
5837	+	}catch (const BossSchedFailure & e) {
5838	+	PyErr_SetString ( SchedulerError, e.what() );
5839	+	return NULL;
5840		}catch (const std::exception& e) {
5841	<	SWIG_exception(SWIG_RuntimeError, e.what());
5841	>	PyErr_SetString ( BossError, e.what() );
5842	>	return NULL;
5843		}
5844		}
5845		resultobj = PyInt_FromLong((long)result);
#	Line 4610 | Line 5914 | static PyObject *_wrap_BossAdministrator
5914		try {
5915		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5916
5917	+	}catch (const BossSchedFailure & e) {
5918	+	PyErr_SetString ( SchedulerError, e.what() );
5919	+	return NULL;
5920		}catch (const std::exception& e) {
5921	<	SWIG_exception(SWIG_RuntimeError, e.what());
5921	>	PyErr_SetString ( BossError, e.what() );
5922	>	return NULL;
5923		}
5924		}
5925		resultobj = PyInt_FromLong((long)result);
#	Line 4639 | Line 5947 | static PyObject *_wrap_BossAdministrator
5947		std::string arg13 = (std::string) "" ;
5948		bool arg14 = (bool) false ;
5949		bool arg15 = (bool) false ;
5950	+	bool arg16 = (bool) false ;
5951	+	bool arg17 = (bool) false ;
5952		int result;
5953		std::string temp2 ;
5954		std::string temp11 ;
#	Line 4657 | Line 5967 | static PyObject *_wrap_BossAdministrator
5967		PyObject * obj12 = 0 ;
5968		PyObject * obj13 = 0 ;
5969		PyObject * obj14 = 0 ;
5970	+	PyObject * obj15 = 0 ;
5971	+	PyObject * obj16 = 0 ;
5972
5973	<	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;
5973	>	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;
5974		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5975		{
5976		if (PyString_Check(obj1)) {
#	Line 4766 | Line 6078 | static PyObject *_wrap_BossAdministrator
6078		arg15 = PyInt_AsLong(obj14) ? true : false;
6079		if (PyErr_Occurred()) SWIG_fail;
6080		}
6081	+	if (obj15) {
6082	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6083	+	if (PyErr_Occurred()) SWIG_fail;
6084	+	}
6085	+	if (obj16) {
6086	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6087	+	if (PyErr_Occurred()) SWIG_fail;
6088	+	}
6089		{
6090		try {
6091	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
6091	>	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);
6092
6093	+	}catch (const BossSchedFailure & e) {
6094	+	PyErr_SetString ( SchedulerError, e.what() );
6095	+	return NULL;
6096		}catch (const std::exception& e) {
6097	<	SWIG_exception(SWIG_RuntimeError, e.what());
6097	>	PyErr_SetString ( BossError, e.what() );
6098	>	return NULL;
6099		}
6100		}
6101		resultobj = PyInt_FromLong((long)result);
#	Line 4793 | Line 6117 | static PyObject *_wrap_BossAdministrator
6117		try {
6118		result = (arg1)->help();
6119
6120	+	}catch (const BossSchedFailure & e) {
6121	+	PyErr_SetString ( SchedulerError, e.what() );
6122	+	return NULL;
6123		}catch (const std::exception& e) {
6124	<	SWIG_exception(SWIG_RuntimeError, e.what());
6124	>	PyErr_SetString ( BossError, e.what() );
6125	>	return NULL;
6126		}
6127		}
6128		{
#	Line 4806 | Line 6134 | static PyObject *_wrap_BossAdministrator
6134		}
6135
6136
6137	<	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
6137	>	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6138		PyObject *resultobj;
6139		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6140	<	std::string *arg2 = 0 ;
6140	>	std::string arg2 ;
6141	>	bool arg3 = (bool) false ;
6142		std::string result;
6143		PyObject * obj0 = 0 ;
6144		PyObject * obj1 = 0 ;
6145	+	PyObject * obj2 = 0 ;
6146
6147	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureDB",&obj0,&obj1)) goto fail;
6147	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
6148		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6149	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6150	<	if (arg2 == NULL) {
6151	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6149	>	{
6150	>	if (PyString_Check(obj1))
6151	>	arg2 = std::string(PyString_AsString(obj1));
6152	>	else
6153	>	SWIG_exception(SWIG_TypeError, "string expected");
6154	>	}
6155	>	if (obj2) {
6156	>	arg3 = PyInt_AsLong(obj2) ? true : false;
6157	>	if (PyErr_Occurred()) SWIG_fail;
6158		}
6159		{
6160		try {
6161	<	result = (arg1)->configureDB(*arg2);
6161	>	result = (arg1)->SQL(arg2,arg3);
6162
6163	+	}catch (const BossSchedFailure & e) {
6164	+	PyErr_SetString ( SchedulerError, e.what() );
6165	+	return NULL;
6166		}catch (const std::exception& e) {
6167	<	SWIG_exception(SWIG_RuntimeError, e.what());
6167	>	PyErr_SetString ( BossError, e.what() );
6168	>	return NULL;
6169		}
6170		}
6171		{
#	Line 4837 | Line 6177 | static PyObject *_wrap_BossAdministrator
6177		}
6178
6179
6180	<	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6180	>	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
6181		PyObject *resultobj;
6182		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6183		std::string *arg2 = 0 ;
6184	<	bool arg3 = (bool) false ;
6185	<	std::string result;
6184	>	std::string *arg3 = 0 ;
6185	>	std::string *arg4 = 0 ;
6186	>	std::string const &arg5_defvalue = "0" ;
6187	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
6188	>	int result;
6189	>	std::string temp2 ;
6190	>	std::string temp3 ;
6191	>	std::string temp4 ;
6192	>	std::string temp5 ;
6193		PyObject * obj0 = 0 ;
6194		PyObject * obj1 = 0 ;
6195		PyObject * obj2 = 0 ;
6196	+	PyObject * obj3 = 0 ;
6197	+	PyObject * obj4 = 0 ;
6198
6199	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
6199	>	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6200		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6201	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6202	<	if (arg2 == NULL) {
6203	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6201	>	{
6202	>	if (PyString_Check(obj1)) {
6203	>	temp2 = std::string(PyString_AsString(obj1));
6204	>	arg2 = &temp2;
6205	>	}else {
6206	>	SWIG_exception(SWIG_TypeError, "string expected");
6207	>	}
6208		}
6209	<	if (obj2) {
6210	<	arg3 = PyInt_AsLong(obj2) ? true : false;
6211	<	if (PyErr_Occurred()) SWIG_fail;
6209	>	{
6210	>	if (PyString_Check(obj2)) {
6211	>	temp3 = std::string(PyString_AsString(obj2));
6212	>	arg3 = &temp3;
6213	>	}else {
6214	>	SWIG_exception(SWIG_TypeError, "string expected");
6215	>	}
6216	>	}
6217	>	{
6218	>	if (PyString_Check(obj3)) {
6219	>	temp4 = std::string(PyString_AsString(obj3));
6220	>	arg4 = &temp4;
6221	>	}else {
6222	>	SWIG_exception(SWIG_TypeError, "string expected");
6223	>	}
6224	>	}
6225	>	if (obj4) {
6226	>	{
6227	>	if (PyString_Check(obj4)) {
6228	>	temp5 = std::string(PyString_AsString(obj4));
6229	>	arg5 = &temp5;
6230	>	}else {
6231	>	SWIG_exception(SWIG_TypeError, "string expected");
6232	>	}
6233	>	}
6234		}
6235		{
6236		try {
6237	<	result = (arg1)->SQL(*arg2,arg3);
6237	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6238
6239	+	}catch (const BossSchedFailure & e) {
6240	+	PyErr_SetString ( SchedulerError, e.what() );
6241	+	return NULL;
6242		}catch (const std::exception& e) {
6243	<	SWIG_exception(SWIG_RuntimeError, e.what());
6243	>	PyErr_SetString ( BossError, e.what() );
6244	>	return NULL;
6245		}
6246		}
6247	<	{
4869	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4870	<	}
6247	>	resultobj = PyInt_FromLong((long)result);
6248		return resultobj;
6249		fail:
6250		return NULL;
6251		}
6252
6253
6254	<	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
6254	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
6255		PyObject *resultobj;
6256		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6257	<	std::string *arg2 = 0 ;
6258	<	std::string result;
6257	>	std::string arg2 ;
6258	>	int result;
6259		PyObject * obj0 = 0 ;
6260		PyObject * obj1 = 0 ;
6261
6262	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_purge",&obj0,&obj1)) goto fail;
6262	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6263		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6264	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6265	<	if (arg2 == NULL) {
6266	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6264	>	{
6265	>	if (PyString_Check(obj1))
6266	>	arg2 = std::string(PyString_AsString(obj1));
6267	>	else
6268	>	SWIG_exception(SWIG_TypeError, "string expected");
6269		}
6270		{
6271		try {
6272	<	result = (arg1)->purge(*arg2);
6272	>	result = (int)(arg1)->registerPlugins(arg2);
6273
6274	+	}catch (const BossSchedFailure & e) {
6275	+	PyErr_SetString ( SchedulerError, e.what() );
6276	+	return NULL;
6277		}catch (const std::exception& e) {
6278	<	SWIG_exception(SWIG_RuntimeError, e.what());
6278	>	PyErr_SetString ( BossError, e.what() );
6279	>	return NULL;
6280		}
6281		}
6282	<	{
4900	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4901	<	}
6282	>	resultobj = PyInt_FromLong((long)result);
6283		return resultobj;
6284		fail:
6285		return NULL;
#	Line 4928 | Line 6309 | static PyMethodDef SwigMethods[] = {
6309		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6310		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6311		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6312	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6312	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6313	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6314	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6315	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6316	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6317	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6318	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6319	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6320	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6321	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6322	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6323	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6324	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6325	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6326		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6327		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6328	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6329	+	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6330		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6331		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6332	<	{ (char *)"BossSession_BossShowCHTools", _wrap_BossSession_BossShowCHTools, METH_VARARGS },
6333	<	{ (char *)"BossSession_BossShowProgramTypes", _wrap_BossSession_BossShowProgramTypes, METH_VARARGS },
6334	<	{ (char *)"BossSession_BossShowRTMon", _wrap_BossSession_BossShowRTMon, METH_VARARGS },
6335	<	{ (char *)"BossSession_BossShowSchedulers", _wrap_BossSession_BossShowSchedulers, METH_VARARGS },
6336	<	{ (char *)"BossSession_BossDefaultCHTool", _wrap_BossSession_BossDefaultCHTool, METH_VARARGS },
6337	<	{ (char *)"BossSession_BossDefaultProgramType", _wrap_BossSession_BossDefaultProgramType, METH_VARARGS },
6338	<	{ (char *)"BossSession_BossDefaultRTMon", _wrap_BossSession_BossDefaultRTMon, METH_VARARGS },
6339	<	{ (char *)"BossSession_BossDefaultScheduler", _wrap_BossSession_BossDefaultScheduler, METH_VARARGS },
6340	<	{ (char *)"BossSession_BossVersion", _wrap_BossSession_BossVersion, METH_VARARGS },
6341	<	{ (char *)"BossSession_BossClientID", _wrap_BossSession_BossClientID, METH_VARARGS },
6332	>	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6333	>	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6334	>	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6335	>	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6336	>	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6337	>	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6338	>	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
6339	>	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS },
6340	>	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
6341	>	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
6342		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
6343	<	{ (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
6344	<	{ (char *)"BossSession_BossRTupdate", _wrap_BossSession_BossRTupdate, METH_VARARGS },
6345	<	{ (char *)"BossSession_BossListMatch", _wrap_BossSession_BossListMatch, METH_VARARGS },
4950	<	{ (char *)"BossSession_jobQuery", _wrap_BossSession_jobQuery, METH_VARARGS },
4951	<	{ (char *)"BossSession_queryPrint", _wrap_BossSession_queryPrint, METH_VARARGS },
6343	>	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6344	>	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6345	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6346		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6347	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6348	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6349	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6350	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6351	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6352	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6353	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6354	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6355		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6356		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6357		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 4957 | Line 6359 | static PyMethodDef SwigMethods[] = {
6359		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6360		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6361		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
4960	–	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
4961	–	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
4962	–	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
4963	–	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6362		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6363		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6364		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
6365		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
6366	<	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6366	>	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6367		{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6368		{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6369	<	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6369	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
6370	>	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6371		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6372	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6373		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
6374		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
6375		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
4976	–	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6376		{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
6377		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6378		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6379		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6380	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6381		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6382		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6383		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6384	<	{ (char *)"BossTask_prompt", _wrap_BossTask_prompt, METH_VARARGS },
6384	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6385	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6386	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6387	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6388	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6389		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6390		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6391		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
6392	+	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
6393		{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
6394		{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
6395		{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
#	Line 4995 | Line 6400 | static PyMethodDef SwigMethods[] = {
6400		{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
6401		{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
6402		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
4998	–	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
6403		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
6404		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
6405	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
6406		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
6407		{ NULL, NULL }
6408		};
#	Line 5005 | Line 6410 | static PyMethodDef SwigMethods[] = {
6410
6411		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6412
5008	–	static swig_type_info _swigt__p_std__vectorTBossJob_p_t[] = {{"_p_std__vectorTBossJob_p_t", 0, "std::vector<BossJob * > *", 0},{"_p_std__vectorTBossJob_p_t"},{0}};
5009	–	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}};
5010	–	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}};
6413		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6414	+	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}};
6415	+	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}};
6416	+	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}};
6417		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}};
6418		static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6419		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6420		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5016	–	static swig_type_info _swigt__p_std__string[] = {{"_p_std__string", 0, "std::string *", 0},{"_p_std__string"},{0}};
6421		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6422	<	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6422	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6423		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6424	+	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6425		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6426		static swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0},{"_p_std__vectorTstd__string_t"},{0}};
6427		static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
6428		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5024	–	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
5025	–	static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
6429		static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
6430	+	static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
6431	+	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6432
6433		static swig_type_info *swig_types_initial[] = {
5029	–	_swigt__p_std__vectorTBossJob_p_t,
5030	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
5031	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6434		_swigt__p_XMLDoc,
6435	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6436	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6437	+	_swigt__p_std__vectorTBossTask_p_t,
6438		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6439		_swigt__p_std__ostream,
6440		_swigt__p_BossTask,
6441		_swigt__p_BossTaskException,
5037	–	_swigt__p_std__string,
6442		_swigt__p_printOption,
6443	<	_swigt__p_BossDatabase,
6443	>	_swigt__p_BossAttributeContainer,
6444		_swigt__p_BossJob,
6445	+	_swigt__p_BossDatabase,
6446		_swigt__p_BossSession,
6447		_swigt__p_std__vectorTstd__string_t,
6448		_swigt__p_std__mapTstd__string_std__string_t,
6449		_swigt__p_BossAdministratorSession,
5045	–	_swigt__p_jobStates,
5046	–	_swigt__p_BossTask__job_iterator,
6450		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6451	+	_swigt__p_BossTask__job_iterator,
6452	+	_swigt__p_jobStates,
6453		0
6454		};
6455
#	Line 5087 | Line 6492 | SWIGEXPORT(void) SWIG_init(void) {
6492		}
6493		SWIG_InstallConstants(d,swig_const_table);
6494
6495	+
6496	+	// define custom exceptions
6497	+	PyObject *e;
6498	+	PyMethodDef tp_methods = {
6499	+	NULL, NULL, 0, NULL
6500	+	};
6501	+	e = Py_InitModule("BossSession", &tp_methods);
6502	+	// generic BOSS exception
6503	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6504	+	Py_INCREF(BossError);
6505	+	PyModule_AddObject(e, "BossError", BossError);
6506	+	// scheduler interaction BOSS exception
6507	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6508	+	Py_INCREF(SchedulerError);
6509	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6510	+
6511		}
6512

Diff Legend

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