ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.4 by gcodispo, Thu Oct 26 13:17:48 2006 UTC vs.
Revision 1.25 by gcodispo, Mon Mar 5 08:07:03 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]
665	>	#define  SWIGTYPE_p_printOption swig_types[8]
666		#define  SWIGTYPE_p_BossAttributeContainer swig_types[9]
667	<	#define  SWIGTYPE_p_printOption swig_types[10]
667	>	#define  SWIGTYPE_p_BossJob swig_types[10]
668		#define  SWIGTYPE_p_BossDatabase swig_types[11]
669	<	#define  SWIGTYPE_p_BossJob swig_types[12]
670	<	#define  SWIGTYPE_p_BossSession swig_types[13]
671	<	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[14]
672	<	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[15]
673	<	#define  SWIGTYPE_p_BossAdministratorSession swig_types[16]
674	<	#define  SWIGTYPE_p_jobStates swig_types[17]
675	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[18]
676	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[19]
677	<	static swig_type_info *swig_types[21];
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_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[17]
675	>	#define  SWIGTYPE_p_jobStates swig_types[18]
676	>	static swig_type_info *swig_types[20];
677
678		/* -------- TYPES TABLE (END) -------- */
679
#	Line 852 | 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 863 | Line 929 | PyObject *std_maplstd_stringcstd_string_
929		#include "BossProgram.h"
930		#include "BossProgramExec.h"
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());
#	Line 873 | Line 941 | PyObject *BossSession_show(BossSession *
941		}
942		return my_list;
943		}
944	<	PyObject *BossSession_showCHTools__SWIG_1(BossSession *self){
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_showProgramTypes__SWIG_1(BossSession *self){
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_showRTMon__SWIG_1(BossSession *self){
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_showSchedulers__SWIG_1(BossSession *self){
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_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){
961	<	self->jobQuery ( filter_opt, taskRange, jobRange, subn,
962	<	type, user, after, before, avoidCheck);
963	<	PyObject * job_dict = PyList_New(0);
964	<	std::vector <std::string>
965	<	taskList = self->selectTasks( taskRange, before, after, user);
966	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
967	<	it!= taskList.end(); ++it ) {
968	<	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
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	<
975	<	//       int size = taskList.size();
976	<	//       PyObject * job_dict = PyList_New(0);
977	<	//       for ( unsigned int i = 0; i < size; ++i ) {
978	<	//      PyList_SetItem(job_dict,i, );
979	<	//      self->makeBossTask( *it );
908	<	//       }
909	<	return  job_dict;
910	<	}
911	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
912	<	std::string tmp;
913	<	BossAttributeContainer::const_iterator it_end = obj.end ();
914	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
915	<	it != it_end; ++it) {
916	<	tmp = (*it).first.name ();
917	<	char * key = new char[ tmp.size() ];
918	<	key = strdup(tmp.c_str());
919	<	tmp = (*it).second.value ();
920	<	PyObject * val = PyString_FromString( tmp.c_str() );
921	<	PyDict_SetItemString( dict, key, val );
922	<	delete [] key;
974	>	PyObject * job_dict = PyList_New(0);
975	>	std::vector <std::string>
976	>	taskList = self->selectTasks( taskRange, before, after, user);
977	>	for ( std::vector <std::string>::const_iterator it= taskList.begin();
978	>	it!= taskList.end(); ++it ) {
979	>	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
980		}
981	<	return dict;
981	>	return  job_dict;
982		}
983	<	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
983	>	void 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	>
989	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
990	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
991	>	PyDict_SetItem( dict, key, val);
992	>	Py_DECREF(key);
993	>	Py_DECREF(val);
994	>	}
995	>	return;
996	>	}
997	>	void BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit,PyObject *job_dict){
998
999	<	PyObject * job_dict = PyDict_New();
999	>	//    PyObject * job_dict = PyDict_New();
1000		std::string tmp;
1001
1002		BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1003	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1003	>	BossTask_appendToPyDict ( self, job_dict, obj );
1004
1005		std::set<std::string> sch = (*jit)->getSchedulerElements();
1006		std::set<std::string>::const_iterator sch_end =  sch.end();
1007		for (std::set<std::string>::const_iterator it =sch.begin();
1008		it != sch_end; ++ it ) {
1009	<	tmp = (*it);
939	<	char * key = new char[ tmp.size() ];
940	<	key = strdup(tmp.c_str());
1009	>
1010		tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1011	+	PyObject * key = PyString_FromString( it->c_str() );
1012		PyObject * val = PyString_FromString( tmp.c_str() );
1013	<	PyDict_SetItemString( job_dict, key, val );
1014	<	delete [] key;
1013	>	PyDict_SetItem( job_dict, key, val);
1014	>	Py_DECREF(key);
1015	>	Py_DECREF(val);
1016		}
1017	<	return job_dict;
1017	>	return;
1018		}
1019	<	PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
1019	>	PyObject *BossTask_jobsDict(BossTask *self){
1020
1021		PyObject * job_dict = PyDict_New();
1022	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1023		for (BossTask::job_iterator jit = self->job_begin ();
1024		jit != self->job_end (); ++jit) {
1025	<	std::string id = (*jit)->chainId();
1026	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1027	<	PyObject * myid =  PyString_FromString(id.c_str() );
1028	<	PyDict_SetItem( job_dict, myid,tmp );
1025	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1026	>	PyObject * tmp_dict = PyDict_New();
1027	>	BossTask_jobDict( self, jit, tmp_dict );
1028	>	PyDict_SetItem( job_dict, id, tmp_dict );
1029	>	Py_DECREF(id);
1030	>	Py_DECREF(tmp_dict);
1031		}
1032		return job_dict;
1033		}
#	Line 998 | Line 1072 | PyObject *BossTask_jobPrograms(BossTask
1072		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1073		++programs_it  ) {
1074		std::string id = (programs_it->first)["PROGRAM.ID"];
1075	<	PyObject * tmp =  BossTask_progDict( self, programs_it );
1075	>	PyObject * tmp_dict =  BossTask_progDict( self, programs_it );
1076		PyObject * myid =  PyString_FromString(id.c_str() );
1077	<	PyDict_SetItem( job_dict, myid,tmp );
1077	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1078	>	Py_DECREF(myid);
1079	>	Py_DECREF(tmp_dict);
1080		}
1081		return job_dict;
1082		}
#	Line 1016 | Line 1092 | static PyObject *_wrap_new_objectMap__SW
1092		try {
1093		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1094
1095	+	}catch (const BossSchedFailure & e) {
1096	+	PyErr_SetString ( SchedulerError, e.what() );
1097	+	return NULL;
1098		}catch (const std::exception& e) {
1099	<	SWIG_exception(SWIG_RuntimeError, e.what());
1099	>	PyErr_SetString ( BossError, e.what() );
1100	>	return NULL;
1101		}
1102		}
1103		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1075 | Line 1155 | static PyObject *_wrap_new_objectMap__SW
1155		try {
1156		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1157
1158	+	}catch (const BossSchedFailure & e) {
1159	+	PyErr_SetString ( SchedulerError, e.what() );
1160	+	return NULL;
1161		}catch (const std::exception& e) {
1162	<	SWIG_exception(SWIG_RuntimeError, e.what());
1162	>	PyErr_SetString ( BossError, e.what() );
1163	>	return NULL;
1164		}
1165		}
1166		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1190 | Line 1274 | static PyObject *_wrap_objectMap___len__
1274		try {
1275		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1276
1277	+	}catch (const BossSchedFailure & e) {
1278	+	PyErr_SetString ( SchedulerError, e.what() );
1279	+	return NULL;
1280		}catch (const std::exception& e) {
1281	<	SWIG_exception(SWIG_RuntimeError, e.what());
1281	>	PyErr_SetString ( BossError, e.what() );
1282	>	return NULL;
1283		}
1284		}
1285		resultobj = PyInt_FromLong((long)result);
#	Line 1212 | Line 1300 | static PyObject *_wrap_objectMap_clear(P
1300		try {
1301		(arg1)->clear();
1302
1303	+	}catch (const BossSchedFailure & e) {
1304	+	PyErr_SetString ( SchedulerError, e.what() );
1305	+	return NULL;
1306		}catch (const std::exception& e) {
1307	<	SWIG_exception(SWIG_RuntimeError, e.what());
1307	>	PyErr_SetString ( BossError, e.what() );
1308	>	return NULL;
1309		}
1310		}
1311		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1235 | Line 1327 | static PyObject *_wrap_objectMap___nonze
1327		try {
1328		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1329
1330	+	}catch (const BossSchedFailure & e) {
1331	+	PyErr_SetString ( SchedulerError, e.what() );
1332	+	return NULL;
1333		}catch (const std::exception& e) {
1334	<	SWIG_exception(SWIG_RuntimeError, e.what());
1334	>	PyErr_SetString ( BossError, e.what() );
1335	>	return NULL;
1336		}
1337		}
1338		resultobj = PyInt_FromLong((long)result);
#	Line 1307 | Line 1403 | static PyObject *_wrap_objectMap___setit
1403		try {
1404		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1405
1406	+	}catch (const BossSchedFailure & e) {
1407	+	PyErr_SetString ( SchedulerError, e.what() );
1408	+	return NULL;
1409		}catch (const std::exception& e) {
1410	<	SWIG_exception(SWIG_RuntimeError, e.what());
1410	>	PyErr_SetString ( BossError, e.what() );
1411	>	return NULL;
1412		}
1413		}
1414		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1369 | Line 1469 | static PyObject *_wrap_objectMap_has_key
1469		try {
1470		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1471
1472	+	}catch (const BossSchedFailure & e) {
1473	+	PyErr_SetString ( SchedulerError, e.what() );
1474	+	return NULL;
1475		}catch (const std::exception& e) {
1476	<	SWIG_exception(SWIG_RuntimeError, e.what());
1476	>	PyErr_SetString ( BossError, e.what() );
1477	>	return NULL;
1478		}
1479		}
1480		resultobj = PyInt_FromLong((long)result);
#	Line 1392 | Line 1496 | static PyObject *_wrap_objectMap_keys(Py
1496		try {
1497		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1498
1499	+	}catch (const BossSchedFailure & e) {
1500	+	PyErr_SetString ( SchedulerError, e.what() );
1501	+	return NULL;
1502		}catch (const std::exception& e) {
1503	<	SWIG_exception(SWIG_RuntimeError, e.what());
1503	>	PyErr_SetString ( BossError, e.what() );
1504	>	return NULL;
1505		}
1506		}
1507		resultobj = result;
#	Line 1415 | Line 1523 | static PyObject *_wrap_objectMap_values(
1523		try {
1524		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1525
1526	+	}catch (const BossSchedFailure & e) {
1527	+	PyErr_SetString ( SchedulerError, e.what() );
1528	+	return NULL;
1529		}catch (const std::exception& e) {
1530	<	SWIG_exception(SWIG_RuntimeError, e.what());
1530	>	PyErr_SetString ( BossError, e.what() );
1531	>	return NULL;
1532		}
1533		}
1534		resultobj = result;
#	Line 1438 | Line 1550 | static PyObject *_wrap_objectMap_items(P
1550		try {
1551		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1552
1553	+	}catch (const BossSchedFailure & e) {
1554	+	PyErr_SetString ( SchedulerError, e.what() );
1555	+	return NULL;
1556		}catch (const std::exception& e) {
1557	<	SWIG_exception(SWIG_RuntimeError, e.what());
1557	>	PyErr_SetString ( BossError, e.what() );
1558	>	return NULL;
1559		}
1560		}
1561		resultobj = result;
#	Line 1469 | Line 1585 | static PyObject *_wrap_objectMap___conta
1585		try {
1586		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1587
1588	+	}catch (const BossSchedFailure & e) {
1589	+	PyErr_SetString ( SchedulerError, e.what() );
1590	+	return NULL;
1591		}catch (const std::exception& e) {
1592	<	SWIG_exception(SWIG_RuntimeError, e.what());
1592	>	PyErr_SetString ( BossError, e.what() );
1593	>	return NULL;
1594		}
1595		}
1596		resultobj = PyInt_FromLong((long)result);
#	Line 1515 | Line 1635 | static PyObject *_wrap_delete_objectMap(
1635		try {
1636		delete arg1;
1637
1638	+	}catch (const BossSchedFailure & e) {
1639	+	PyErr_SetString ( SchedulerError, e.what() );
1640	+	return NULL;
1641		}catch (const std::exception& e) {
1642	<	SWIG_exception(SWIG_RuntimeError, e.what());
1642	>	PyErr_SetString ( BossError, e.what() );
1643	>	return NULL;
1644		}
1645		}
1646		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1533 | Line 1657 | static PyObject * objectMap_swigregister
1657		Py_INCREF(obj);
1658		return Py_BuildValue((char *)"");
1659		}
1660	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
1660	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1661		PyObject *resultobj;
1662	<	BossSession *arg1 = (BossSession *) 0 ;
1663	<	std::vector<std::string > *arg2 = 0 ;
1664	<	PyObject *result;
1662	>	unsigned int arg1 = (unsigned int) 0 ;
1663	>	std::vector<std::string > *result;
1664	>	PyObject * obj0 = 0 ;
1665	>
1666	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1667	>	if (obj0) {
1668	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1669	>	if (PyErr_Occurred()) SWIG_fail;
1670	>	}
1671	>	{
1672	>	try {
1673	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1674	>
1675	>	}catch (const BossSchedFailure & e) {
1676	>	PyErr_SetString ( SchedulerError, e.what() );
1677	>	return NULL;
1678	>	}catch (const std::exception& e) {
1679	>	PyErr_SetString ( BossError, e.what() );
1680	>	return NULL;
1681	>	}
1682	>	}
1683	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1684	>	return resultobj;
1685	>	fail:
1686	>	return NULL;
1687	>	}
1688	>
1689	>
1690	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1691	>	PyObject *resultobj;
1692	>	unsigned int arg1 ;
1693	>	std::string *arg2 = 0 ;
1694	>	std::vector<std::string > *result;
1695	>	std::string temp2 ;
1696		PyObject * obj0 = 0 ;
1697		PyObject * obj1 = 0 ;
1698
1699	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
1700	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1701	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1702	<	if (arg2 == NULL) {
1703	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
1699	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1700	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1701	>	if (PyErr_Occurred()) SWIG_fail;
1702	>	{
1703	>	if (PyString_Check(obj1)) {
1704	>	temp2 = std::string(PyString_AsString(obj1));
1705	>	arg2 = &temp2;
1706	>	}else {
1707	>	SWIG_exception(SWIG_TypeError, "string expected");
1708	>	}
1709		}
1710		{
1711		try {
1712	<	result = (PyObject *)BossSession_show(arg1,*arg2);
1712	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1713
1714	+	}catch (const BossSchedFailure & e) {
1715	+	PyErr_SetString ( SchedulerError, e.what() );
1716	+	return NULL;
1717		}catch (const std::exception& e) {
1718	<	SWIG_exception(SWIG_RuntimeError, e.what());
1718	>	PyErr_SetString ( BossError, e.what() );
1719	>	return NULL;
1720		}
1721		}
1722	<	resultobj = result;
1722	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1723		return resultobj;
1724		fail:
1725		return NULL;
1726		}
1727
1728
1729	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_1(PyObject *self, PyObject *args) {
1729	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1730		PyObject *resultobj;
1731	<	BossSession *arg1 = (BossSession *) 0 ;
1732	<	PyObject *result;
1731	>	std::vector<std::string > *arg1 = 0 ;
1732	>	std::vector<std::string > *result;
1733	>	std::vector<std::string > temp1 ;
1734	>	std::vector<std::string > *v1 ;
1735		PyObject * obj0 = 0 ;
1736
1737	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
1738	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1737	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1738	>	{
1739	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1740	>	unsigned int size = (PyTuple_Check(obj0) ?
1741	>	PyTuple_Size(obj0) :
1742	>	PyList_Size(obj0));
1743	>	temp1 = std::vector<std::string >(size);
1744	>	arg1 = &temp1;
1745	>	for (unsigned int i=0; i<size; i++) {
1746	>	PyObject* o = PySequence_GetItem(obj0,i);
1747	>	if (PyString_Check(o)) {
1748	>	temp1[i] = (std::string)(\
1749	>	SwigString_AsString(o));
1750	>	Py_DECREF(o);
1751	>	}else {
1752	>	Py_DECREF(o);
1753	>	PyErr_SetString(PyExc_TypeError,
1754	>	"vector<""std::string""> expected");
1755	>	SWIG_fail;
1756	>	}
1757	>	}
1758	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1759	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1760	>	arg1 = v1;
1761	>	}else {
1762	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1763	>	SWIG_fail;
1764	>	}
1765	>	}
1766		{
1767		try {
1768	<	result = (PyObject *)BossSession_showCHTools__SWIG_1(arg1);
1768	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1769
1770	+	}catch (const BossSchedFailure & e) {
1771	+	PyErr_SetString ( SchedulerError, e.what() );
1772	+	return NULL;
1773		}catch (const std::exception& e) {
1774	<	SWIG_exception(SWIG_RuntimeError, e.what());
1774	>	PyErr_SetString ( BossError, e.what() );
1775	>	return NULL;
1776		}
1777		}
1778	<	resultobj = result;
1778	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1779		return resultobj;
1780		fail:
1781		return NULL;
1782		}
1783
1784
1785	<	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
1785	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1786		int argc;
1787	<	PyObject *argv[2];
1787	>	PyObject *argv[3];
1788		int ii;
1789
1790		argc = PyObject_Length(args);
1791	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1791	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1792		argv[ii] = PyTuple_GetItem(args,ii);
1793		}
1794	+	if ((argc >= 0) && (argc <= 1)) {
1795	+	int _v;
1796	+	if (argc <= 0) {
1797	+	return _wrap_new_vector_string__SWIG_0(self,args);
1798	+	}
1799	+	{
1800	+	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1801	+	}
1802	+	if (_v) {
1803	+	return _wrap_new_vector_string__SWIG_0(self,args);
1804	+	}
1805	+	}
1806		if (argc == 1) {
1807		int _v;
1808		{
1809	<	void *ptr;
1810	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1811	<	_v = 0;
1812	<	PyErr_Clear();
1809	>	/* native sequence? */
1810	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1811	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1812	>	PyTuple_Size(argv[0]) :
1813	>	PyList_Size(argv[0]));
1814	>	if (size == 0) {
1815	>	/* an empty sequence can be of any type */
1816	>	_v = 1;
1817	>	}else {
1818	>	/* check the first element only */
1819	>	PyObject* o = PySequence_GetItem(argv[0],0);
1820	>	if (PyString_Check(o))
1821	>	_v = 1;
1822	>	else
1823	>	_v = 0;
1824	>	Py_DECREF(o);
1825	>	}
1826		}else {
1827	+	/* wrapped vector? */
1828	+	std::vector<std::string >* v;
1829	+	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1830	+	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1831		_v = 1;
1832	+	else
1833	+	_v = 0;
1834		}
1835		}
1836		if (_v) {
1837	<	return _wrap_BossSession_showCHTools__SWIG_1(self,args);
1837	>	return _wrap_new_vector_string__SWIG_2(self,args);
1838	>	}
1839	>	}
1840	>	if (argc == 2) {
1841	>	int _v;
1842	>	{
1843	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1844	>	}
1845	>	if (_v) {
1846	>	{
1847	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1848	>	}
1849	>	if (_v) {
1850	>	return _wrap_new_vector_string__SWIG_1(self,args);
1851	>	}
1852		}
1853		}
1854
1855	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showCHTools'");
1855	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1856		return NULL;
1857		}
1858
1859
1860	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_1(PyObject *self, PyObject *args) {
1860	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1861		PyObject *resultobj;
1862	<	BossSession *arg1 = (BossSession *) 0 ;
1863	<	PyObject *result;
1862	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1863	>	unsigned int result;
1864	>	std::vector<std::string > temp1 ;
1865	>	std::vector<std::string > *v1 ;
1866		PyObject * obj0 = 0 ;
1867
1868	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
1869	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1868	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1869	>	{
1870	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1871	>	unsigned int size = (PyTuple_Check(obj0) ?
1872	>	PyTuple_Size(obj0) :
1873	>	PyList_Size(obj0));
1874	>	temp1 = std::vector<std::string >(size);
1875	>	arg1 = &temp1;
1876	>	for (unsigned int i=0; i<size; i++) {
1877	>	PyObject* o = PySequence_GetItem(obj0,i);
1878	>	if (PyString_Check(o)) {
1879	>	temp1[i] = (std::string)(\
1880	>	SwigString_AsString(o));
1881	>	Py_DECREF(o);
1882	>	}else {
1883	>	Py_DECREF(o);
1884	>	PyErr_SetString(PyExc_TypeError,
1885	>	"vector<""std::string""> expected");
1886	>	SWIG_fail;
1887	>	}
1888	>	}
1889	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1890	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1891	>	arg1 = v1;
1892	>	}else {
1893	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1894	>	SWIG_fail;
1895	>	}
1896	>	}
1897		{
1898		try {
1899	<	result = (PyObject *)BossSession_showProgramTypes__SWIG_1(arg1);
1899	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1900
1901	+	}catch (const BossSchedFailure & e) {
1902	+	PyErr_SetString ( SchedulerError, e.what() );
1903	+	return NULL;
1904		}catch (const std::exception& e) {
1905	<	SWIG_exception(SWIG_RuntimeError, e.what());
1905	>	PyErr_SetString ( BossError, e.what() );
1906	>	return NULL;
1907		}
1908		}
1909	<	resultobj = result;
1909	>	resultobj = PyInt_FromLong((long)result);
1910		return resultobj;
1911		fail:
1912		return NULL;
1913		}
1914
1915
1916	<	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
1917	<	int argc;
1918	<	PyObject *argv[2];
1919	<	int ii;
1916	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1917	>	PyObject *resultobj;
1918	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1919	>	bool result;
1920	>	std::vector<std::string > temp1 ;
1921	>	std::vector<std::string > *v1 ;
1922	>	PyObject * obj0 = 0 ;
1923
1924	<	argc = PyObject_Length(args);
1925	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1926	<	argv[ii] = PyTuple_GetItem(args,ii);
1927	<	}
1928	<	if (argc == 1) {
1929	<	int _v;
1930	<	{
1931	<	void *ptr;
1932	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1933	<	_v = 0;
1934	<	PyErr_Clear();
1935	<	}else {
1936	<	_v = 1;
1924	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1925	>	{
1926	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1927	>	unsigned int size = (PyTuple_Check(obj0) ?
1928	>	PyTuple_Size(obj0) :
1929	>	PyList_Size(obj0));
1930	>	temp1 = std::vector<std::string >(size);
1931	>	arg1 = &temp1;
1932	>	for (unsigned int i=0; i<size; i++) {
1933	>	PyObject* o = PySequence_GetItem(obj0,i);
1934	>	if (PyString_Check(o)) {
1935	>	temp1[i] = (std::string)(\
1936	>	SwigString_AsString(o));
1937	>	Py_DECREF(o);
1938	>	}else {
1939	>	Py_DECREF(o);
1940	>	PyErr_SetString(PyExc_TypeError,
1941	>	"vector<""std::string""> expected");
1942	>	SWIG_fail;
1943	>	}
1944		}
1945	+	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1946	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1947	+	arg1 = v1;
1948	+	}else {
1949	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1950	+	SWIG_fail;
1951		}
1952	<	if (_v) {
1953	<	return _wrap_BossSession_showProgramTypes__SWIG_1(self,args);
1952	>	}
1953	>	{
1954	>	try {
1955	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1956	>
1957	>	}catch (const BossSchedFailure & e) {
1958	>	PyErr_SetString ( SchedulerError, e.what() );
1959	>	return NULL;
1960	>	}catch (const std::exception& e) {
1961	>	PyErr_SetString ( BossError, e.what() );
1962	>	return NULL;
1963		}
1964		}
1965	<
1966	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showProgramTypes'");
1965	>	resultobj = PyInt_FromLong((long)result);
1966	>	return resultobj;
1967	>	fail:
1968		return NULL;
1969		}
1970
1971
1972	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_1(PyObject *self, PyObject *args) {
1972	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1973		PyObject *resultobj;
1974	<	BossSession *arg1 = (BossSession *) 0 ;
1674	<	PyObject *result;
1974	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1975		PyObject * obj0 = 0 ;
1976
1977	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
1978	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1977	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1978	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1979		{
1980		try {
1981	<	result = (PyObject *)BossSession_showRTMon__SWIG_1(arg1);
1981	>	(arg1)->clear();
1982
1983	+	}catch (const BossSchedFailure & e) {
1984	+	PyErr_SetString ( SchedulerError, e.what() );
1985	+	return NULL;
1986		}catch (const std::exception& e) {
1987	<	SWIG_exception(SWIG_RuntimeError, e.what());
1987	>	PyErr_SetString ( BossError, e.what() );
1988	>	return NULL;
1989		}
1990		}
1991	<	resultobj = result;
1991	>	Py_INCREF(Py_None); resultobj = Py_None;
1992		return resultobj;
1993		fail:
1994		return NULL;
1995		}
1996
1997
1998	<	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
1999	<	int argc;
2000	<	PyObject *argv[2];
2001	<	int ii;
1998	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1999	>	PyObject *resultobj;
2000	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2001	>	std::string arg2 ;
2002	>	PyObject * obj0 = 0 ;
2003	>	PyObject * obj1 = 0 ;
2004
2005	<	argc = PyObject_Length(args);
2006	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2007	<	argv[ii] = PyTuple_GetItem(args,ii);
2005	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
2006	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2007	>	{
2008	>	if (PyString_Check(obj1))
2009	>	arg2 = std::string(PyString_AsString(obj1));
2010	>	else
2011	>	SWIG_exception(SWIG_TypeError, "string expected");
2012		}
2013	<	if (argc == 1) {
2014	<	int _v;
2015	<	{
2016	<	void *ptr;
2017	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2018	<	_v = 0;
2019	<	PyErr_Clear();
2020	<	}else {
2021	<	_v = 1;
2022	<	}
2013	>	{
2014	>	try {
2015	>	(arg1)->push_back(arg2);
2016	>
2017	>	}catch (const BossSchedFailure & e) {
2018	>	PyErr_SetString ( SchedulerError, e.what() );
2019	>	return NULL;
2020	>	}catch (const std::exception& e) {
2021	>	PyErr_SetString ( BossError, e.what() );
2022	>	return NULL;
2023		}
2024	<	if (_v) {
2025	<	return _wrap_BossSession_showRTMon__SWIG_1(self,args);
2024	>	}
2025	>	Py_INCREF(Py_None); resultobj = Py_None;
2026	>	return resultobj;
2027	>	fail:
2028	>	return NULL;
2029	>	}
2030	>
2031	>
2032	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
2033	>	PyObject *resultobj;
2034	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2035	>	std::string result;
2036	>	PyObject * obj0 = 0 ;
2037	>
2038	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
2039	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2040	>	{
2041	>	try {
2042	>	result = std_vectorlstd_string_g_pop___(arg1);
2043	>
2044	>	}catch (std::out_of_range& e) {
2045	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2046		}
2047		}
2048	+	{
2049	+	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2050	+	}
2051	+	return resultobj;
2052	+	fail:
2053	+	return NULL;
2054	+	}
2055	+
2056	+
2057	+	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
2058	+	PyObject *resultobj;
2059	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2060	+	int arg2 ;
2061	+	std::string result;
2062	+	PyObject * obj0 = 0 ;
2063
2064	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showRTMon'");
2064	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2065	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2066	>	{
2067	>	try {
2068	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2069	>
2070	>	}catch (std::out_of_range& e) {
2071	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2072	>	}
2073	>	}
2074	>	{
2075	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2076	>	}
2077	>	return resultobj;
2078	>	fail:
2079		return NULL;
2080		}
2081
2082
2083	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_1(PyObject *self, PyObject *args) {
2083	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2084		PyObject *resultobj;
2085	<	BossSession *arg1 = (BossSession *) 0 ;
2086	<	PyObject *result;
2085	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2086	>	int arg2 ;
2087	>	int arg3 ;
2088	>	std::vector<std::string > result;
2089		PyObject * obj0 = 0 ;
2090
2091	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2092	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2091	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2092	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2093		{
2094		try {
2095	<	result = (PyObject *)BossSession_showSchedulers__SWIG_1(arg1);
2095	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2096
2097	+	}catch (const BossSchedFailure & e) {
2098	+	PyErr_SetString ( SchedulerError, e.what() );
2099	+	return NULL;
2100		}catch (const std::exception& e) {
2101	<	SWIG_exception(SWIG_RuntimeError, e.what());
2101	>	PyErr_SetString ( BossError, e.what() );
2102	>	return NULL;
2103		}
2104		}
2105	<	resultobj = result;
2105	>	{
2106	>	resultobj = PyTuple_New((&result)->size());
2107	>	for (unsigned int i=0; i<(&result)->size(); i++)
2108	>	PyTuple_SetItem(resultobj,i,
2109	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2110	>	}
2111		return resultobj;
2112		fail:
2113		return NULL;
2114		}
2115
2116
2117	<	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2118	<	int argc;
2119	<	PyObject *argv[2];
2120	<	int ii;
2117	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2118	>	PyObject *resultobj;
2119	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2120	>	int arg2 ;
2121	>	std::string arg3 ;
2122	>	PyObject * obj0 = 0 ;
2123	>	PyObject * obj2 = 0 ;
2124
2125	<	argc = PyObject_Length(args);
2126	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2127	<	argv[ii] = PyTuple_GetItem(args,ii);
2125	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2126	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2127	>	{
2128	>	if (PyString_Check(obj2))
2129	>	arg3 = std::string(PyString_AsString(obj2));
2130	>	else
2131	>	SWIG_exception(SWIG_TypeError, "string expected");
2132		}
2133	<	if (argc == 1) {
2134	<	int _v;
2135	<	{
2136	<	void *ptr;
2137	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2138	<	_v = 0;
1762	<	PyErr_Clear();
1763	<	}else {
1764	<	_v = 1;
1765	<	}
1766	<	}
1767	<	if (_v) {
1768	<	return _wrap_BossSession_showSchedulers__SWIG_1(self,args);
2133	>	{
2134	>	try {
2135	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2136	>
2137	>	}catch (std::out_of_range& e) {
2138	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2139		}
2140		}
2141	<
2142	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showSchedulers'");
2141	>	Py_INCREF(Py_None); resultobj = Py_None;
2142	>	return resultobj;
2143	>	fail:
2144		return NULL;
2145		}
2146
2147
2148	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2148	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2149		PyObject *resultobj;
2150	<	BossSession *arg1 = (BossSession *) 0 ;
2151	<	int arg2 = (int) SCHEDULED ;
2152	<	std::string const &arg3_defvalue = "all" ;
2153	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
2154	<	std::string const &arg4_defvalue = "all" ;
2155	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
1785	<	std::string const &arg5_defvalue = "" ;
1786	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
1787	<	std::string arg6 = (std::string) "" ;
1788	<	std::string arg7 = (std::string) "" ;
1789	<	std::string arg8 = (std::string) "" ;
1790	<	std::string arg9 = (std::string) "" ;
1791	<	bool arg10 = (bool) false ;
1792	<	PyObject *result;
1793	<	std::string temp3 ;
1794	<	std::string temp4 ;
1795	<	std::string temp5 ;
2150	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2151	>	int arg2 ;
2152	>	int arg3 ;
2153	>	std::vector<std::string > *arg4 = 0 ;
2154	>	std::vector<std::string > temp4 ;
2155	>	std::vector<std::string > *v4 ;
2156		PyObject * obj0 = 0 ;
1797	–	PyObject * obj2 = 0 ;
2157		PyObject * obj3 = 0 ;
1799	–	PyObject * obj4 = 0 ;
1800	–	PyObject * obj5 = 0 ;
1801	–	PyObject * obj6 = 0 ;
1802	–	PyObject * obj7 = 0 ;
1803	–	PyObject * obj8 = 0 ;
1804	–	PyObject * obj9 = 0 ;
2158
2159	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2160	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2161	<	if (obj2) {
2162	<	{
2163	<	if (PyString_Check(obj2)) {
2164	<	temp3 = std::string(PyString_AsString(obj2));
2165	<	arg3 = &temp3;
2166	<	}else {
2167	<	SWIG_exception(SWIG_TypeError, "string expected");
2159	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2160	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2161	>	{
2162	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2163	>	unsigned int size = (PyTuple_Check(obj3) ?
2164	>	PyTuple_Size(obj3) :
2165	>	PyList_Size(obj3));
2166	>	temp4 = std::vector<std::string >(size);
2167	>	arg4 = &temp4;
2168	>	for (unsigned int i=0; i<size; i++) {
2169	>	PyObject* o = PySequence_GetItem(obj3,i);
2170	>	if (PyString_Check(o)) {
2171	>	temp4[i] = (std::string)(\
2172	>	SwigString_AsString(o));
2173	>	Py_DECREF(o);
2174	>	}else {
2175	>	Py_DECREF(o);
2176	>	PyErr_SetString(PyExc_TypeError,
2177	>	"vector<""std::string""> expected");
2178	>	SWIG_fail;
2179	>	}
2180		}
2181	+	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2182	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2183	+	arg4 = v4;
2184	+	}else {
2185	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2186	+	SWIG_fail;
2187		}
2188		}
2189	<	if (obj3) {
2190	<	{
2191	<	if (PyString_Check(obj3)) {
2192	<	temp4 = std::string(PyString_AsString(obj3));
2193	<	arg4 = &temp4;
2194	<	}else {
2195	<	SWIG_exception(SWIG_TypeError, "string expected");
2196	<	}
2189	>	{
2190	>	try {
2191	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2192	>
2193	>	}catch (const BossSchedFailure & e) {
2194	>	PyErr_SetString ( SchedulerError, e.what() );
2195	>	return NULL;
2196	>	}catch (const std::exception& e) {
2197	>	PyErr_SetString ( BossError, e.what() );
2198	>	return NULL;
2199		}
2200		}
2201	<	if (obj4) {
2202	<	{
2203	<	if (PyString_Check(obj4)) {
2204	<	temp5 = std::string(PyString_AsString(obj4));
2205	<	arg5 = &temp5;
2206	<	}else {
2207	<	SWIG_exception(SWIG_TypeError, "string expected");
2208	<	}
2201	>	Py_INCREF(Py_None); resultobj = Py_None;
2202	>	return resultobj;
2203	>	fail:
2204	>	return NULL;
2205	>	}
2206	>
2207	>
2208	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2209	>	PyObject *resultobj;
2210	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2211	>	int arg2 ;
2212	>	PyObject * obj0 = 0 ;
2213	>
2214	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2215	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2216	>	{
2217	>	try {
2218	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2219	>
2220	>	}catch (std::out_of_range& e) {
2221	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2222		}
2223		}
2224	<	if (obj5) {
2224	>	Py_INCREF(Py_None); resultobj = Py_None;
2225	>	return resultobj;
2226	>	fail:
2227	>	return NULL;
2228	>	}
2229	>
2230	>
2231	>	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2232	>	PyObject *resultobj;
2233	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2234	>	int arg2 ;
2235	>	int arg3 ;
2236	>	PyObject * obj0 = 0 ;
2237	>
2238	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2239	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2240	>	{
2241	>	try {
2242	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2243	>
2244	>	}catch (const BossSchedFailure & e) {
2245	>	PyErr_SetString ( SchedulerError, e.what() );
2246	>	return NULL;
2247	>	}catch (const std::exception& e) {
2248	>	PyErr_SetString ( BossError, e.what() );
2249	>	return NULL;
2250	>	}
2251	>	}
2252	>	Py_INCREF(Py_None); resultobj = Py_None;
2253	>	return resultobj;
2254	>	fail:
2255	>	return NULL;
2256	>	}
2257	>
2258	>
2259	>	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2260	>	PyObject *resultobj;
2261	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2262	>	PyObject * obj0 = 0 ;
2263	>
2264	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2265	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2266	>	{
2267	>	try {
2268	>	delete arg1;
2269	>
2270	>	}catch (const BossSchedFailure & e) {
2271	>	PyErr_SetString ( SchedulerError, e.what() );
2272	>	return NULL;
2273	>	}catch (const std::exception& e) {
2274	>	PyErr_SetString ( BossError, e.what() );
2275	>	return NULL;
2276	>	}
2277	>	}
2278	>	Py_INCREF(Py_None); resultobj = Py_None;
2279	>	return resultobj;
2280	>	fail:
2281	>	return NULL;
2282	>	}
2283	>
2284	>
2285	>	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2286	>	PyObject *obj;
2287	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2288	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2289	>	Py_INCREF(obj);
2290	>	return Py_BuildValue((char *)"");
2291	>	}
2292	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2293	>	PyObject *resultobj;
2294	>	std::string arg1 = (std::string) "" ;
2295	>	std::string arg2 = (std::string) "2" ;
2296	>	std::string arg3 = (std::string) "" ;
2297	>	std::string arg4 = (std::string) "" ;
2298	>	BossSession *result;
2299	>	PyObject * obj0 = 0 ;
2300	>	PyObject * obj1 = 0 ;
2301	>	PyObject * obj2 = 0 ;
2302	>	PyObject * obj3 = 0 ;
2303	>
2304	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2305	>	if (obj0) {
2306		{
2307	<	if (PyString_Check(obj5))
2308	<	arg6 = std::string(PyString_AsString(obj5));
2307	>	if (PyString_Check(obj0))
2308	>	arg1 = std::string(PyString_AsString(obj0));
2309		else
2310		SWIG_exception(SWIG_TypeError, "string expected");
2311		}
2312		}
2313	<	if (obj6) {
2313	>	if (obj1) {
2314		{
2315	<	if (PyString_Check(obj6))
2316	<	arg7 = std::string(PyString_AsString(obj6));
2315	>	if (PyString_Check(obj1))
2316	>	arg2 = std::string(PyString_AsString(obj1));
2317		else
2318		SWIG_exception(SWIG_TypeError, "string expected");
2319		}
2320		}
2321	<	if (obj7) {
2321	>	if (obj2) {
2322		{
2323	<	if (PyString_Check(obj7))
2324	<	arg8 = std::string(PyString_AsString(obj7));
2323	>	if (PyString_Check(obj2))
2324	>	arg3 = std::string(PyString_AsString(obj2));
2325		else
2326		SWIG_exception(SWIG_TypeError, "string expected");
2327		}
2328		}
2329	<	if (obj8) {
2329	>	if (obj3) {
2330		{
2331	<	if (PyString_Check(obj8))
2332	<	arg9 = std::string(PyString_AsString(obj8));
2331	>	if (PyString_Check(obj3))
2332	>	arg4 = std::string(PyString_AsString(obj3));
2333		else
2334		SWIG_exception(SWIG_TypeError, "string expected");
2335		}
2336		}
1870	–	if (obj9) {
1871	–	arg10 = PyInt_AsLong(obj9) ? true : false;
1872	–	if (PyErr_Occurred()) SWIG_fail;
1873	–	}
2337		{
2338		try {
2339	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2339	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2340
2341	+	}catch (const BossSchedFailure & e) {
2342	+	PyErr_SetString ( SchedulerError, e.what() );
2343	+	return NULL;
2344		}catch (const std::exception& e) {
2345	<	SWIG_exception(SWIG_RuntimeError, e.what());
2345	>	PyErr_SetString ( BossError, e.what() );
2346	>	return NULL;
2347		}
2348		}
2349	<	resultobj = result;
2349	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2350		return resultobj;
2351		fail:
2352		return NULL;
2353		}
2354
2355
2356	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2356	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2357		PyObject *resultobj;
2358	<	std::string arg1 = (std::string) "" ;
1892	<	BossSession *result;
2358	>	BossSession *arg1 = (BossSession *) 0 ;
2359		PyObject * obj0 = 0 ;
2360
2361	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2362	<	if (obj0) {
2363	<	{
2364	<	if (PyString_Check(obj0))
2365	<	arg1 = std::string(PyString_AsString(obj0));
2366	<	else
2367	<	SWIG_exception(SWIG_TypeError, "string expected");
2361	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2362	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2363	>	{
2364	>	try {
2365	>	delete arg1;
2366	>
2367	>	}catch (const BossSchedFailure & e) {
2368	>	PyErr_SetString ( SchedulerError, e.what() );
2369	>	return NULL;
2370	>	}catch (const std::exception& e) {
2371	>	PyErr_SetString ( BossError, e.what() );
2372	>	return NULL;
2373		}
2374		}
2375	+	Py_INCREF(Py_None); resultobj = Py_None;
2376	+	return resultobj;
2377	+	fail:
2378	+	return NULL;
2379	+	}
2380	+
2381	+
2382	+	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2383	+	PyObject *resultobj;
2384	+	BossSession *arg1 = (BossSession *) 0 ;
2385	+	PyObject * obj0 = 0 ;
2386	+
2387	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2388	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2389		{
2390		try {
2391	<	result = (BossSession *)new BossSession(arg1);
2391	>	(arg1)->resetDB();
2392
2393	+	}catch (const BossSchedFailure & e) {
2394	+	PyErr_SetString ( SchedulerError, e.what() );
2395	+	return NULL;
2396		}catch (const std::exception& e) {
2397	<	SWIG_exception(SWIG_RuntimeError, e.what());
2397	>	PyErr_SetString ( BossError, e.what() );
2398	>	return NULL;
2399		}
2400		}
2401	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2401	>	Py_INCREF(Py_None); resultobj = Py_None;
2402		return resultobj;
2403		fail:
2404		return NULL;
2405		}
2406
2407
2408	<	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2408	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2409		PyObject *resultobj;
2410		BossSession *arg1 = (BossSession *) 0 ;
2411		PyObject * obj0 = 0 ;
2412
2413	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2413	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2414		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2415		{
2416		try {
2417	<	delete arg1;
2417	>	(arg1)->clear();
2418
2419	+	}catch (const BossSchedFailure & e) {
2420	+	PyErr_SetString ( SchedulerError, e.what() );
2421	+	return NULL;
2422		}catch (const std::exception& e) {
2423	<	SWIG_exception(SWIG_RuntimeError, e.what());
2423	>	PyErr_SetString ( BossError, e.what() );
2424	>	return NULL;
2425		}
2426		}
2427		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1964 | Line 2457 | static PyObject *_wrap_BossSession_makeB
2457		try {
2458		result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2459
2460	+	}catch (const BossSchedFailure & e) {
2461	+	PyErr_SetString ( SchedulerError, e.what() );
2462	+	return NULL;
2463		}catch (const std::exception& e) {
2464	<	SWIG_exception(SWIG_RuntimeError, e.what());
2464	>	PyErr_SetString ( BossError, e.what() );
2465	>	return NULL;
2466		}
2467		}
2468		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
#	Line 1989 | Line 2486 | static PyObject *_wrap_BossSession_destr
2486		try {
2487		(arg1)->destroyBossTask(arg2);
2488
2489	+	}catch (const BossSchedFailure & e) {
2490	+	PyErr_SetString ( SchedulerError, e.what() );
2491	+	return NULL;
2492		}catch (const std::exception& e) {
2493	<	SWIG_exception(SWIG_RuntimeError, e.what());
2493	>	PyErr_SetString ( BossError, e.what() );
2494	>	return NULL;
2495		}
2496		}
2497		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2000 | Line 2501 | static PyObject *_wrap_BossSession_destr
2501		}
2502
2503
2504	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_0(PyObject *self, PyObject *args) {
2504	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2505		PyObject *resultobj;
2506		BossSession *arg1 = (BossSession *) 0 ;
2507	<	SwigValueWrapper< std::vector<std::string > > result;
2507	>	std::vector<std::string > result;
2508		PyObject * obj0 = 0 ;
2509
2510		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
#	Line 2012 | Line 2513 | static PyObject *_wrap_BossSession_showC
2513		try {
2514		result = (arg1)->showCHTools();
2515
2516	+	}catch (const BossSchedFailure & e) {
2517	+	PyErr_SetString ( SchedulerError, e.what() );
2518	+	return NULL;
2519		}catch (const std::exception& e) {
2520	<	SWIG_exception(SWIG_RuntimeError, e.what());
2520	>	PyErr_SetString ( BossError, e.what() );
2521	>	return NULL;
2522		}
2523		}
2524		{
2525	<	std::vector<std::string > * resultptr;
2526	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2527	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2525	>	resultobj = PyTuple_New((&result)->size());
2526	>	for (unsigned int i=0; i<(&result)->size(); i++)
2527	>	PyTuple_SetItem(resultobj,i,
2528	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2529		}
2530		return resultobj;
2531		fail:
#	Line 2027 | Line 2533 | static PyObject *_wrap_BossSession_showC
2533		}
2534
2535
2536	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_0(PyObject *self, PyObject *args) {
2536	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2537		PyObject *resultobj;
2538		BossSession *arg1 = (BossSession *) 0 ;
2539	<	SwigValueWrapper< std::vector<std::string > > result;
2539	>	std::vector<std::string > result;
2540		PyObject * obj0 = 0 ;
2541
2542		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
#	Line 2039 | Line 2545 | static PyObject *_wrap_BossSession_showP
2545		try {
2546		result = (arg1)->showProgramTypes();
2547
2548	+	}catch (const BossSchedFailure & e) {
2549	+	PyErr_SetString ( SchedulerError, e.what() );
2550	+	return NULL;
2551		}catch (const std::exception& e) {
2552	<	SWIG_exception(SWIG_RuntimeError, e.what());
2552	>	PyErr_SetString ( BossError, e.what() );
2553	>	return NULL;
2554		}
2555		}
2556		{
2557	<	std::vector<std::string > * resultptr;
2558	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2559	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2557	>	resultobj = PyTuple_New((&result)->size());
2558	>	for (unsigned int i=0; i<(&result)->size(); i++)
2559	>	PyTuple_SetItem(resultobj,i,
2560	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2561		}
2562		return resultobj;
2563		fail:
#	Line 2054 | Line 2565 | static PyObject *_wrap_BossSession_showP
2565		}
2566
2567
2568	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_0(PyObject *self, PyObject *args) {
2568	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2569		PyObject *resultobj;
2570		BossSession *arg1 = (BossSession *) 0 ;
2571	<	SwigValueWrapper< std::vector<std::string > > result;
2571	>	std::vector<std::string > result;
2572		PyObject * obj0 = 0 ;
2573
2574		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
#	Line 2066 | Line 2577 | static PyObject *_wrap_BossSession_showR
2577		try {
2578		result = (arg1)->showRTMon();
2579
2580	+	}catch (const BossSchedFailure & e) {
2581	+	PyErr_SetString ( SchedulerError, e.what() );
2582	+	return NULL;
2583		}catch (const std::exception& e) {
2584	<	SWIG_exception(SWIG_RuntimeError, e.what());
2584	>	PyErr_SetString ( BossError, e.what() );
2585	>	return NULL;
2586		}
2587		}
2588		{
2589	<	std::vector<std::string > * resultptr;
2590	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2591	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2589	>	resultobj = PyTuple_New((&result)->size());
2590	>	for (unsigned int i=0; i<(&result)->size(); i++)
2591	>	PyTuple_SetItem(resultobj,i,
2592	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2593		}
2594		return resultobj;
2595		fail:
#	Line 2081 | Line 2597 | static PyObject *_wrap_BossSession_showR
2597		}
2598
2599
2600	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_0(PyObject *self, PyObject *args) {
2600	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2601		PyObject *resultobj;
2602		BossSession *arg1 = (BossSession *) 0 ;
2603	<	SwigValueWrapper< std::vector<std::string > > result;
2603	>	std::vector<std::string > result;
2604		PyObject * obj0 = 0 ;
2605
2606		if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
#	Line 2093 | Line 2609 | static PyObject *_wrap_BossSession_showS
2609		try {
2610		result = (arg1)->showSchedulers();
2611
2612	+	}catch (const BossSchedFailure & e) {
2613	+	PyErr_SetString ( SchedulerError, e.what() );
2614	+	return NULL;
2615		}catch (const std::exception& e) {
2616	<	SWIG_exception(SWIG_RuntimeError, e.what());
2616	>	PyErr_SetString ( BossError, e.what() );
2617	>	return NULL;
2618		}
2619		}
2620		{
2621	<	std::vector<std::string > * resultptr;
2622	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2623	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2621	>	resultobj = PyTuple_New((&result)->size());
2622	>	for (unsigned int i=0; i<(&result)->size(); i++)
2623	>	PyTuple_SetItem(resultobj,i,
2624	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2625		}
2626		return resultobj;
2627		fail:
#	Line 2120 | Line 2641 | static PyObject *_wrap_BossSession_defau
2641		try {
2642		result = (arg1)->defaultCHTool();
2643
2644	+	}catch (const BossSchedFailure & e) {
2645	+	PyErr_SetString ( SchedulerError, e.what() );
2646	+	return NULL;
2647		}catch (const std::exception& e) {
2648	<	SWIG_exception(SWIG_RuntimeError, e.what());
2648	>	PyErr_SetString ( BossError, e.what() );
2649	>	return NULL;
2650		}
2651		}
2652		{
#	Line 2145 | Line 2670 | static PyObject *_wrap_BossSession_defau
2670		try {
2671		result = (arg1)->defaultProgramType();
2672
2673	+	}catch (const BossSchedFailure & e) {
2674	+	PyErr_SetString ( SchedulerError, e.what() );
2675	+	return NULL;
2676		}catch (const std::exception& e) {
2677	<	SWIG_exception(SWIG_RuntimeError, e.what());
2677	>	PyErr_SetString ( BossError, e.what() );
2678	>	return NULL;
2679		}
2680		}
2681		{
#	Line 2170 | Line 2699 | static PyObject *_wrap_BossSession_defau
2699		try {
2700		result = (arg1)->defaultRTMon();
2701
2702	+	}catch (const BossSchedFailure & e) {
2703	+	PyErr_SetString ( SchedulerError, e.what() );
2704	+	return NULL;
2705		}catch (const std::exception& e) {
2706	<	SWIG_exception(SWIG_RuntimeError, e.what());
2706	>	PyErr_SetString ( BossError, e.what() );
2707	>	return NULL;
2708		}
2709		}
2710		{
#	Line 2195 | Line 2728 | static PyObject *_wrap_BossSession_defau
2728		try {
2729		result = (arg1)->defaultScheduler();
2730
2731	+	}catch (const BossSchedFailure & e) {
2732	+	PyErr_SetString ( SchedulerError, e.what() );
2733	+	return NULL;
2734		}catch (const std::exception& e) {
2735	<	SWIG_exception(SWIG_RuntimeError, e.what());
2735	>	PyErr_SetString ( BossError, e.what() );
2736	>	return NULL;
2737		}
2738		}
2739		{
#	Line 2220 | Line 2757 | static PyObject *_wrap_BossSession_versi
2757		try {
2758		result = (arg1)->version();
2759
2760	+	}catch (const BossSchedFailure & e) {
2761	+	PyErr_SetString ( SchedulerError, e.what() );
2762	+	return NULL;
2763		}catch (const std::exception& e) {
2764	<	SWIG_exception(SWIG_RuntimeError, e.what());
2764	>	PyErr_SetString ( BossError, e.what() );
2765	>	return NULL;
2766		}
2767		}
2768		{
#	Line 2245 | Line 2786 | static PyObject *_wrap_BossSession_clien
2786		try {
2787		result = (arg1)->clientID();
2788
2789	+	}catch (const BossSchedFailure & e) {
2790	+	PyErr_SetString ( SchedulerError, e.what() );
2791	+	return NULL;
2792		}catch (const std::exception& e) {
2793	<	SWIG_exception(SWIG_RuntimeError, e.what());
2793	>	PyErr_SetString ( BossError, e.what() );
2794	>	return NULL;
2795		}
2796		}
2797		{
#	Line 2276 | Line 2821 | static PyObject *_wrap_BossSession_showC
2821		try {
2822		result = (int)(arg1)->showConfigs(arg2);
2823
2824	+	}catch (const BossSchedFailure & e) {
2825	+	PyErr_SetString ( SchedulerError, e.what() );
2826	+	return NULL;
2827		}catch (const std::exception& e) {
2828	<	SWIG_exception(SWIG_RuntimeError, e.what());
2829	<	}
2282	<	}
2283	<	resultobj = PyInt_FromLong((long)result);
2284	<	return resultobj;
2285	<	fail:
2286	<	return NULL;
2287	<	}
2288	<
2289	<
2290	<	static PyObject *_wrap_BossSession_purgeTasks(PyObject *self, PyObject *args) {
2291	<	PyObject *resultobj;
2292	<	BossSession *arg1 = (BossSession *) 0 ;
2293	<	std::string *arg2 = 0 ;
2294	<	std::string *arg3 = 0 ;
2295	<	std::string *arg4 = 0 ;
2296	<	std::string const &arg5_defvalue = "0" ;
2297	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2298	<	int result;
2299	<	std::string temp2 ;
2300	<	std::string temp3 ;
2301	<	std::string temp4 ;
2302	<	std::string temp5 ;
2303	<	PyObject * obj0 = 0 ;
2304	<	PyObject * obj1 = 0 ;
2305	<	PyObject * obj2 = 0 ;
2306	<	PyObject * obj3 = 0 ;
2307	<	PyObject * obj4 = 0 ;
2308	<
2309	<	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossSession_purgeTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
2310	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2311	<	{
2312	<	if (PyString_Check(obj1)) {
2313	<	temp2 = std::string(PyString_AsString(obj1));
2314	<	arg2 = &temp2;
2315	<	}else {
2316	<	SWIG_exception(SWIG_TypeError, "string expected");
2317	<	}
2318	<	}
2319	<	{
2320	<	if (PyString_Check(obj2)) {
2321	<	temp3 = std::string(PyString_AsString(obj2));
2322	<	arg3 = &temp3;
2323	<	}else {
2324	<	SWIG_exception(SWIG_TypeError, "string expected");
2325	<	}
2326	<	}
2327	<	{
2328	<	if (PyString_Check(obj3)) {
2329	<	temp4 = std::string(PyString_AsString(obj3));
2330	<	arg4 = &temp4;
2331	<	}else {
2332	<	SWIG_exception(SWIG_TypeError, "string expected");
2333	<	}
2334	<	}
2335	<	if (obj4) {
2336	<	{
2337	<	if (PyString_Check(obj4)) {
2338	<	temp5 = std::string(PyString_AsString(obj4));
2339	<	arg5 = &temp5;
2340	<	}else {
2341	<	SWIG_exception(SWIG_TypeError, "string expected");
2342	<	}
2343	<	}
2344	<	}
2345	<	{
2346	<	try {
2347	<	result = (int)(arg1)->purgeTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
2348	<
2349	<	}catch (const std::exception& e) {
2350	<	SWIG_exception(SWIG_RuntimeError, e.what());
2828	>	PyErr_SetString ( BossError, e.what() );
2829	>	return NULL;
2830		}
2831		}
2832		resultobj = PyInt_FromLong((long)result);
#	Line 2399 | Line 2878 | static PyObject *_wrap_BossSession_RTupd
2878		try {
2879		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2880
2881	+	}catch (const BossSchedFailure & e) {
2882	+	PyErr_SetString ( SchedulerError, e.what() );
2883	+	return NULL;
2884		}catch (const std::exception& e) {
2885	<	SWIG_exception(SWIG_RuntimeError, e.what());
2885	>	PyErr_SetString ( BossError, e.what() );
2886	>	return NULL;
2887		}
2888		}
2889		resultobj = PyInt_FromLong((long)result);
#	Line 2420 | Line 2903 | static PyObject *_wrap_BossSession_listM
2903		std::string *arg5 = (std::string *) &arg5_defvalue ;
2904		std::string const &arg6_defvalue = "" ;
2905		std::string *arg6 = (std::string *) &arg6_defvalue ;
2906	<	std::string result;
2906	>	unsigned int arg7 = (unsigned int) 0 ;
2907	>	std::vector<std::string > result;
2908		std::string temp2 ;
2909		std::string temp3 ;
2910		std::string temp5 ;
#	Line 2431 | Line 2915 | static PyObject *_wrap_BossSession_listM
2915		PyObject * obj3 = 0 ;
2916		PyObject * obj4 = 0 ;
2917		PyObject * obj5 = 0 ;
2918	+	PyObject * obj6 = 0 ;
2919
2920	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2920	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2921		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2922		{
2923		if (PyString_Check(obj1)) {
#	Line 2474 | Line 2959 | static PyObject *_wrap_BossSession_listM
2959		}
2960		}
2961		}
2962	+	if (obj6) {
2963	+	arg7 = (unsigned int) PyInt_AsLong(obj6);
2964	+	if (PyErr_Occurred()) SWIG_fail;
2965	+	}
2966		{
2967		try {
2968	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2968	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
2969
2970	+	}catch (const BossSchedFailure & e) {
2971	+	PyErr_SetString ( SchedulerError, e.what() );
2972	+	return NULL;
2973		}catch (const std::exception& e) {
2974	<	SWIG_exception(SWIG_RuntimeError, e.what());
2974	>	PyErr_SetString ( BossError, e.what() );
2975	>	return NULL;
2976		}
2977		}
2978		{
2979	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2979	>	resultobj = PyTuple_New((&result)->size());
2980	>	for (unsigned int i=0; i<(&result)->size(); i++)
2981	>	PyTuple_SetItem(resultobj,i,
2982	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2983		}
2984		return resultobj;
2985		fail:
#	Line 2491 | Line 2987 | static PyObject *_wrap_BossSession_listM
2987		}
2988
2989
2990	<	static PyObject *_wrap_BossSession_jobQuery(PyObject *self, PyObject *args) {
2990	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
2991		PyObject *resultobj;
2992		BossSession *arg1 = (BossSession *) 0 ;
2993		int arg2 = (int) SCHEDULED ;
#	Line 2505 | Line 3001 | static PyObject *_wrap_BossSession_jobQu
3001		std::string arg7 = (std::string) "" ;
3002		std::string arg8 = (std::string) "" ;
3003		std::string arg9 = (std::string) "" ;
3004	<	bool arg10 = (bool) false ;
2509	<	SwigValueWrapper< std::vector<BossJob * > > result;
3004	>	unsigned int arg10 = (unsigned int) 0 ;
3005		std::string temp3 ;
3006		std::string temp4 ;
3007		std::string temp5 ;
#	Line 2520 | Line 3015 | static PyObject *_wrap_BossSession_jobQu
3015		PyObject * obj8 = 0 ;
3016		PyObject * obj9 = 0 ;
3017
3018	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_jobQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3018	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3019		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3020		if (obj2) {
3021		{
#	Line 2585 | Line 3080 | static PyObject *_wrap_BossSession_jobQu
3080		}
3081		}
3082		if (obj9) {
3083	<	arg10 = PyInt_AsLong(obj9) ? true : false;
3083	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3084		if (PyErr_Occurred()) SWIG_fail;
3085		}
3086		{
3087		try {
3088	<	result = (arg1)->jobQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3088	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3089
3090	+	}catch (const BossSchedFailure & e) {
3091	+	PyErr_SetString ( SchedulerError, e.what() );
3092	+	return NULL;
3093		}catch (const std::exception& e) {
3094	<	SWIG_exception(SWIG_RuntimeError, e.what());
3094	>	PyErr_SetString ( BossError, e.what() );
3095	>	return NULL;
3096		}
3097		}
3098	<	{
2600	<	std::vector<BossJob * > * resultptr;
2601	<	resultptr = new std::vector<BossJob * >((std::vector<BossJob * > &) result);
2602	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossJob_p_t, 1);
2603	<	}
3098	>	Py_INCREF(Py_None); resultobj = Py_None;
3099		return resultobj;
3100		fail:
3101		return NULL;
3102		}
3103
3104
3105	<	static PyObject *_wrap_BossSession_queryPrint(PyObject *self, PyObject *args) {
3105	>	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3106		PyObject *resultobj;
3107		BossSession *arg1 = (BossSession *) 0 ;
3108	<	SwigValueWrapper< std::vector<BossJob * > > arg2 ;
3109	<	std::ostream &arg3_defvalue = std::cout ;
3110	<	std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
3111	<	jobStates const &arg4_defvalue = SCHEDULED ;
3112	<	jobStates *arg4 = (jobStates *) &arg4_defvalue ;
3113	<	printOption const &arg5_defvalue = NORMAL ;
3114	<	printOption *arg5 = (printOption *) &arg5_defvalue ;
3115	<	std::string const &arg6_defvalue = "" ;
3116	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
3117	<	std::vector<BossJob * > *argp2 ;
3118	<	std::string temp6 ;
3108	>	std::string const &arg2_defvalue = "all" ;
3109	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3110	>	std::string const &arg3_defvalue = "" ;
3111	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3112	>	std::string const &arg4_defvalue = "" ;
3113	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3114	>	std::string const &arg5_defvalue = "" ;
3115	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3116	>	std::vector<std::string > result;
3117	>	std::string temp2 ;
3118	>	std::string temp3 ;
3119	>	std::string temp4 ;
3120	>	std::string temp5 ;
3121		PyObject * obj0 = 0 ;
3122		PyObject * obj1 = 0 ;
3123		PyObject * obj2 = 0 ;
3124		PyObject * obj3 = 0 ;
3125		PyObject * obj4 = 0 ;
2629	–	PyObject * obj5 = 0 ;
3126
3127	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossSession_queryPrint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3127	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3128		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3129	<	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3130	<	arg2 = *argp2;
3129	>	if (obj1) {
3130	>	{
3131	>	if (PyString_Check(obj1)) {
3132	>	temp2 = std::string(PyString_AsString(obj1));
3133	>	arg2 = &temp2;
3134	>	}else {
3135	>	SWIG_exception(SWIG_TypeError, "string expected");
3136	>	}
3137	>	}
3138	>	}
3139		if (obj2) {
3140	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3141	<	if (arg3 == NULL) {
3142	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3140	>	{
3141	>	if (PyString_Check(obj2)) {
3142	>	temp3 = std::string(PyString_AsString(obj2));
3143	>	arg3 = &temp3;
3144	>	}else {
3145	>	SWIG_exception(SWIG_TypeError, "string expected");
3146	>	}
3147		}
3148		}
3149		if (obj3) {
3150	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3151	<	if (arg4 == NULL) {
3152	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3150	>	{
3151	>	if (PyString_Check(obj3)) {
3152	>	temp4 = std::string(PyString_AsString(obj3));
3153	>	arg4 = &temp4;
3154	>	}else {
3155	>	SWIG_exception(SWIG_TypeError, "string expected");
3156	>	}
3157		}
3158		}
3159		if (obj4) {
2648	–	if ((SWIG_ConvertPtr(obj4,(void **) &arg5, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2649	–	if (arg5 == NULL) {
2650	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2651	–	}
2652	–	}
2653	–	if (obj5) {
3160		{
3161	<	if (PyString_Check(obj5)) {
3162	<	temp6 = std::string(PyString_AsString(obj5));
3163	<	arg6 = &temp6;
3161	>	if (PyString_Check(obj4)) {
3162	>	temp5 = std::string(PyString_AsString(obj4));
3163	>	arg5 = &temp5;
3164		}else {
3165		SWIG_exception(SWIG_TypeError, "string expected");
3166		}
#	Line 2662 | Line 3168 | static PyObject *_wrap_BossSession_query
3168		}
3169		{
3170		try {
3171	<	(arg1)->queryPrint(arg2,*arg3,(jobStates const &)*arg4,(printOption const &)*arg5,(std::string const &)*arg6);
3171	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3172
3173	+	}catch (const BossSchedFailure & e) {
3174	+	PyErr_SetString ( SchedulerError, e.what() );
3175	+	return NULL;
3176		}catch (const std::exception& e) {
3177	<	SWIG_exception(SWIG_RuntimeError, e.what());
3177	>	PyErr_SetString ( BossError, e.what() );
3178	>	return NULL;
3179		}
3180		}
3181	<	Py_INCREF(Py_None); resultobj = Py_None;
3181	>	{
3182	>	resultobj = PyTuple_New((&result)->size());
3183	>	for (unsigned int i=0; i<(&result)->size(); i++)
3184	>	PyTuple_SetItem(resultobj,i,
3185	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3186	>	}
3187		return resultobj;
3188		fail:
3189		return NULL;
3190		}
3191
3192
3193	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3193	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3194		PyObject *resultobj;
3195		BossSession *arg1 = (BossSession *) 0 ;
3196	<	std::string const &arg2_defvalue = "all" ;
3197	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2683	<	std::string const &arg3_defvalue = "" ;
3196	>	int arg2 = (int) SCHEDULED ;
3197	>	std::string const &arg3_defvalue = "all" ;
3198		std::string *arg3 = (std::string *) &arg3_defvalue ;
3199	<	std::string const &arg4_defvalue = "" ;
3199	>	std::string const &arg4_defvalue = "all" ;
3200		std::string *arg4 = (std::string *) &arg4_defvalue ;
3201		std::string const &arg5_defvalue = "" ;
3202		std::string *arg5 = (std::string *) &arg5_defvalue ;
3203	<	SwigValueWrapper< std::vector<std::string > > result;
3204	<	std::string temp2 ;
3203	>	std::string arg6 = (std::string) "" ;
3204	>	std::string arg7 = (std::string) "" ;
3205	>	std::string arg8 = (std::string) "" ;
3206	>	std::string arg9 = (std::string) "" ;
3207	>	unsigned int arg10 = (unsigned int) 0 ;
3208	>	bool arg11 = (bool) false ;
3209	>	SwigValueWrapper< std::vector<BossTask * > > result;
3210		std::string temp3 ;
3211		std::string temp4 ;
3212		std::string temp5 ;
3213		PyObject * obj0 = 0 ;
2695	–	PyObject * obj1 = 0 ;
3214		PyObject * obj2 = 0 ;
3215		PyObject * obj3 = 0 ;
3216		PyObject * obj4 = 0 ;
3217	+	PyObject * obj5 = 0 ;
3218	+	PyObject * obj6 = 0 ;
3219	+	PyObject * obj7 = 0 ;
3220	+	PyObject * obj8 = 0 ;
3221	+	PyObject * obj9 = 0 ;
3222	+	PyObject * obj10 = 0 ;
3223
3224	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3224	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3225		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2702	–	if (obj1) {
2703	–	{
2704	–	if (PyString_Check(obj1)) {
2705	–	temp2 = std::string(PyString_AsString(obj1));
2706	–	arg2 = &temp2;
2707	–	}else {
2708	–	SWIG_exception(SWIG_TypeError, "string expected");
2709	–	}
2710	–	}
2711	–	}
3226		if (obj2) {
3227		{
3228		if (PyString_Check(obj2)) {
#	Line 2739 | Line 3253 | static PyObject *_wrap_BossSession_selec
3253		}
3254		}
3255		}
3256	+	if (obj5) {
3257	+	{
3258	+	if (PyString_Check(obj5))
3259	+	arg6 = std::string(PyString_AsString(obj5));
3260	+	else
3261	+	SWIG_exception(SWIG_TypeError, "string expected");
3262	+	}
3263	+	}
3264	+	if (obj6) {
3265	+	{
3266	+	if (PyString_Check(obj6))
3267	+	arg7 = std::string(PyString_AsString(obj6));
3268	+	else
3269	+	SWIG_exception(SWIG_TypeError, "string expected");
3270	+	}
3271	+	}
3272	+	if (obj7) {
3273	+	{
3274	+	if (PyString_Check(obj7))
3275	+	arg8 = std::string(PyString_AsString(obj7));
3276	+	else
3277	+	SWIG_exception(SWIG_TypeError, "string expected");
3278	+	}
3279	+	}
3280	+	if (obj8) {
3281	+	{
3282	+	if (PyString_Check(obj8))
3283	+	arg9 = std::string(PyString_AsString(obj8));
3284	+	else
3285	+	SWIG_exception(SWIG_TypeError, "string expected");
3286	+	}
3287	+	}
3288	+	if (obj9) {
3289	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3290	+	if (PyErr_Occurred()) SWIG_fail;
3291	+	}
3292	+	if (obj10) {
3293	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3294	+	if (PyErr_Occurred()) SWIG_fail;
3295	+	}
3296		{
3297		try {
3298	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3298	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3299
3300	+	}catch (const BossSchedFailure & e) {
3301	+	PyErr_SetString ( SchedulerError, e.what() );
3302	+	return NULL;
3303		}catch (const std::exception& e) {
3304	<	SWIG_exception(SWIG_RuntimeError, e.what());
3304	>	PyErr_SetString ( BossError, e.what() );
3305	>	return NULL;
3306		}
3307		}
3308		{
3309	<	std::vector<std::string > * resultptr;
3310	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3311	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3309	>	std::vector<BossTask * > * resultptr;
3310	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3311	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3312		}
3313		return resultobj;
3314		fail:
#	Line 2758 | Line 3316 | static PyObject *_wrap_BossSession_selec
3316		}
3317
3318
3319	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
2762	<	PyObject *obj;
2763	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2764	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
2765	<	Py_INCREF(obj);
2766	<	return Py_BuildValue((char *)"");
2767	<	}
2768	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3319	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3320		PyObject *resultobj;
3321	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3322	<	char *arg2 ;
3321	>	BossSession *arg1 = (BossSession *) 0 ;
3322	>	std::vector<std::string > *arg2 = 0 ;
3323	>	PyObject *result;
3324		PyObject * obj0 = 0 ;
3325	+	PyObject * obj1 = 0 ;
3326
3327	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3328	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3327	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3328	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3329	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3330	>	if (arg2 == NULL) {
3331	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3332	>	}
3333		{
3334	<	if (arg2) {
3335	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3336	<	strcpy((char *) arg1->key,arg2);
3337	<	}else {
3338	<	arg1->key = 0;
3334	>	try {
3335	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3336	>
3337	>	}catch (const BossSchedFailure & e) {
3338	>	PyErr_SetString ( SchedulerError, e.what() );
3339	>	return NULL;
3340	>	}catch (const std::exception& e) {
3341	>	PyErr_SetString ( BossError, e.what() );
3342	>	return NULL;
3343		}
3344		}
3345	<	Py_INCREF(Py_None); resultobj = Py_None;
3345	>	resultobj = result;
3346		return resultobj;
3347		fail:
3348		return NULL;
3349		}
3350
3351
3352	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3352	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3353		PyObject *resultobj;
3354	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3355	<	char *result;
3354	>	BossSession *arg1 = (BossSession *) 0 ;
3355	>	PyObject *result;
3356		PyObject * obj0 = 0 ;
3357
3358	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3359	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3360	<	result = (char *) ((arg1)->key);
3361	<
3362	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3358	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3359	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3360	>	{
3361	>	try {
3362	>	result = (PyObject *)BossSession_CHTools(arg1);
3363	>
3364	>	}catch (const BossSchedFailure & e) {
3365	>	PyErr_SetString ( SchedulerError, e.what() );
3366	>	return NULL;
3367	>	}catch (const std::exception& e) {
3368	>	PyErr_SetString ( BossError, e.what() );
3369	>	return NULL;
3370	>	}
3371	>	}
3372	>	resultobj = result;
3373		return resultobj;
3374		fail:
3375		return NULL;
3376		}
3377
3378
3379	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3379	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3380		PyObject *resultobj;
3381	<	char *arg1 ;
3382	<	BossTaskException *result;
3381	>	BossSession *arg1 = (BossSession *) 0 ;
3382	>	PyObject *result;
3383	>	PyObject * obj0 = 0 ;
3384
3385	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3385	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3386	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3387		{
3388		try {
3389	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3389	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3390
3391	+	}catch (const BossSchedFailure & e) {
3392	+	PyErr_SetString ( SchedulerError, e.what() );
3393	+	return NULL;
3394		}catch (const std::exception& e) {
3395	<	SWIG_exception(SWIG_RuntimeError, e.what());
3395	>	PyErr_SetString ( BossError, e.what() );
3396	>	return NULL;
3397		}
3398		}
3399	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3399	>	resultobj = result;
3400		return resultobj;
3401		fail:
3402		return NULL;
3403		}
3404
3405
3406	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3406	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3407		PyObject *resultobj;
3408	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3409	<	char *result;
3408	>	BossSession *arg1 = (BossSession *) 0 ;
3409	>	PyObject *result;
3410		PyObject * obj0 = 0 ;
3411
3412	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3413	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3412	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3413	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3414		{
3415		try {
3416	<	result = (char *)((BossTaskException const *)arg1)->what();
3416	>	result = (PyObject *)BossSession_RTMons(arg1);
3417
3418	+	}catch (const BossSchedFailure & e) {
3419	+	PyErr_SetString ( SchedulerError, e.what() );
3420	+	return NULL;
3421		}catch (const std::exception& e) {
3422	<	SWIG_exception(SWIG_RuntimeError, e.what());
3422	>	PyErr_SetString ( BossError, e.what() );
3423	>	return NULL;
3424		}
3425		}
3426	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3426	>	resultobj = result;
3427		return resultobj;
3428		fail:
3429		return NULL;
3430		}
3431
3432
3433	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3433	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3434		PyObject *resultobj;
3435	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3435	>	BossSession *arg1 = (BossSession *) 0 ;
3436	>	PyObject *result;
3437		PyObject * obj0 = 0 ;
3438
3439	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3440	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3439	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3440	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3441		{
3442		try {
3443	<	delete arg1;
3443	>	result = (PyObject *)BossSession_schedulers(arg1);
3444
3445	+	}catch (const BossSchedFailure & e) {
3446	+	PyErr_SetString ( SchedulerError, e.what() );
3447	+	return NULL;
3448		}catch (const std::exception& e) {
3449	<	SWIG_exception(SWIG_RuntimeError, e.what());
3449	>	PyErr_SetString ( BossError, e.what() );
3450	>	return NULL;
3451		}
3452		}
3453	<	Py_INCREF(Py_None); resultobj = Py_None;
3453	>	resultobj = result;
3454		return resultobj;
3455		fail:
3456		return NULL;
3457		}
3458
3459
3460	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
2875	<	PyObject *obj;
2876	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2877	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
2878	<	Py_INCREF(obj);
2879	<	return Py_BuildValue((char *)"");
2880	<	}
2881	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3460	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3461		PyObject *resultobj;
3462	<	BossTask *arg1 = (BossTask *) 0 ;
3463	<	PyObject *arg2 = (PyObject *) 0 ;
3464	<	BossAttributeContainer *arg3 = 0 ;
3462	>	BossSession *arg1 = (BossSession *) 0 ;
3463	>	std::string *arg2 = 0 ;
3464	>	std::string *arg3 = 0 ;
3465	>	std::string const &arg4_defvalue = "" ;
3466	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3467	>	std::string const &arg5_defvalue = "" ;
3468	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3469	>	unsigned int arg6 = (unsigned int) 0 ;
3470	>	bool arg7 = (bool) false ;
3471		PyObject *result;
3472	+	std::string temp2 ;
3473	+	std::string temp3 ;
3474	+	std::string temp4 ;
3475	+	std::string temp5 ;
3476		PyObject * obj0 = 0 ;
3477		PyObject * obj1 = 0 ;
3478		PyObject * obj2 = 0 ;
3479	+	PyObject * obj3 = 0 ;
3480	+	PyObject * obj4 = 0 ;
3481	+	PyObject * obj5 = 0 ;
3482	+	PyObject * obj6 = 0 ;
3483
3484	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3485	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3486	<	arg2 = obj1;
3487	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3488	<	if (arg3 == NULL) {
3489	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3484	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3485	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3486	>	{
3487	>	if (PyString_Check(obj1)) {
3488	>	temp2 = std::string(PyString_AsString(obj1));
3489	>	arg2 = &temp2;
3490	>	}else {
3491	>	SWIG_exception(SWIG_TypeError, "string expected");
3492	>	}
3493	>	}
3494	>	{
3495	>	if (PyString_Check(obj2)) {
3496	>	temp3 = std::string(PyString_AsString(obj2));
3497	>	arg3 = &temp3;
3498	>	}else {
3499	>	SWIG_exception(SWIG_TypeError, "string expected");
3500	>	}
3501	>	}
3502	>	if (obj3) {
3503	>	{
3504	>	if (PyString_Check(obj3)) {
3505	>	temp4 = std::string(PyString_AsString(obj3));
3506	>	arg4 = &temp4;
3507	>	}else {
3508	>	SWIG_exception(SWIG_TypeError, "string expected");
3509	>	}
3510	>	}
3511	>	}
3512	>	if (obj4) {
3513	>	{
3514	>	if (PyString_Check(obj4)) {
3515	>	temp5 = std::string(PyString_AsString(obj4));
3516	>	arg5 = &temp5;
3517	>	}else {
3518	>	SWIG_exception(SWIG_TypeError, "string expected");
3519	>	}
3520	>	}
3521	>	}
3522	>	if (obj5) {
3523	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3524	>	if (PyErr_Occurred()) SWIG_fail;
3525	>	}
3526	>	if (obj6) {
3527	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3528	>	if (PyErr_Occurred()) SWIG_fail;
3529		}
3530		{
3531		try {
3532	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3532	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3533
3534	+	}catch (const BossSchedFailure & e) {
3535	+	PyErr_SetString ( SchedulerError, e.what() );
3536	+	return NULL;
3537		}catch (const std::exception& e) {
3538	<	SWIG_exception(SWIG_RuntimeError, e.what());
3538	>	PyErr_SetString ( BossError, e.what() );
3539	>	return NULL;
3540		}
3541		}
3542		resultobj = result;
#	Line 2910 | Line 3546 | static PyObject *_wrap_BossTask_appendTo
3546		}
3547
3548
3549	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3549	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3550		PyObject *resultobj;
3551	<	BossTask *arg1 = (BossTask *) 0 ;
3552	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3551	>	BossSession *arg1 = (BossSession *) 0 ;
3552	>	int arg2 = (int) SCHEDULED ;
3553	>	std::string const &arg3_defvalue = "all" ;
3554	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3555	>	std::string const &arg4_defvalue = "all" ;
3556	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3557	>	std::string const &arg5_defvalue = "" ;
3558	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3559	>	std::string arg6 = (std::string) "" ;
3560	>	std::string arg7 = (std::string) "" ;
3561	>	std::string arg8 = (std::string) "" ;
3562	>	std::string arg9 = (std::string) "" ;
3563	>	unsigned int arg10 = (unsigned int) 0 ;
3564	>	bool arg11 = (bool) false ;
3565		PyObject *result;
3566	+	std::string temp3 ;
3567	+	std::string temp4 ;
3568	+	std::string temp5 ;
3569		PyObject * obj0 = 0 ;
3570	<	PyObject * obj1 = 0 ;
3570	>	PyObject * obj2 = 0 ;
3571	>	PyObject * obj3 = 0 ;
3572	>	PyObject * obj4 = 0 ;
3573	>	PyObject * obj5 = 0 ;
3574	>	PyObject * obj6 = 0 ;
3575	>	PyObject * obj7 = 0 ;
3576	>	PyObject * obj8 = 0 ;
3577	>	PyObject * obj9 = 0 ;
3578	>	PyObject * obj10 = 0 ;
3579
3580	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3581	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3582	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3583	<	if (arg2 == NULL) {
3584	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3580	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3581	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3582	>	if (obj2) {
3583	>	{
3584	>	if (PyString_Check(obj2)) {
3585	>	temp3 = std::string(PyString_AsString(obj2));
3586	>	arg3 = &temp3;
3587	>	}else {
3588	>	SWIG_exception(SWIG_TypeError, "string expected");
3589	>	}
3590	>	}
3591	>	}
3592	>	if (obj3) {
3593	>	{
3594	>	if (PyString_Check(obj3)) {
3595	>	temp4 = std::string(PyString_AsString(obj3));
3596	>	arg4 = &temp4;
3597	>	}else {
3598	>	SWIG_exception(SWIG_TypeError, "string expected");
3599	>	}
3600	>	}
3601	>	}
3602	>	if (obj4) {
3603	>	{
3604	>	if (PyString_Check(obj4)) {
3605	>	temp5 = std::string(PyString_AsString(obj4));
3606	>	arg5 = &temp5;
3607	>	}else {
3608	>	SWIG_exception(SWIG_TypeError, "string expected");
3609	>	}
3610	>	}
3611	>	}
3612	>	if (obj5) {
3613	>	{
3614	>	if (PyString_Check(obj5))
3615	>	arg6 = std::string(PyString_AsString(obj5));
3616	>	else
3617	>	SWIG_exception(SWIG_TypeError, "string expected");
3618	>	}
3619	>	}
3620	>	if (obj6) {
3621	>	{
3622	>	if (PyString_Check(obj6))
3623	>	arg7 = std::string(PyString_AsString(obj6));
3624	>	else
3625	>	SWIG_exception(SWIG_TypeError, "string expected");
3626	>	}
3627	>	}
3628	>	if (obj7) {
3629	>	{
3630	>	if (PyString_Check(obj7))
3631	>	arg8 = std::string(PyString_AsString(obj7));
3632	>	else
3633	>	SWIG_exception(SWIG_TypeError, "string expected");
3634	>	}
3635	>	}
3636	>	if (obj8) {
3637	>	{
3638	>	if (PyString_Check(obj8))
3639	>	arg9 = std::string(PyString_AsString(obj8));
3640	>	else
3641	>	SWIG_exception(SWIG_TypeError, "string expected");
3642	>	}
3643	>	}
3644	>	if (obj9) {
3645	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3646	>	if (PyErr_Occurred()) SWIG_fail;
3647	>	}
3648	>	if (obj10) {
3649	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3650	>	if (PyErr_Occurred()) SWIG_fail;
3651		}
3652		{
3653		try {
3654	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3654	>	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3655
3656	+	}catch (const BossSchedFailure & e) {
3657	+	PyErr_SetString ( SchedulerError, e.what() );
3658	+	return NULL;
3659		}catch (const std::exception& e) {
3660	<	SWIG_exception(SWIG_RuntimeError, e.what());
3660	>	PyErr_SetString ( BossError, e.what() );
3661	>	return NULL;
3662		}
3663		}
3664		resultobj = result;
#	Line 2939 | Line 3668 | static PyObject *_wrap_BossTask_jobDict(
3668		}
3669
3670
3671	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3671	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3672	>	PyObject *obj;
3673	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3674	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3675	>	Py_INCREF(obj);
3676	>	return Py_BuildValue((char *)"");
3677	>	}
3678	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3679		PyObject *resultobj;
3680	<	BossTask *arg1 = (BossTask *) 0 ;
3681	<	PyObject *result;
3680	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3681	>	char *arg2 ;
3682		PyObject * obj0 = 0 ;
3683
3684	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3685	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3684	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3685	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3686		{
3687	<	try {
3688	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3689	<
3690	<	}catch (const std::exception& e) {
3691	<	SWIG_exception(SWIG_RuntimeError, e.what());
3687	>	if (arg2) {
3688	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3689	>	strcpy((char *) arg1->key,arg2);
3690	>	}else {
3691	>	arg1->key = 0;
3692		}
3693		}
3694	<	resultobj = result;
3694	>	Py_INCREF(Py_None); resultobj = Py_None;
3695		return resultobj;
3696		fail:
3697		return NULL;
3698		}
3699
3700
3701	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3702	<	int argc;
3703	<	PyObject *argv[2];
3704	<	int ii;
3701	>	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3702	>	PyObject *resultobj;
3703	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3704	>	char *result;
3705	>	PyObject * obj0 = 0 ;
3706
3707	<	argc = PyObject_Length(args);
3708	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3709	<	argv[ii] = PyTuple_GetItem(args,ii);
2973	<	}
2974	<	if (argc == 1) {
2975	<	int _v;
2976	<	{
2977	<	void *ptr;
2978	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
2979	<	_v = 0;
2980	<	PyErr_Clear();
2981	<	}else {
2982	<	_v = 1;
2983	<	}
2984	<	}
2985	<	if (_v) {
2986	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
2987	<	}
2988	<	}
3707	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3708	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3709	>	result = (char *) ((arg1)->key);
3710
3711	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3711	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3712	>	return resultobj;
3713	>	fail:
3714		return NULL;
3715		}
3716
3717
3718	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3718	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3719		PyObject *resultobj;
3720	<	BossTask *arg1 = (BossTask *) 0 ;
3721	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
2999	<	PyObject *result;
3000	<	PyObject * obj0 = 0 ;
3001	<	PyObject * obj1 = 0 ;
3720	>	char *arg1 ;
3721	>	BossTaskException *result;
3722
3723	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3004	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3005	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3006	<	if (arg2 == NULL) {
3007	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3008	<	}
3723	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3724		{
3725		try {
3726	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3726	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3727
3728	+	}catch (const BossSchedFailure & e) {
3729	+	PyErr_SetString ( SchedulerError, e.what() );
3730	+	return NULL;
3731		}catch (const std::exception& e) {
3732	<	SWIG_exception(SWIG_RuntimeError, e.what());
3732	>	PyErr_SetString ( BossError, e.what() );
3733	>	return NULL;
3734		}
3735		}
3736	<	resultobj = result;
3736	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3737		return resultobj;
3738		fail:
3739		return NULL;
3740		}
3741
3742
3743	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
3743	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3744		PyObject *resultobj;
3745	<	BossTask *arg1 = (BossTask *) 0 ;
3746	<	std::string *arg2 = 0 ;
3028	<	PyObject *result;
3029	<	std::string temp2 ;
3745	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3746	>	char *result;
3747		PyObject * obj0 = 0 ;
3031	–	PyObject * obj1 = 0 ;
3748
3749	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3750	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3749	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3750	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3751		{
3752	<	if (PyString_Check(obj1)) {
3753	<	temp2 = std::string(PyString_AsString(obj1));
3754	<	arg2 = &temp2;
3755	<	}else {
3756	<	SWIG_exception(SWIG_TypeError, "string expected");
3752	>	try {
3753	>	result = (char *)((BossTaskException const *)arg1)->what();
3754	>
3755	>	}catch (const BossSchedFailure & e) {
3756	>	PyErr_SetString ( SchedulerError, e.what() );
3757	>	return NULL;
3758	>	}catch (const std::exception& e) {
3759	>	PyErr_SetString ( BossError, e.what() );
3760	>	return NULL;
3761		}
3762		}
3763	+	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3764	+	return resultobj;
3765	+	fail:
3766	+	return NULL;
3767	+	}
3768	+
3769	+
3770	+	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3771	+	PyObject *resultobj;
3772	+	BossTaskException *arg1 = (BossTaskException *) 0 ;
3773	+	PyObject * obj0 = 0 ;
3774	+
3775	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3776	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3777		{
3778		try {
3779	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3779	>	delete arg1;
3780
3781	+	}catch (const BossSchedFailure & e) {
3782	+	PyErr_SetString ( SchedulerError, e.what() );
3783	+	return NULL;
3784		}catch (const std::exception& e) {
3785	<	SWIG_exception(SWIG_RuntimeError, e.what());
3785	>	PyErr_SetString ( BossError, e.what() );
3786	>	return NULL;
3787		}
3788		}
3789	<	resultobj = result;
3789	>	Py_INCREF(Py_None); resultobj = Py_None;
3790		return resultobj;
3791		fail:
3792		return NULL;
3793		}
3794
3795
3796	+	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3797	+	PyObject *obj;
3798	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3799	+	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3800	+	Py_INCREF(obj);
3801	+	return Py_BuildValue((char *)"");
3802	+	}
3803		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3804		PyObject *resultobj;
3805		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 3067 | Line 3812 | static PyObject *_wrap_new_BossTask__SWI
3812		try {
3813		result = (BossTask *)new BossTask(arg1);
3814
3815	+	}catch (const BossSchedFailure & e) {
3816	+	PyErr_SetString ( SchedulerError, e.what() );
3817	+	return NULL;
3818		}catch (const std::exception& e) {
3819	<	SWIG_exception(SWIG_RuntimeError, e.what());
3819	>	PyErr_SetString ( BossError, e.what() );
3820	>	return NULL;
3821		}
3822		}
3823		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3101 | Line 3850 | static PyObject *_wrap_new_BossTask__SWI
3850		try {
3851		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3852
3853	+	}catch (const BossSchedFailure & e) {
3854	+	PyErr_SetString ( SchedulerError, e.what() );
3855	+	return NULL;
3856		}catch (const std::exception& e) {
3857	<	SWIG_exception(SWIG_RuntimeError, e.what());
3857	>	PyErr_SetString ( BossError, e.what() );
3858	>	return NULL;
3859		}
3860		}
3861		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3123 | Line 3876 | static PyObject *_wrap_delete_BossTask(P
3876		try {
3877		delete arg1;
3878
3879	+	}catch (const BossSchedFailure & e) {
3880	+	PyErr_SetString ( SchedulerError, e.what() );
3881	+	return NULL;
3882		}catch (const std::exception& e) {
3883	<	SWIG_exception(SWIG_RuntimeError, e.what());
3883	>	PyErr_SetString ( BossError, e.what() );
3884	>	return NULL;
3885		}
3886		}
3887		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3149 | Line 3906 | static PyObject *_wrap_new_BossTask__SWI
3906		try {
3907		result = (BossTask *)new BossTask((BossTask const &)*arg1);
3908
3909	+	}catch (const BossSchedFailure & e) {
3910	+	PyErr_SetString ( SchedulerError, e.what() );
3911	+	return NULL;
3912		}catch (const std::exception& e) {
3913	<	SWIG_exception(SWIG_RuntimeError, e.what());
3913	>	PyErr_SetString ( BossError, e.what() );
3914	>	return NULL;
3915		}
3916		}
3917		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3240 | Line 4001 | static PyObject *_wrap_BossTask_id(PyObj
4001		result = (std::string *) &_result_ref;
4002		}
4003
4004	+	}catch (const BossSchedFailure & e) {
4005	+	PyErr_SetString ( SchedulerError, e.what() );
4006	+	return NULL;
4007		}catch (const std::exception& e) {
4008	<	SWIG_exception(SWIG_RuntimeError, e.what());
4008	>	PyErr_SetString ( BossError, e.what() );
4009	>	return NULL;
4010		}
4011		}
4012		{
#	Line 3268 | Line 4033 | static PyObject *_wrap_BossTask_name(PyO
4033		result = (std::string *) &_result_ref;
4034		}
4035
4036	+	}catch (const BossSchedFailure & e) {
4037	+	PyErr_SetString ( SchedulerError, e.what() );
4038	+	return NULL;
4039		}catch (const std::exception& e) {
4040	<	SWIG_exception(SWIG_RuntimeError, e.what());
4040	>	PyErr_SetString ( BossError, e.what() );
4041	>	return NULL;
4042		}
4043		}
4044		{
#	Line 3281 | Line 4050 | static PyObject *_wrap_BossTask_name(PyO
4050		}
4051
4052
4053	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
4053	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4054		PyObject *resultobj;
4055		BossTask *arg1 = (BossTask *) 0 ;
4056	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4056	>	std::map<std::string,std::string > result;
4057		PyObject * obj0 = 0 ;
4058
4059	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4059	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4060		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4061		{
4062		try {
4063	<	result = ((BossTask const *)arg1)->jobsMap();
4063	>	result = ((BossTask const *)arg1)->taskMap();
4064
4065	+	}catch (const BossSchedFailure & e) {
4066	+	PyErr_SetString ( SchedulerError, e.what() );
4067	+	return NULL;
4068		}catch (const std::exception& e) {
4069	<	SWIG_exception(SWIG_RuntimeError, e.what());
4069	>	PyErr_SetString ( BossError, e.what() );
4070	>	return NULL;
4071		}
4072		}
4073		{
4074	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4075	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4076	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4074	>	resultobj = PyDict_New();
4075	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4076	>	PyDict_SetItem(resultobj,
4077	>	SwigString_FromString(i->first),
4078	>	SwigString_FromString(i->second));
4079	>	}
4080		}
4081		return resultobj;
4082		fail:
#	Line 3308 | Line 4084 | static PyObject *_wrap_BossTask_jobsMap_
4084		}
4085
4086
4087	<	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4087	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4088		PyObject *resultobj;
4089		BossTask *arg1 = (BossTask *) 0 ;
4090	<	unsigned int arg2 ;
3315	<	std::map<std::string,std::string > result;
4090	>	BossTask::job_iterator result;
4091		PyObject * obj0 = 0 ;
3317	–	PyObject * obj1 = 0 ;
4092
4093	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4093	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4094		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3321	–	arg2 = (unsigned int) PyInt_AsLong(obj1);
3322	–	if (PyErr_Occurred()) SWIG_fail;
4095		{
4096		try {
4097	<	result = ((BossTask const *)arg1)->jobMap(arg2);
4097	>	result = ((BossTask const *)arg1)->job_begin();
4098
4099	+	}catch (const BossSchedFailure & e) {
4100	+	PyErr_SetString ( SchedulerError, e.what() );
4101	+	return NULL;
4102		}catch (const std::exception& e) {
4103	<	SWIG_exception(SWIG_RuntimeError, e.what());
4103	>	PyErr_SetString ( BossError, e.what() );
4104	>	return NULL;
4105		}
4106		}
4107		{
4108	<	resultobj = PyDict_New();
4109	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4110	<	PyDict_SetItem(resultobj,
4111	<	SwigString_FromString(i->first),
4112	<	SwigString_FromString(i->second));
4108	>	BossTask::job_iterator * resultptr;
4109	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4110	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4111	>	}
4112	>	return resultobj;
4113	>	fail:
4114	>	return NULL;
4115	>	}
4116	>
4117	>
4118	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4119	>	PyObject *resultobj;
4120	>	BossTask *arg1 = (BossTask *) 0 ;
4121	>	BossTask::job_iterator result;
4122	>	PyObject * obj0 = 0 ;
4123	>
4124	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4125	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4126	>	{
4127	>	try {
4128	>	result = ((BossTask const *)arg1)->job_end();
4129	>
4130	>	}catch (const BossSchedFailure & e) {
4131	>	PyErr_SetString ( SchedulerError, e.what() );
4132	>	return NULL;
4133	>	}catch (const std::exception& e) {
4134	>	PyErr_SetString ( BossError, e.what() );
4135	>	return NULL;
4136		}
4137		}
4138	+	{
4139	+	BossTask::job_iterator * resultptr;
4140	+	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4141	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4142	+	}
4143		return resultobj;
4144		fail:
4145		return NULL;
4146		}
4147
4148
4149	<	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4149	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4150	>	PyObject *resultobj;
4151	>	BossTask *arg1 = (BossTask *) 0 ;
4152	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4153	>	PyObject * obj0 = 0 ;
4154	>
4155	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4156	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4157	>	{
4158	>	try {
4159	>	result = ((BossTask const *)arg1)->jobsMap();
4160	>
4161	>	}catch (const BossSchedFailure & e) {
4162	>	PyErr_SetString ( SchedulerError, e.what() );
4163	>	return NULL;
4164	>	}catch (const std::exception& e) {
4165	>	PyErr_SetString ( BossError, e.what() );
4166	>	return NULL;
4167	>	}
4168	>	}
4169	>	{
4170	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4171	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4172	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4173	>	}
4174	>	return resultobj;
4175	>	fail:
4176	>	return NULL;
4177	>	}
4178	>
4179	>
4180	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4181		PyObject *resultobj;
4182		BossTask *arg1 = (BossTask *) 0 ;
4183		SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
#	Line 3365 | Line 4200 | static PyObject *_wrap_BossTask_jobMap__
4200		try {
4201		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4202
4203	+	}catch (const BossSchedFailure & e) {
4204	+	PyErr_SetString ( SchedulerError, e.what() );
4205	+	return NULL;
4206		}catch (const std::exception& e) {
4207	<	SWIG_exception(SWIG_RuntimeError, e.what());
4207	>	PyErr_SetString ( BossError, e.what() );
4208	>	return NULL;
4209		}
4210		}
4211		{
#	Line 3378 | Line 4217 | static PyObject *_wrap_BossTask_jobMap__
4217		}
4218
4219
4220	+	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4221	+	PyObject *resultobj;
4222	+	BossTask *arg1 = (BossTask *) 0 ;
4223	+	unsigned int arg2 ;
4224	+	std::map<std::string,std::string > result;
4225	+	PyObject * obj0 = 0 ;
4226	+	PyObject * obj1 = 0 ;
4227	+
4228	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4229	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4230	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
4231	+	if (PyErr_Occurred()) SWIG_fail;
4232	+	{
4233	+	try {
4234	+	result = ((BossTask const *)arg1)->jobMap(arg2);
4235	+
4236	+	}catch (const BossSchedFailure & e) {
4237	+	PyErr_SetString ( SchedulerError, e.what() );
4238	+	return NULL;
4239	+	}catch (const std::exception& e) {
4240	+	PyErr_SetString ( BossError, e.what() );
4241	+	return NULL;
4242	+	}
4243	+	}
4244	+	{
4245	+	resultobj = PyDict_New();
4246	+	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4247	+	PyDict_SetItem(resultobj,
4248	+	SwigString_FromString(i->first),
4249	+	SwigString_FromString(i->second));
4250	+	}
4251	+	}
4252	+	return resultobj;
4253	+	fail:
4254	+	return NULL;
4255	+	}
4256	+
4257	+
4258		static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4259		int argc;
4260		PyObject *argv[4];
#	Line 3403 | Line 4280 | static PyObject *_wrap_BossTask_jobMap(P
4280		_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4281		}
4282		if (_v) {
4283	<	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4283	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4284		}
4285		}
4286		}
#	Line 3439 | Line 4316 | static PyObject *_wrap_BossTask_jobMap(P
4316		}
4317		}
4318		if (_v) {
4319	<	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4319	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4320		}
4321		}
4322		}
#	Line 3450 | Line 4327 | static PyObject *_wrap_BossTask_jobMap(P
4327		}
4328
4329
4330	<	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3454	<	PyObject *resultobj;
3455	<	BossTask *arg1 = (BossTask *) 0 ;
3456	<	BossTask::job_iterator result;
3457	<	PyObject * obj0 = 0 ;
3458	<
3459	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3460	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3461	<	{
3462	<	try {
3463	<	result = ((BossTask const *)arg1)->job_begin();
3464	<
3465	<	}catch (const std::exception& e) {
3466	<	SWIG_exception(SWIG_RuntimeError, e.what());
3467	<	}
3468	<	}
3469	<	{
3470	<	BossTask::job_iterator * resultptr;
3471	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3472	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3473	<	}
3474	<	return resultobj;
3475	<	fail:
3476	<	return NULL;
3477	<	}
3478	<
3479	<
3480	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4330	>	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4331		PyObject *resultobj;
4332		BossTask *arg1 = (BossTask *) 0 ;
4333	<	BossTask::job_iterator result;
4333	>	BossJob *arg2 = (BossJob *) 0 ;
4334	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4335		PyObject * obj0 = 0 ;
4336	+	PyObject * obj1 = 0 ;
4337
4338	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4338	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4339		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4340	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4341		{
4342		try {
4343	<	result = ((BossTask const *)arg1)->job_end();
4343	>	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4344
4345	+	}catch (const BossSchedFailure & e) {
4346	+	PyErr_SetString ( SchedulerError, e.what() );
4347	+	return NULL;
4348		}catch (const std::exception& e) {
4349	<	SWIG_exception(SWIG_RuntimeError, e.what());
4349	>	PyErr_SetString ( BossError, e.what() );
4350	>	return NULL;
4351		}
4352		}
4353		{
4354	<	BossTask::job_iterator * resultptr;
4355	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4356	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4354	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4355	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4356	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4357		}
4358		return resultobj;
4359		fail:
#	Line 3519 | Line 4376 | static PyObject *_wrap_BossTask_queryJob
4376		try {
4377		result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4378
4379	+	}catch (const BossSchedFailure & e) {
4380	+	PyErr_SetString ( SchedulerError, e.what() );
4381	+	return NULL;
4382		}catch (const std::exception& e) {
4383	<	SWIG_exception(SWIG_RuntimeError, e.what());
4383	>	PyErr_SetString ( BossError, e.what() );
4384	>	return NULL;
4385		}
4386		}
4387		{
#	Line 3534 | Line 4395 | static PyObject *_wrap_BossTask_queryJob
4395		}
4396
4397
3537	–	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
3538	–	PyObject *resultobj;
3539	–	BossTask *arg1 = (BossTask *) 0 ;
3540	–	BossJob *arg2 = (BossJob *) 0 ;
3541	–	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3542	–	PyObject * obj0 = 0 ;
3543	–	PyObject * obj1 = 0 ;
3544	–
3545	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
3546	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3547	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3548	–	{
3549	–	try {
3550	–	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
3551	–
3552	–	}catch (const std::exception& e) {
3553	–	SWIG_exception(SWIG_RuntimeError, e.what());
3554	–	}
3555	–	}
3556	–	{
3557	–	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3558	–	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3559	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3560	–	}
3561	–	return resultobj;
3562	–	fail:
3563	–	return NULL;
3564	–	}
3565	–
3566	–
4398		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4399		PyObject *resultobj;
4400		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3600 | Line 4431 | static PyObject *_wrap_BossTask_declare_
4431		try {
4432		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4433
4434	+	}catch (const BossSchedFailure & e) {
4435	+	PyErr_SetString ( SchedulerError, e.what() );
4436	+	return NULL;
4437		}catch (const std::exception& e) {
4438	<	SWIG_exception(SWIG_RuntimeError, e.what());
4438	>	PyErr_SetString ( BossError, e.what() );
4439	>	return NULL;
4440		}
4441		}
4442		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3639 | Line 4474 | static PyObject *_wrap_BossTask_declare_
4474		try {
4475		(arg1)->declare(arg2,(std::string const &)*arg3);
4476
4477	+	}catch (const BossSchedFailure & e) {
4478	+	PyErr_SetString ( SchedulerError, e.what() );
4479	+	return NULL;
4480		}catch (const std::exception& e) {
4481	<	SWIG_exception(SWIG_RuntimeError, e.what());
4481	>	PyErr_SetString ( BossError, e.what() );
4482	>	return NULL;
4483		}
4484		}
4485		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3738 | Line 4577 | static PyObject *_wrap_BossTask_remove(P
4577		try {
4578		(arg1)->remove();
4579
4580	+	}catch (const BossSchedFailure & e) {
4581	+	PyErr_SetString ( SchedulerError, e.what() );
4582	+	return NULL;
4583		}catch (const std::exception& e) {
4584	<	SWIG_exception(SWIG_RuntimeError, e.what());
4584	>	PyErr_SetString ( BossError, e.what() );
4585	>	return NULL;
4586		}
4587		}
4588		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3774 | Line 4617 | static PyObject *_wrap_BossTask_archive(
4617		try {
4618		(arg1)->archive((std::string const &)*arg2);
4619
4620	+	}catch (const BossSchedFailure & e) {
4621	+	PyErr_SetString ( SchedulerError, e.what() );
4622	+	return NULL;
4623		}catch (const std::exception& e) {
4624	<	SWIG_exception(SWIG_RuntimeError, e.what());
4624	>	PyErr_SetString ( BossError, e.what() );
4625	>	return NULL;
4626		}
4627		}
4628		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3785 | Line 4632 | static PyObject *_wrap_BossTask_archive(
4632		}
4633
4634
3788	–	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3789	–	PyObject *resultobj;
3790	–	BossTask *arg1 = (BossTask *) 0 ;
3791	–	std::map<std::string,std::string > result;
3792	–	PyObject * obj0 = 0 ;
3793	–
3794	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3795	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3796	–	{
3797	–	try {
3798	–	result = ((BossTask const *)arg1)->taskMap();
3799	–
3800	–	}catch (const std::exception& e) {
3801	–	SWIG_exception(SWIG_RuntimeError, e.what());
3802	–	}
3803	–	}
3804	–	{
3805	–	resultobj = PyDict_New();
3806	–	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3807	–	PyDict_SetItem(resultobj,
3808	–	SwigString_FromString(i->first),
3809	–	SwigString_FromString(i->second));
3810	–	}
3811	–	}
3812	–	return resultobj;
3813	–	fail:
3814	–	return NULL;
3815	–	}
3816	–
3817	–
4635		static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4636		PyObject *resultobj;
4637		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3828 | Line 4645 | static PyObject *_wrap_BossTask_submit(P
4645		std::string *arg5 = (std::string *) &arg5_defvalue ;
4646		std::string const &arg6_defvalue = "" ;
4647		std::string *arg6 = (std::string *) &arg6_defvalue ;
4648	<	bool arg7 = (bool) false ;
4648	>	unsigned int arg7 = (unsigned int) 0 ;
4649	>	bool arg8 = (bool) false ;
4650		int result;
4651		std::string temp2 ;
4652		std::string temp3 ;
#	Line 3842 | Line 4660 | static PyObject *_wrap_BossTask_submit(P
4660		PyObject * obj4 = 0 ;
4661		PyObject * obj5 = 0 ;
4662		PyObject * obj6 = 0 ;
4663	+	PyObject * obj7 = 0 ;
4664
4665	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4665	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4666		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4667		if (obj1) {
4668		{
#	Line 3896 | Line 4715 | static PyObject *_wrap_BossTask_submit(P
4715		}
4716		}
4717		if (obj6) {
4718	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4718	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4719	>	if (PyErr_Occurred()) SWIG_fail;
4720	>	}
4721	>	if (obj7) {
4722	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4723		if (PyErr_Occurred()) SWIG_fail;
4724		}
4725		{
4726		try {
4727	<	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);
4727	>	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);
4728
4729	+	}catch (const BossSchedFailure & e) {
4730	+	PyErr_SetString ( SchedulerError, e.what() );
4731	+	return NULL;
4732		}catch (const std::exception& e) {
4733	<	SWIG_exception(SWIG_RuntimeError, e.what());
4733	>	PyErr_SetString ( BossError, e.what() );
4734	>	return NULL;
4735		}
4736		}
4737		resultobj = PyInt_FromLong((long)result);
#	Line 3943 | Line 4770 | static PyObject *_wrap_BossTask_reSubmit
4770		try {
4771		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4772
4773	+	}catch (const BossSchedFailure & e) {
4774	+	PyErr_SetString ( SchedulerError, e.what() );
4775	+	return NULL;
4776		}catch (const std::exception& e) {
4777	<	SWIG_exception(SWIG_RuntimeError, e.what());
4777	>	PyErr_SetString ( BossError, e.what() );
4778	>	return NULL;
4779		}
4780		}
4781		resultobj = PyInt_FromLong((long)result);
#	Line 3958 | Line 4789 | static PyObject *_wrap_BossTask_kill(PyO
4789		PyObject *resultobj;
4790		BossTask *arg1 = (BossTask *) 0 ;
4791		std::string *arg2 = 0 ;
4792	<	bool arg3 = (bool) false ;
4792	>	unsigned int arg3 = (unsigned int) 0 ;
4793	>	bool arg4 = (bool) false ;
4794		int result;
4795		std::string temp2 ;
4796		PyObject * obj0 = 0 ;
4797		PyObject * obj1 = 0 ;
4798		PyObject * obj2 = 0 ;
4799	+	PyObject * obj3 = 0 ;
4800
4801	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4801	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
4802		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4803		{
4804		if (PyString_Check(obj1)) {
#	Line 3976 | Line 4809 | static PyObject *_wrap_BossTask_kill(PyO
4809		}
4810		}
4811		if (obj2) {
4812	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4812	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
4813	>	if (PyErr_Occurred()) SWIG_fail;
4814	>	}
4815	>	if (obj3) {
4816	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4817		if (PyErr_Occurred()) SWIG_fail;
4818		}
4819		{
4820		try {
4821	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4821	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
4822
4823	+	}catch (const BossSchedFailure & e) {
4824	+	PyErr_SetString ( SchedulerError, e.what() );
4825	+	return NULL;
4826		}catch (const std::exception& e) {
4827	<	SWIG_exception(SWIG_RuntimeError, e.what());
4827	>	PyErr_SetString ( BossError, e.what() );
4828	>	return NULL;
4829		}
4830		}
4831		resultobj = PyInt_FromLong((long)result);
#	Line 3994 | Line 4835 | static PyObject *_wrap_BossTask_kill(PyO
4835		}
4836
4837
4838	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
4838	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4839		PyObject *resultobj;
4840		BossTask *arg1 = (BossTask *) 0 ;
4841		std::string const &arg2_defvalue = "all" ;
4842		std::string *arg2 = (std::string *) &arg2_defvalue ;
4843		std::string const &arg3_defvalue = "" ;
4844		std::string *arg3 = (std::string *) &arg3_defvalue ;
4845	<	bool arg4 = (bool) false ;
4845	>	unsigned int arg4 = (unsigned int) 0 ;
4846		bool arg5 = (bool) false ;
4847	+	bool arg6 = (bool) false ;
4848		int result;
4849		std::string temp2 ;
4850		std::string temp3 ;
#	Line 4011 | Line 4853 | static PyObject *_wrap_BossTask_getOutpu
4853		PyObject * obj2 = 0 ;
4854		PyObject * obj3 = 0 ;
4855		PyObject * obj4 = 0 ;
4856	+	PyObject * obj5 = 0 ;
4857
4858	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4858	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
4859		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4860		if (obj1) {
4861		{
#	Line 4035 | Line 4878 | static PyObject *_wrap_BossTask_getOutpu
4878		}
4879		}
4880		if (obj3) {
4881	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4881	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
4882		if (PyErr_Occurred()) SWIG_fail;
4883		}
4884		if (obj4) {
4885		arg5 = PyInt_AsLong(obj4) ? true : false;
4886		if (PyErr_Occurred()) SWIG_fail;
4887		}
4888	+	if (obj5) {
4889	+	arg6 = PyInt_AsLong(obj5) ? true : false;
4890	+	if (PyErr_Occurred()) SWIG_fail;
4891	+	}
4892		{
4893		try {
4894	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4894	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
4895
4896	+	}catch (const BossSchedFailure & e) {
4897	+	PyErr_SetString ( SchedulerError, e.what() );
4898	+	return NULL;
4899		}catch (const std::exception& e) {
4900	<	SWIG_exception(SWIG_RuntimeError, e.what());
4900	>	PyErr_SetString ( BossError, e.what() );
4901	>	return NULL;
4902		}
4903		}
4904		resultobj = PyInt_FromLong((long)result);
#	Line 4057 | Line 4908 | static PyObject *_wrap_BossTask_getOutpu
4908		}
4909
4910
4911	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
4911	>	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4912		PyObject *resultobj;
4913		BossTask *arg1 = (BossTask *) 0 ;
4914	<	std::string const &arg2_defvalue = "" ;
4915	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
4916	<	bool arg3 = (bool) false ;
4917	<	bool arg4 = (bool) false ;
4914	>	int arg2 = (int) SCHEDULED ;
4915	>	std::string const &arg3_defvalue = "all" ;
4916	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4917	>	std::string const &arg4_defvalue = "" ;
4918	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4919	>	std::string arg5 = (std::string) "" ;
4920	>	std::string arg6 = (std::string) "" ;
4921	>	std::string arg7 = (std::string) "" ;
4922	>	std::string arg8 = (std::string) "" ;
4923		int result;
4924	<	std::string temp2 ;
4924	>	std::string temp3 ;
4925	>	std::string temp4 ;
4926		PyObject * obj0 = 0 ;
4070	–	PyObject * obj1 = 0 ;
4927		PyObject * obj2 = 0 ;
4928		PyObject * obj3 = 0 ;
4929	+	PyObject * obj4 = 0 ;
4930	+	PyObject * obj5 = 0 ;
4931	+	PyObject * obj6 = 0 ;
4932	+	PyObject * obj7 = 0 ;
4933
4934	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4934	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4935		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4936	<	if (obj1) {
4936	>	if (obj2) {
4937		{
4938	<	if (PyString_Check(obj1)) {
4939	<	temp2 = std::string(PyString_AsString(obj1));
4940	<	arg2 = &temp2;
4938	>	if (PyString_Check(obj2)) {
4939	>	temp3 = std::string(PyString_AsString(obj2));
4940	>	arg3 = &temp3;
4941		}else {
4942		SWIG_exception(SWIG_TypeError, "string expected");
4943		}
4944		}
4945		}
4086	–	if (obj2) {
4087	–	arg3 = PyInt_AsLong(obj2) ? true : false;
4088	–	if (PyErr_Occurred()) SWIG_fail;
4089	–	}
4946		if (obj3) {
4947	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4948	<	if (PyErr_Occurred()) SWIG_fail;
4949	<	}
4950	<	{
4951	<	try {
4952	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
4953	<
4098	<	}catch (const std::exception& e) {
4099	<	SWIG_exception(SWIG_RuntimeError, e.what());
4947	>	{
4948	>	if (PyString_Check(obj3)) {
4949	>	temp4 = std::string(PyString_AsString(obj3));
4950	>	arg4 = &temp4;
4951	>	}else {
4952	>	SWIG_exception(SWIG_TypeError, "string expected");
4953	>	}
4954		}
4955		}
4956	<	resultobj = PyInt_FromLong((long)result);
4957	<	return resultobj;
4958	<	fail:
4959	<	return NULL;
4960	<	}
4961	<
4962	<
4109	<	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4110	<	int argc;
4111	<	PyObject *argv[6];
4112	<	int ii;
4113	<
4114	<	argc = PyObject_Length(args);
4115	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
4116	<	argv[ii] = PyTuple_GetItem(args,ii);
4956	>	if (obj4) {
4957	>	{
4958	>	if (PyString_Check(obj4))
4959	>	arg5 = std::string(PyString_AsString(obj4));
4960	>	else
4961	>	SWIG_exception(SWIG_TypeError, "string expected");
4962	>	}
4963		}
4964	<	if ((argc >= 1) && (argc <= 5)) {
4119	<	int _v;
4964	>	if (obj5) {
4965		{
4966	<	void *ptr;
4967	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4968	<	_v = 0;
4969	<	PyErr_Clear();
4125	<	}else {
4126	<	_v = 1;
4127	<	}
4966	>	if (PyString_Check(obj5))
4967	>	arg6 = std::string(PyString_AsString(obj5));
4968	>	else
4969	>	SWIG_exception(SWIG_TypeError, "string expected");
4970		}
4971	<	if (_v) {
4972	<	if (argc <= 1) {
4973	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4974	<	}
4975	<	{
4976	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4977	<	}
4136	<	if (_v) {
4137	<	if (argc <= 2) {
4138	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4139	<	}
4140	<	{
4141	<	_v = PyString_Check(argv[2]) ? 1 : 0;
4142	<	}
4143	<	if (_v) {
4144	<	if (argc <= 3) {
4145	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4146	<	}
4147	<	{
4148	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4149	<	}
4150	<	if (_v) {
4151	<	if (argc <= 4) {
4152	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4153	<	}
4154	<	{
4155	<	_v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
4156	<	}
4157	<	if (_v) {
4158	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4159	<	}
4160	<	}
4161	<	}
4162	<	}
4971	>	}
4972	>	if (obj6) {
4973	>	{
4974	>	if (PyString_Check(obj6))
4975	>	arg7 = std::string(PyString_AsString(obj6));
4976	>	else
4977	>	SWIG_exception(SWIG_TypeError, "string expected");
4978		}
4979		}
4980	<	if ((argc >= 1) && (argc <= 4)) {
4166	<	int _v;
4980	>	if (obj7) {
4981		{
4982	<	void *ptr;
4983	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4984	<	_v = 0;
4985	<	PyErr_Clear();
4172	<	}else {
4173	<	_v = 1;
4174	<	}
4982	>	if (PyString_Check(obj7))
4983	>	arg8 = std::string(PyString_AsString(obj7));
4984	>	else
4985	>	SWIG_exception(SWIG_TypeError, "string expected");
4986		}
4987	<	if (_v) {
4988	<	if (argc <= 1) {
4989	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4990	<	}
4991	<	{
4992	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4993	<	}
4994	<	if (_v) {
4995	<	if (argc <= 2) {
4996	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4997	<	}
4187	<	{
4188	<	_v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
4189	<	}
4190	<	if (_v) {
4191	<	if (argc <= 3) {
4192	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4193	<	}
4194	<	{
4195	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4196	<	}
4197	<	if (_v) {
4198	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4199	<	}
4200	<	}
4201	<	}
4987	>	}
4988	>	{
4989	>	try {
4990	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4991	>
4992	>	}catch (const BossSchedFailure & e) {
4993	>	PyErr_SetString ( SchedulerError, e.what() );
4994	>	return NULL;
4995	>	}catch (const std::exception& e) {
4996	>	PyErr_SetString ( BossError, e.what() );
4997	>	return NULL;
4998		}
4999		}
5000	<
5001	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
5000	>	resultobj = PyInt_FromLong((long)result);
5001	>	return resultobj;
5002	>	fail:
5003		return NULL;
5004		}
5005
#	Line 4219 | Line 5016 | static PyObject *_wrap_BossTask_query(Py
5016		std::string arg6 = (std::string) "" ;
5017		std::string arg7 = (std::string) "" ;
5018		std::string arg8 = (std::string) "" ;
5019	<	bool arg9 = (bool) false ;
5019	>	unsigned int arg9 = (unsigned int) 0 ;
5020	>	bool arg10 = (bool) false ;
5021		int result;
5022		std::string temp3 ;
5023		std::string temp4 ;
#	Line 4231 | Line 5029 | static PyObject *_wrap_BossTask_query(Py
5029		PyObject * obj6 = 0 ;
5030		PyObject * obj7 = 0 ;
5031		PyObject * obj8 = 0 ;
5032	+	PyObject * obj9 = 0 ;
5033
5034	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5034	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5035		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5036		if (obj2) {
5037		{
#	Line 4287 | Line 5086 | static PyObject *_wrap_BossTask_query(Py
5086		}
5087		}
5088		if (obj8) {
5089	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5089	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5090	>	if (PyErr_Occurred()) SWIG_fail;
5091	>	}
5092	>	if (obj9) {
5093	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5094		if (PyErr_Occurred()) SWIG_fail;
5095		}
5096		{
5097		try {
5098	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5098	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5099
5100	+	}catch (const BossSchedFailure & e) {
5101	+	PyErr_SetString ( SchedulerError, e.what() );
5102	+	return NULL;
5103		}catch (const std::exception& e) {
5104	<	SWIG_exception(SWIG_RuntimeError, e.what());
5104	>	PyErr_SetString ( BossError, e.what() );
5105	>	return NULL;
5106		}
5107		}
5108		resultobj = PyInt_FromLong((long)result);
#	Line 4353 | Line 5160 | static PyObject *_wrap_BossTask_query_ou
5160		try {
5161		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5162
5163	+	}catch (const BossSchedFailure & e) {
5164	+	PyErr_SetString ( SchedulerError, e.what() );
5165	+	return NULL;
5166		}catch (const std::exception& e) {
5167	<	SWIG_exception(SWIG_RuntimeError, e.what());
5167	>	PyErr_SetString ( BossError, e.what() );
5168	>	return NULL;
5169		}
5170		}
5171		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4375 | Line 5186 | static PyObject *_wrap_BossTask_clear(Py
5186		try {
5187		(arg1)->clear();
5188
5189	+	}catch (const BossSchedFailure & e) {
5190	+	PyErr_SetString ( SchedulerError, e.what() );
5191	+	return NULL;
5192	+	}catch (const std::exception& e) {
5193	+	PyErr_SetString ( BossError, e.what() );
5194	+	return NULL;
5195	+	}
5196	+	}
5197	+	Py_INCREF(Py_None); resultobj = Py_None;
5198	+	return resultobj;
5199	+	fail:
5200	+	return NULL;
5201	+	}
5202	+
5203	+
5204	+	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5205	+	PyObject *resultobj;
5206	+	BossTask *arg1 = (BossTask *) 0 ;
5207	+	PyObject *arg2 = (PyObject *) 0 ;
5208	+	BossAttributeContainer *arg3 = 0 ;
5209	+	PyObject * obj0 = 0 ;
5210	+	PyObject * obj1 = 0 ;
5211	+	PyObject * obj2 = 0 ;
5212	+
5213	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5214	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5215	+	arg2 = obj1;
5216	+	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5217	+	if (arg3 == NULL) {
5218	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5219	+	}
5220	+	{
5221	+	try {
5222	+	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5223	+
5224	+	}catch (const BossSchedFailure & e) {
5225	+	PyErr_SetString ( SchedulerError, e.what() );
5226	+	return NULL;
5227	+	}catch (const std::exception& e) {
5228	+	PyErr_SetString ( BossError, e.what() );
5229	+	return NULL;
5230	+	}
5231	+	}
5232	+	Py_INCREF(Py_None); resultobj = Py_None;
5233	+	return resultobj;
5234	+	fail:
5235	+	return NULL;
5236	+	}
5237	+
5238	+
5239	+	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5240	+	PyObject *resultobj;
5241	+	BossTask *arg1 = (BossTask *) 0 ;
5242	+	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5243	+	PyObject *arg3 = (PyObject *) 0 ;
5244	+	PyObject * obj0 = 0 ;
5245	+	PyObject * obj1 = 0 ;
5246	+	PyObject * obj2 = 0 ;
5247	+
5248	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5249	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5250	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5251	+	if (arg2 == NULL) {
5252	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5253	+	}
5254	+	arg3 = obj2;
5255	+	{
5256	+	try {
5257	+	BossTask_jobDict((BossTask const *)arg1,*arg2,arg3);
5258	+
5259	+	}catch (const BossSchedFailure & e) {
5260	+	PyErr_SetString ( SchedulerError, e.what() );
5261	+	return NULL;
5262		}catch (const std::exception& e) {
5263	<	SWIG_exception(SWIG_RuntimeError, e.what());
5263	>	PyErr_SetString ( BossError, e.what() );
5264	>	return NULL;
5265		}
5266		}
5267		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4386 | Line 5271 | static PyObject *_wrap_BossTask_clear(Py
5271		}
5272
5273
5274	<	static PyObject *_wrap_BossTask_prompt(PyObject *self, PyObject *args) {
5274	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5275	>	PyObject *resultobj;
5276	>	BossTask *arg1 = (BossTask *) 0 ;
5277	>	PyObject *result;
5278	>	PyObject * obj0 = 0 ;
5279	>
5280	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5281	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5282	>	{
5283	>	try {
5284	>	result = (PyObject *)BossTask_jobsDict(arg1);
5285	>
5286	>	}catch (const BossSchedFailure & e) {
5287	>	PyErr_SetString ( SchedulerError, e.what() );
5288	>	return NULL;
5289	>	}catch (const std::exception& e) {
5290	>	PyErr_SetString ( BossError, e.what() );
5291	>	return NULL;
5292	>	}
5293	>	}
5294	>	resultobj = result;
5295	>	return resultobj;
5296	>	fail:
5297	>	return NULL;
5298	>	}
5299	>
5300	>
5301	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5302	>	PyObject *resultobj;
5303	>	BossTask *arg1 = (BossTask *) 0 ;
5304	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5305	>	PyObject *result;
5306	>	PyObject * obj0 = 0 ;
5307	>	PyObject * obj1 = 0 ;
5308	>
5309	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5310	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5311	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5312	>	if (arg2 == NULL) {
5313	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5314	>	}
5315	>	{
5316	>	try {
5317	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5318	>
5319	>	}catch (const BossSchedFailure & e) {
5320	>	PyErr_SetString ( SchedulerError, e.what() );
5321	>	return NULL;
5322	>	}catch (const std::exception& e) {
5323	>	PyErr_SetString ( BossError, e.what() );
5324	>	return NULL;
5325	>	}
5326	>	}
5327	>	resultobj = result;
5328	>	return resultobj;
5329	>	fail:
5330	>	return NULL;
5331	>	}
5332	>
5333	>
5334	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5335		PyObject *resultobj;
5336		BossTask *arg1 = (BossTask *) 0 ;
5337		std::string *arg2 = 0 ;
5338	<	bool result;
5338	>	PyObject *result;
5339		std::string temp2 ;
5340		PyObject * obj0 = 0 ;
5341		PyObject * obj1 = 0 ;
5342
5343	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_prompt",&obj0,&obj1)) goto fail;
5343	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5344		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5345		{
5346		if (PyString_Check(obj1)) {
#	Line 4407 | Line 5352 | static PyObject *_wrap_BossTask_prompt(P
5352		}
5353		{
5354		try {
5355	<	result = (bool)(arg1)->prompt((std::string const &)*arg2);
5355	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5356
5357	+	}catch (const BossSchedFailure & e) {
5358	+	PyErr_SetString ( SchedulerError, e.what() );
5359	+	return NULL;
5360		}catch (const std::exception& e) {
5361	<	SWIG_exception(SWIG_RuntimeError, e.what());
5361	>	PyErr_SetString ( BossError, e.what() );
5362	>	return NULL;
5363		}
5364		}
5365	<	resultobj = PyInt_FromLong((long)result);
5365	>	resultobj = result;
5366		return resultobj;
5367		fail:
5368		return NULL;
#	Line 4430 | Line 5379 | static PyObject * BossTask_swigregister(
5379		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5380		PyObject *resultobj;
5381		std::string arg1 = (std::string) "" ;
5382	<	bool arg2 = (bool) false ;
5382	>	std::string arg2 = (std::string) "2" ;
5383	>	std::string arg3 = (std::string) "" ;
5384	>	std::string arg4 = (std::string) "" ;
5385	>	bool arg5 = (bool) false ;
5386		BossAdministratorSession *result;
5387		PyObject * obj0 = 0 ;
5388		PyObject * obj1 = 0 ;
5389	+	PyObject * obj2 = 0 ;
5390	+	PyObject * obj3 = 0 ;
5391	+	PyObject * obj4 = 0 ;
5392
5393	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
5393	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5394		if (obj0) {
5395		{
5396		if (PyString_Check(obj0))
#	Line 4445 | Line 5400 | static PyObject *_wrap_new_BossAdministr
5400		}
5401		}
5402		if (obj1) {
5403	<	arg2 = PyInt_AsLong(obj1) ? true : false;
5403	>	{
5404	>	if (PyString_Check(obj1))
5405	>	arg2 = std::string(PyString_AsString(obj1));
5406	>	else
5407	>	SWIG_exception(SWIG_TypeError, "string expected");
5408	>	}
5409	>	}
5410	>	if (obj2) {
5411	>	{
5412	>	if (PyString_Check(obj2))
5413	>	arg3 = std::string(PyString_AsString(obj2));
5414	>	else
5415	>	SWIG_exception(SWIG_TypeError, "string expected");
5416	>	}
5417	>	}
5418	>	if (obj3) {
5419	>	{
5420	>	if (PyString_Check(obj3))
5421	>	arg4 = std::string(PyString_AsString(obj3));
5422	>	else
5423	>	SWIG_exception(SWIG_TypeError, "string expected");
5424	>	}
5425	>	}
5426	>	if (obj4) {
5427	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5428		if (PyErr_Occurred()) SWIG_fail;
5429		}
5430		{
5431		try {
5432	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
5432	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5433
5434	+	}catch (const BossSchedFailure & e) {
5435	+	PyErr_SetString ( SchedulerError, e.what() );
5436	+	return NULL;
5437		}catch (const std::exception& e) {
5438	<	SWIG_exception(SWIG_RuntimeError, e.what());
5438	>	PyErr_SetString ( BossError, e.what() );
5439	>	return NULL;
5440		}
5441		}
5442		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4474 | Line 5457 | static PyObject *_wrap_delete_BossAdmini
5457		try {
5458		delete arg1;
5459
5460	+	}catch (const BossSchedFailure & e) {
5461	+	PyErr_SetString ( SchedulerError, e.what() );
5462	+	return NULL;
5463		}catch (const std::exception& e) {
5464	<	SWIG_exception(SWIG_RuntimeError, e.what());
5464	>	PyErr_SetString ( BossError, e.what() );
5465	>	return NULL;
5466		}
5467		}
5468		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4485 | Line 5472 | static PyObject *_wrap_delete_BossAdmini
5472		}
5473
5474
5475	+	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
5476	+	PyObject *resultobj;
5477	+	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5478	+	int result;
5479	+	PyObject * obj0 = 0 ;
5480	+
5481	+	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
5482	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5483	+	{
5484	+	try {
5485	+	result = (int)(arg1)->configureDB();
5486	+
5487	+	}catch (const BossSchedFailure & e) {
5488	+	PyErr_SetString ( SchedulerError, e.what() );
5489	+	return NULL;
5490	+	}catch (const std::exception& e) {
5491	+	PyErr_SetString ( BossError, e.what() );
5492	+	return NULL;
5493	+	}
5494	+	}
5495	+	resultobj = PyInt_FromLong((long)result);
5496	+	return resultobj;
5497	+	fail:
5498	+	return NULL;
5499	+	}
5500	+
5501	+
5502		static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
5503		PyObject *resultobj;
5504		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
#	Line 4508 | Line 5522 | static PyObject *_wrap_BossAdministrator
5522		try {
5523		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5524
5525	+	}catch (const BossSchedFailure & e) {
5526	+	PyErr_SetString ( SchedulerError, e.what() );
5527	+	return NULL;
5528		}catch (const std::exception& e) {
5529	<	SWIG_exception(SWIG_RuntimeError, e.what());
5529	>	PyErr_SetString ( BossError, e.what() );
5530	>	return NULL;
5531		}
5532		}
5533		resultobj = PyInt_FromLong((long)result);
#	Line 4542 | Line 5560 | static PyObject *_wrap_BossAdministrator
5560		try {
5561		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5562
5563	+	}catch (const BossSchedFailure & e) {
5564	+	PyErr_SetString ( SchedulerError, e.what() );
5565	+	return NULL;
5566		}catch (const std::exception& e) {
5567	<	SWIG_exception(SWIG_RuntimeError, e.what());
5567	>	PyErr_SetString ( BossError, e.what() );
5568	>	return NULL;
5569		}
5570		}
5571		resultobj = PyInt_FromLong((long)result);
#	Line 4576 | Line 5598 | static PyObject *_wrap_BossAdministrator
5598		try {
5599		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5600
5601	+	}catch (const BossSchedFailure & e) {
5602	+	PyErr_SetString ( SchedulerError, e.what() );
5603	+	return NULL;
5604		}catch (const std::exception& e) {
5605	<	SWIG_exception(SWIG_RuntimeError, e.what());
5605	>	PyErr_SetString ( BossError, e.what() );
5606	>	return NULL;
5607		}
5608		}
5609		resultobj = PyInt_FromLong((long)result);
#	Line 4610 | Line 5636 | static PyObject *_wrap_BossAdministrator
5636		try {
5637		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5638
5639	+	}catch (const BossSchedFailure & e) {
5640	+	PyErr_SetString ( SchedulerError, e.what() );
5641	+	return NULL;
5642		}catch (const std::exception& e) {
5643	<	SWIG_exception(SWIG_RuntimeError, e.what());
5643	>	PyErr_SetString ( BossError, e.what() );
5644	>	return NULL;
5645		}
5646		}
5647		resultobj = PyInt_FromLong((long)result);
#	Line 4644 | Line 5674 | static PyObject *_wrap_BossAdministrator
5674		try {
5675		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5676
5677	+	}catch (const BossSchedFailure & e) {
5678	+	PyErr_SetString ( SchedulerError, e.what() );
5679	+	return NULL;
5680		}catch (const std::exception& e) {
5681	<	SWIG_exception(SWIG_RuntimeError, e.what());
5681	>	PyErr_SetString ( BossError, e.what() );
5682	>	return NULL;
5683		}
5684		}
5685		resultobj = PyInt_FromLong((long)result);
#	Line 4710 | Line 5744 | static PyObject *_wrap_BossAdministrator
5744		try {
5745		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5746
5747	+	}catch (const BossSchedFailure & e) {
5748	+	PyErr_SetString ( SchedulerError, e.what() );
5749	+	return NULL;
5750		}catch (const std::exception& e) {
5751	<	SWIG_exception(SWIG_RuntimeError, e.what());
5751	>	PyErr_SetString ( BossError, e.what() );
5752	>	return NULL;
5753		}
5754		}
5755		resultobj = PyInt_FromLong((long)result);
#	Line 4800 | Line 5838 | static PyObject *_wrap_BossAdministrator
5838		try {
5839		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5840
5841	+	}catch (const BossSchedFailure & e) {
5842	+	PyErr_SetString ( SchedulerError, e.what() );
5843	+	return NULL;
5844		}catch (const std::exception& e) {
5845	<	SWIG_exception(SWIG_RuntimeError, e.what());
5845	>	PyErr_SetString ( BossError, e.what() );
5846	>	return NULL;
5847		}
5848		}
5849		resultobj = PyInt_FromLong((long)result);
#	Line 4876 | Line 5918 | static PyObject *_wrap_BossAdministrator
5918		try {
5919		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5920
5921	+	}catch (const BossSchedFailure & e) {
5922	+	PyErr_SetString ( SchedulerError, e.what() );
5923	+	return NULL;
5924		}catch (const std::exception& e) {
5925	<	SWIG_exception(SWIG_RuntimeError, e.what());
5925	>	PyErr_SetString ( BossError, e.what() );
5926	>	return NULL;
5927		}
5928		}
5929		resultobj = PyInt_FromLong((long)result);
#	Line 4905 | Line 5951 | static PyObject *_wrap_BossAdministrator
5951		std::string arg13 = (std::string) "" ;
5952		bool arg14 = (bool) false ;
5953		bool arg15 = (bool) false ;
5954	+	bool arg16 = (bool) false ;
5955	+	bool arg17 = (bool) false ;
5956		int result;
5957		std::string temp2 ;
5958		std::string temp11 ;
#	Line 4923 | Line 5971 | static PyObject *_wrap_BossAdministrator
5971		PyObject * obj12 = 0 ;
5972		PyObject * obj13 = 0 ;
5973		PyObject * obj14 = 0 ;
5974	+	PyObject * obj15 = 0 ;
5975	+	PyObject * obj16 = 0 ;
5976
5977	<	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;
5977	>	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;
5978		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5979		{
5980		if (PyString_Check(obj1)) {
#	Line 5032 | Line 6082 | static PyObject *_wrap_BossAdministrator
6082		arg15 = PyInt_AsLong(obj14) ? true : false;
6083		if (PyErr_Occurred()) SWIG_fail;
6084		}
6085	+	if (obj15) {
6086	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6087	+	if (PyErr_Occurred()) SWIG_fail;
6088	+	}
6089	+	if (obj16) {
6090	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6091	+	if (PyErr_Occurred()) SWIG_fail;
6092	+	}
6093		{
6094		try {
6095	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
6095	>	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);
6096
6097	+	}catch (const BossSchedFailure & e) {
6098	+	PyErr_SetString ( SchedulerError, e.what() );
6099	+	return NULL;
6100		}catch (const std::exception& e) {
6101	<	SWIG_exception(SWIG_RuntimeError, e.what());
6101	>	PyErr_SetString ( BossError, e.what() );
6102	>	return NULL;
6103		}
6104		}
6105		resultobj = PyInt_FromLong((long)result);
#	Line 5059 | Line 6121 | static PyObject *_wrap_BossAdministrator
6121		try {
6122		result = (arg1)->help();
6123
6124	+	}catch (const BossSchedFailure & e) {
6125	+	PyErr_SetString ( SchedulerError, e.what() );
6126	+	return NULL;
6127		}catch (const std::exception& e) {
6128	<	SWIG_exception(SWIG_RuntimeError, e.what());
6128	>	PyErr_SetString ( BossError, e.what() );
6129	>	return NULL;
6130		}
6131		}
6132		{
#	Line 5072 | Line 6138 | static PyObject *_wrap_BossAdministrator
6138		}
6139
6140
6141	<	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
6141	>	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6142		PyObject *resultobj;
6143		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6144	<	std::string *arg2 = 0 ;
6144	>	std::string arg2 ;
6145	>	bool arg3 = (bool) false ;
6146		std::string result;
6147		PyObject * obj0 = 0 ;
6148		PyObject * obj1 = 0 ;
6149	+	PyObject * obj2 = 0 ;
6150
6151	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureDB",&obj0,&obj1)) goto fail;
6151	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
6152		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6153	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6154	<	if (arg2 == NULL) {
6155	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6153	>	{
6154	>	if (PyString_Check(obj1))
6155	>	arg2 = std::string(PyString_AsString(obj1));
6156	>	else
6157	>	SWIG_exception(SWIG_TypeError, "string expected");
6158	>	}
6159	>	if (obj2) {
6160	>	arg3 = PyInt_AsLong(obj2) ? true : false;
6161	>	if (PyErr_Occurred()) SWIG_fail;
6162		}
6163		{
6164		try {
6165	<	result = (arg1)->configureDB(*arg2);
6165	>	result = (arg1)->SQL(arg2,arg3);
6166
6167	+	}catch (const BossSchedFailure & e) {
6168	+	PyErr_SetString ( SchedulerError, e.what() );
6169	+	return NULL;
6170		}catch (const std::exception& e) {
6171	<	SWIG_exception(SWIG_RuntimeError, e.what());
6171	>	PyErr_SetString ( BossError, e.what() );
6172	>	return NULL;
6173		}
6174		}
6175		{
#	Line 5103 | Line 6181 | static PyObject *_wrap_BossAdministrator
6181		}
6182
6183
6184	<	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6184	>	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
6185		PyObject *resultobj;
6186		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6187		std::string *arg2 = 0 ;
6188	<	bool arg3 = (bool) false ;
6189	<	std::string result;
6188	>	std::string *arg3 = 0 ;
6189	>	std::string *arg4 = 0 ;
6190	>	std::string const &arg5_defvalue = "0" ;
6191	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
6192	>	int result;
6193	>	std::string temp2 ;
6194	>	std::string temp3 ;
6195	>	std::string temp4 ;
6196	>	std::string temp5 ;
6197		PyObject * obj0 = 0 ;
6198		PyObject * obj1 = 0 ;
6199		PyObject * obj2 = 0 ;
6200	+	PyObject * obj3 = 0 ;
6201	+	PyObject * obj4 = 0 ;
6202
6203	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
6203	>	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6204		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6205	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6206	<	if (arg2 == NULL) {
6207	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6205	>	{
6206	>	if (PyString_Check(obj1)) {
6207	>	temp2 = std::string(PyString_AsString(obj1));
6208	>	arg2 = &temp2;
6209	>	}else {
6210	>	SWIG_exception(SWIG_TypeError, "string expected");
6211	>	}
6212		}
6213	<	if (obj2) {
6214	<	arg3 = PyInt_AsLong(obj2) ? true : false;
6215	<	if (PyErr_Occurred()) SWIG_fail;
6213	>	{
6214	>	if (PyString_Check(obj2)) {
6215	>	temp3 = std::string(PyString_AsString(obj2));
6216	>	arg3 = &temp3;
6217	>	}else {
6218	>	SWIG_exception(SWIG_TypeError, "string expected");
6219	>	}
6220	>	}
6221	>	{
6222	>	if (PyString_Check(obj3)) {
6223	>	temp4 = std::string(PyString_AsString(obj3));
6224	>	arg4 = &temp4;
6225	>	}else {
6226	>	SWIG_exception(SWIG_TypeError, "string expected");
6227	>	}
6228	>	}
6229	>	if (obj4) {
6230	>	{
6231	>	if (PyString_Check(obj4)) {
6232	>	temp5 = std::string(PyString_AsString(obj4));
6233	>	arg5 = &temp5;
6234	>	}else {
6235	>	SWIG_exception(SWIG_TypeError, "string expected");
6236	>	}
6237	>	}
6238		}
6239		{
6240		try {
6241	<	result = (arg1)->SQL(*arg2,arg3);
6241	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6242
6243	+	}catch (const BossSchedFailure & e) {
6244	+	PyErr_SetString ( SchedulerError, e.what() );
6245	+	return NULL;
6246		}catch (const std::exception& e) {
6247	<	SWIG_exception(SWIG_RuntimeError, e.what());
6247	>	PyErr_SetString ( BossError, e.what() );
6248	>	return NULL;
6249		}
6250		}
6251	<	{
5135	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5136	<	}
6251	>	resultobj = PyInt_FromLong((long)result);
6252		return resultobj;
6253		fail:
6254		return NULL;
6255		}
6256
6257
6258	<	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
6258	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
6259		PyObject *resultobj;
6260		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6261	<	std::string *arg2 = 0 ;
6262	<	std::string result;
6261	>	std::string arg2 ;
6262	>	int result;
6263		PyObject * obj0 = 0 ;
6264		PyObject * obj1 = 0 ;
6265
6266	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_purge",&obj0,&obj1)) goto fail;
6266	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6267		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6268	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6269	<	if (arg2 == NULL) {
6270	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
6268	>	{
6269	>	if (PyString_Check(obj1))
6270	>	arg2 = std::string(PyString_AsString(obj1));
6271	>	else
6272	>	SWIG_exception(SWIG_TypeError, "string expected");
6273		}
6274		{
6275		try {
6276	<	result = (arg1)->purge(*arg2);
6276	>	result = (int)(arg1)->registerPlugins(arg2);
6277
6278	+	}catch (const BossSchedFailure & e) {
6279	+	PyErr_SetString ( SchedulerError, e.what() );
6280	+	return NULL;
6281		}catch (const std::exception& e) {
6282	<	SWIG_exception(SWIG_RuntimeError, e.what());
6282	>	PyErr_SetString ( BossError, e.what() );
6283	>	return NULL;
6284		}
6285		}
6286	<	{
5166	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5167	<	}
6286	>	resultobj = PyInt_FromLong((long)result);
6287		return resultobj;
6288		fail:
6289		return NULL;
#	Line 5194 | Line 6313 | static PyMethodDef SwigMethods[] = {
6313		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6314		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6315		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6316	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6317	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6318	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6319	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6320	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6321	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6316	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6317	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6318	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6319	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6320	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6321	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6322	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6323	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6324	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6325	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6326	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6327	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6328	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6329	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6330		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6331		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6332	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6333	+	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6334		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6335		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6336	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6337	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6338	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6339	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6340		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6341		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6342		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5211 | Line 6344 | static PyMethodDef SwigMethods[] = {
6344		{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
6345		{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
6346		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5214	–	{ (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
6347		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6348		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6349	<	{ (char *)"BossSession_jobQuery", _wrap_BossSession_jobQuery, METH_VARARGS },
5218	<	{ (char *)"BossSession_queryPrint", _wrap_BossSession_queryPrint, METH_VARARGS },
6349	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6350		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6351	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6352	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6353	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6354	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6355	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6356	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6357	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6358	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6359		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6360		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6361		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5224 | Line 6363 | static PyMethodDef SwigMethods[] = {
6363		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6364		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6365		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5227	–	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5228	–	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5229	–	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5230	–	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5231	–	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6366		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6367		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6368		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
6369		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
6370	<	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6370	>	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6371		{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6372		{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6373	<	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6373	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
6374	>	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6375		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6376	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6377		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
6378		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
6379		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
5244	–	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6380		{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
6381		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6382		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6383		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6384	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6385		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6386		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6387		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6388	<	{ (char *)"BossTask_prompt", _wrap_BossTask_prompt, METH_VARARGS },
6388	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6389	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6390	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6391	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6392	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6393		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6394		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6395		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
6396	+	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
6397		{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
6398		{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
6399		{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
#	Line 5263 | Line 6404 | static PyMethodDef SwigMethods[] = {
6404		{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
6405		{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
6406		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
5266	–	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
6407		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
6408		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
6409	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
6410		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
6411		{ NULL, NULL }
6412		};
#	Line 5273 | Line 6414 | static PyMethodDef SwigMethods[] = {
6414
6415		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6416
5276	–	static swig_type_info _swigt__p_std__vectorTBossJob_p_t[] = {{"_p_std__vectorTBossJob_p_t", 0, "std::vector<BossJob * > *", 0},{"_p_std__vectorTBossJob_p_t"},{0}};
5277	–	static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator", 0, "std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator"},{0}};
5278	–	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}};
6417		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6418	+	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}};
6419	+	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}};
6420	+	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}};
6421		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}};
6422		static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6423		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6424		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5284	–	static swig_type_info _swigt__p_std__string[] = {{"_p_std__string", 0, "std::string *", 0},{"_p_std__string"},{0}};
5285	–	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6425		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6426	<	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6426	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6427		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6428	+	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6429		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6430		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}};
6431		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}};
6432		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5293	–	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6433		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}};
6434		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}};
6435	+	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6436
6437		static swig_type_info *swig_types_initial[] = {
5298	–	_swigt__p_std__vectorTBossJob_p_t,
5299	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
5300	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6438		_swigt__p_XMLDoc,
6439	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6440	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6441	+	_swigt__p_std__vectorTBossTask_p_t,
6442		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6443		_swigt__p_std__ostream,
6444		_swigt__p_BossTask,
6445		_swigt__p_BossTaskException,
5306	–	_swigt__p_std__string,
5307	–	_swigt__p_BossAttributeContainer,
6446		_swigt__p_printOption,
6447	<	_swigt__p_BossDatabase,
6447	>	_swigt__p_BossAttributeContainer,
6448		_swigt__p_BossJob,
6449	+	_swigt__p_BossDatabase,
6450		_swigt__p_BossSession,
6451		_swigt__p_std__vectorTstd__string_t,
6452		_swigt__p_std__mapTstd__string_std__string_t,
6453		_swigt__p_BossAdministratorSession,
5315	–	_swigt__p_jobStates,
6454		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6455		_swigt__p_BossTask__job_iterator,
6456	+	_swigt__p_jobStates,
6457		0
6458		};
6459
#	Line 5357 | Line 6496 | SWIGEXPORT(void) SWIG_init(void) {
6496		}
6497		SWIG_InstallConstants(d,swig_const_table);
6498
6499	+
6500	+	// define custom exceptions
6501	+	PyObject *e;
6502	+	PyMethodDef tp_methods = {
6503	+	NULL, NULL, 0, NULL
6504	+	};
6505	+	e = Py_InitModule("BossSession", &tp_methods);
6506	+	// generic BOSS exception
6507	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6508	+	Py_INCREF(BossError);
6509	+	PyModule_AddObject(e, "BossError", BossError);
6510	+	// scheduler interaction BOSS exception
6511	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6512	+	Py_INCREF(SchedulerError);
6513	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6514	+
6515		}
6516

Diff Legend

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