[ViewVC] Diff of: cvsroot/COMP/BOSS/BossPython/BossSession

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.7 by gcodispo, Fri Oct 27 13:36:09 2006 UTC vs.
Revision 1.27 by gcodispo, Thu Mar 8 17:52:39 2007 UTC

#	Line 657 \| Line 657 \| *SWIG_InstallConstants(PyObject d, swig_**
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__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[3]
661	<	#define SWIGTYPE_p_BossTask swig_types[4]
662	<	#define SWIGTYPE_p_BossTaskException swig_types[5]
663	<	#define SWIGTYPE_p_std__ostream swig_types[6]
664	<	#define SWIGTYPE_p_BossAttributeContainer swig_types[7]
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_printOption swig_types[8]
666	<	#define SWIGTYPE_p_BossJob swig_types[9]
667	<	#define SWIGTYPE_p_BossDatabase swig_types[10]
668	<	#define SWIGTYPE_p_BossSession swig_types[11]
669	<	#define SWIGTYPE_p_std__vectorTstd__string_t swig_types[12]
670	<	#define SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[13]
671	<	#define SWIGTYPE_p_BossAdministratorSession swig_types[14]
672	<	#define SWIGTYPE_p_BossTask__job_iterator swig_types[15]
666	>	#define SWIGTYPE_p_BossAttributeContainer swig_types[9]
667	>	#define SWIGTYPE_p_BossJob swig_types[10]
668	>	#define SWIGTYPE_p_BossDatabase swig_types[11]
669	>	#define SWIGTYPE_p_BossSession swig_types[12]
670	>	#define SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671	>	#define SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672	>	#define SWIGTYPE_p_BossAdministratorSession swig_types[15]
673		#define SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	<	#define SWIGTYPE_p_jobStates swig_types[17]
675	<	static swig_type_info *swig_types[19];
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 850 \| Line 851 \| *PyObject std_maplstd_stringcstd_string_**
851		" for iterator support");
852		#endif
853		}
854	+	std::string std_vectorlstd_string_g_pop___(std::vector<std::string > *self){
855	+	if (self->size() == 0)
856	+	throw std::out_of_range("pop from empty vector");
857	+	std::string x = self->back();
858	+	self->pop_back();
859	+	return x;
860	+	}
861	+	std::string std_vectorlstd_string_g___getitem_____(std::vector<std::string > *self,int i){
862	+	int size = int(self->size());
863	+	if (i<0) i += size;
864	+	if (i>=0 && i<size)
865	+	return (*self)[i];
866	+	else
867	+	throw std::out_of_range("vector index out of range");
868	+	}
869	+	std::vector<std::string > std_vectorlstd_string_g___getslice_____(std::vector<std::string > *self,int i,int j){
870	+	int size = int(self->size());
871	+	if (i<0) i = size+i;
872	+	if (j<0) j = size+j;
873	+	if (i<0) i = 0;
874	+	if (j>size) j = size;
875	+	std::vector<std::string > tmp(j-i);
876	+	std::copy(self->begin()+i,self->begin()+j,tmp.begin());
877	+	return tmp;
878	+	}
879	+	void std_vectorlstd_string_g___setitem_____(std::vector<std::string > *self,int i,std::string x){
880	+	int size = int(self->size());
881	+	if (i<0) i+= size;
882	+	if (i>=0 && i<size)
883	+	(*self)[i] = x;
884	+	else
885	+	throw std::out_of_range("vector index out of range");
886	+	}
887	+	void std_vectorlstd_string_g___setslice_____(std::vector<std::string > *self,int i,int j,std::vector<std::string > const &v){
888	+	int size = int(self->size());
889	+	if (i<0) i = size+i;
890	+	if (j<0) j = size+j;
891	+	if (i<0) i = 0;
892	+	if (j>size) j = size;
893	+	if (int(v.size()) == j-i) {
894	+	std::copy(v.begin(),v.end(),self->begin()+i);
895	+	} else {
896	+	self->erase(self->begin()+i,self->begin()+j);
897	+	if (i+1 <= int(self->size()))
898	+	self->insert(self->begin()+i,v.begin(),v.end());
899	+	else
900	+	self->insert(self->end(),v.begin(),v.end());
901	+	}
902	+	}
903	+	void std_vectorlstd_string_g___delitem_____(std::vector<std::string > *self,int i){
904	+	int size = int(self->size());
905	+	if (i<0) i+= size;
906	+	if (i>=0 && i<size)
907	+	self->erase(self->begin()+i);
908	+	else
909	+	throw std::out_of_range("vector index out of range");
910	+	}
911	+	void std_vectorlstd_string_g___delslice_____(std::vector<std::string > *self,int i,int j){
912	+	int size = int(self->size());
913	+	if (i<0) i = size+i;
914	+	if (j<0) j = size+j;
915	+	if (i<0) i = 0;
916	+	if (j>size) j = size;
917	+	self->erase(self->begin()+i,self->begin()+j);
918	+	}
919
920	+	static PyObject * BossError;
921	+	static PyObject * SchedulerError;
922		#include "BossSession.h"
923		#include "BossAdministratorSession.h"
924		#include "BossTask.h"
#	Line 861 \| Line 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 871 \| 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	<	if ( !avoidCheck ) {
962	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
963	<	type, user, after, before);
964	<	}
965	<	PyObject * job_dict = PyList_New(0);
966	<	std::vector <std::string>
967	<	taskList = self->selectTasks( taskRange, before, after, user);
968	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
969	<	it!= taskList.end(); ++it ) {
970	<	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,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
970	>	PyObject * task_list = PyList_New(0);
971	>	std::vector <std::string> taskList;
972	>	if ( taskName.empty() ) {
973	>	taskList = self->selectTasks( taskRange, before, after, user);
974	>	} else {
975	>	taskList = self->selectTasksByName( taskName );
976		}
977	<
978	<	// int size = taskList.size();
979	<	// PyObject * job_dict = PyList_New(0);
905	<	// for ( unsigned int i = 0; i < size; ++i ) {
906	<	// PyList_SetItem(job_dict,i, );
907	<	// self->makeBossTask( *it );
908	<	// }
909	<	return job_dict;
910	<	}
911	<	PyObject BossTask_appendToPyDict(BossTask const self,PyObject *dict,BossAttributeContainer const &obj){
912	<	std::string tmp;
913	<	BossAttributeContainer::const_iterator it_end = obj.end ();
914	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
915	<	it != it_end; ++it) {
916	<	tmp = (*it).first.name ();
917	<	char * key = new char[ tmp.size() ];
918	<	key = strdup(tmp.c_str());
919	<	tmp = (*it).second.value ();
920	<	PyObject * val = PyString_FromString( tmp.c_str() );
921	<	PyDict_SetItemString( dict, key, val );
922	<	delete [] key;
977	>	for ( std::vector <std::string>::const_iterator it= taskList.begin();
978	>	it!= taskList.end(); ++it ) {
979	>	PyList_Append( task_list, PyString_FromString(it->c_str() ) );
980		}
981	<	return dict;
981	>	return task_list;
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) {
1897	<	{
1898	<	if (PyString_Check(obj0))
1899	<	arg1 = std::string(PyString_AsString(obj0));
1900	<	else
1901	<	SWIG_exception(SWIG_TypeError, "string expected");
1902	<	}
1903	<	}
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	<	result = (BossSession *)new BossSession(arg1);
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	<	SWIG_exception(SWIG_RuntimeError, e.what());
2371	>	PyErr_SetString ( BossError, e.what() );
2372	>	return NULL;
2373		}
2374		}
2375	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2375	>	Py_INCREF(Py_None); resultobj = Py_None;
2376		return resultobj;
2377		fail:
2378		return NULL;
2379		}
2380
2381
2382	<	static PyObject _wrap_delete_BossSession(PyObject self, PyObject *args) {
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:delete_BossSession",&obj0)) goto fail;
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	<	delete 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		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1949 \| Line 2416 \| *static PyObject _wrap_BossSession_clear**
2416		try {
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 1986 \| 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 2011 \| 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 2022 \| 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 2034 \| 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 2049 \| 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 2061 \| 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 2076 \| 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 2088 \| 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 2103 \| 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 2115 \| 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 2142 \| 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 2167 \| 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 2192 \| 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 2217 \| 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 2242 \| 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 2267 \| 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 2298 \| 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());
2828	>	PyErr_SetString ( BossError, e.what() );
2829	>	return NULL;
2830		}
2831		}
2832		resultobj = PyInt_FromLong((long)result);
#	Line 2351 \| 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 2372 \| 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 2383 \| 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 2426 \| 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 2457 \| Line 3001 \| *static PyObject _wrap_BossSession_sched**
3001		std::string arg7 = (std::string) "" ;
3002		std::string arg8 = (std::string) "" ;
3003		std::string arg9 = (std::string) "" ;
3004	+	unsigned int arg10 = (unsigned int) 0 ;
3005		std::string temp3 ;
3006		std::string temp4 ;
3007		std::string temp5 ;
#	Line 2468 \| Line 3013 \| *static PyObject _wrap_BossSession_sched**
3013		PyObject * obj6 = 0 ;
3014		PyObject * obj7 = 0 ;
3015		PyObject * obj8 = 0 ;
3016	+	PyObject * obj9 = 0 ;
3017
3018	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) 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 2533 \| Line 3079 \| *static PyObject _wrap_BossSession_sched**
3079		SWIG_exception(SWIG_TypeError, "string expected");
3080		}
3081		}
3082	+	if (obj9) {
3083	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3084	+	if (PyErr_Occurred()) SWIG_fail;
3085	+	}
3086		{
3087		try {
3088	<	(arg1)->schedulerQuery(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
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		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2559 \| Line 3113 \| *static PyObject _wrap_BossSession_selec**
3113		std::string arg4 = (std::string ) &arg4_defvalue ;
3114		std::string const &arg5_defvalue = "" ;
3115		std::string arg5 = (std::string ) &arg5_defvalue ;
3116	<	SwigValueWrapper< std::vector<std::string > > result;
3116	>	std::vector<std::string > result;
3117		std::string temp2 ;
3118		std::string temp3 ;
3119		std::string temp4 ;
#	Line 2616 \| Line 3170 \| *static PyObject _wrap_BossSession_selec**
3170		try {
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		{
3182	<	std::vector<std::string > * resultptr;
3183	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3184	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
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:
#	Line 2631 \| Line 3190 \| *static PyObject _wrap_BossSession_selec**
3190		}
3191
3192
3193	<	static PyObject * BossSession_swigregister(PyObject self, PyObject args) {
2635	<	PyObject *obj;
2636	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2637	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
2638	<	Py_INCREF(obj);
2639	<	return Py_BuildValue((char *)"");
2640	<	}
2641	<	static PyObject _wrap_BossTaskException_key_set(PyObject self, PyObject *args) {
3193	>	static PyObject _wrap_BossSession_selectTasksByName(PyObject self, PyObject *args) {
3194		PyObject *resultobj;
3195	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3196	<	char *arg2 ;
3195	>	BossSession arg1 = (BossSession ) 0 ;
3196	>	std::string *arg2 = 0 ;
3197	>	std::vector<std::string > result;
3198	>	std::string temp2 ;
3199		PyObject * obj0 = 0 ;
3200	+	PyObject * obj1 = 0 ;
3201
3202	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3203	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3202	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3203	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3204		{
3205	<	if (arg2) {
3206	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3207	<	strcpy((char *) arg1->key,arg2);
3205	>	if (PyString_Check(obj1)) {
3206	>	temp2 = std::string(PyString_AsString(obj1));
3207	>	arg2 = &temp2;
3208		}else {
3209	<	arg1->key = 0;
3209	>	SWIG_exception(SWIG_TypeError, "string expected");
3210		}
3211		}
3212	<	Py_INCREF(Py_None); resultobj = Py_None;
3212	>	{
3213	>	try {
3214	>	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3215	>
3216	>	}catch (const BossSchedFailure & e) {
3217	>	PyErr_SetString ( SchedulerError, e.what() );
3218	>	return NULL;
3219	>	}catch (const std::exception& e) {
3220	>	PyErr_SetString ( BossError, e.what() );
3221	>	return NULL;
3222	>	}
3223	>	}
3224	>	{
3225	>	resultobj = PyTuple_New((&result)->size());
3226	>	for (unsigned int i=0; i<(&result)->size(); i++)
3227	>	PyTuple_SetItem(resultobj,i,
3228	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3229	>	}
3230		return resultobj;
3231		fail:
3232		return NULL;
3233		}
3234
3235
3236	<	static PyObject _wrap_BossTaskException_key_get(PyObject self, PyObject *args) {
3236	>	static PyObject _wrap_BossSession_query(PyObject self, PyObject *args) {
3237		PyObject *resultobj;
3238	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3239	<	char *result;
3238	>	BossSession arg1 = (BossSession ) 0 ;
3239	>	int arg2 = (int) SCHEDULED ;
3240	>	std::string const &arg3_defvalue = "all" ;
3241	>	std::string arg3 = (std::string ) &arg3_defvalue ;
3242	>	std::string const &arg4_defvalue = "all" ;
3243	>	std::string arg4 = (std::string ) &arg4_defvalue ;
3244	>	std::string const &arg5_defvalue = "" ;
3245	>	std::string arg5 = (std::string ) &arg5_defvalue ;
3246	>	std::string arg6 = (std::string) "" ;
3247	>	std::string arg7 = (std::string) "" ;
3248	>	std::string arg8 = (std::string) "" ;
3249	>	std::string arg9 = (std::string) "" ;
3250	>	unsigned int arg10 = (unsigned int) 0 ;
3251	>	bool arg11 = (bool) false ;
3252	>	SwigValueWrapper< std::vector<BossTask * > > result;
3253	>	std::string temp3 ;
3254	>	std::string temp4 ;
3255	>	std::string temp5 ;
3256		PyObject * obj0 = 0 ;
3257	+	PyObject * obj2 = 0 ;
3258	+	PyObject * obj3 = 0 ;
3259	+	PyObject * obj4 = 0 ;
3260	+	PyObject * obj5 = 0 ;
3261	+	PyObject * obj6 = 0 ;
3262	+	PyObject * obj7 = 0 ;
3263	+	PyObject * obj8 = 0 ;
3264	+	PyObject * obj9 = 0 ;
3265	+	PyObject * obj10 = 0 ;
3266
3267	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3268	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3269	<	result = (char *) ((arg1)->key);
3270	<
3271	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3267	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3268	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3269	>	if (obj2) {
3270	>	{
3271	>	if (PyString_Check(obj2)) {
3272	>	temp3 = std::string(PyString_AsString(obj2));
3273	>	arg3 = &temp3;
3274	>	}else {
3275	>	SWIG_exception(SWIG_TypeError, "string expected");
3276	>	}
3277	>	}
3278	>	}
3279	>	if (obj3) {
3280	>	{
3281	>	if (PyString_Check(obj3)) {
3282	>	temp4 = std::string(PyString_AsString(obj3));
3283	>	arg4 = &temp4;
3284	>	}else {
3285	>	SWIG_exception(SWIG_TypeError, "string expected");
3286	>	}
3287	>	}
3288	>	}
3289	>	if (obj4) {
3290	>	{
3291	>	if (PyString_Check(obj4)) {
3292	>	temp5 = std::string(PyString_AsString(obj4));
3293	>	arg5 = &temp5;
3294	>	}else {
3295	>	SWIG_exception(SWIG_TypeError, "string expected");
3296	>	}
3297	>	}
3298	>	}
3299	>	if (obj5) {
3300	>	{
3301	>	if (PyString_Check(obj5))
3302	>	arg6 = std::string(PyString_AsString(obj5));
3303	>	else
3304	>	SWIG_exception(SWIG_TypeError, "string expected");
3305	>	}
3306	>	}
3307	>	if (obj6) {
3308	>	{
3309	>	if (PyString_Check(obj6))
3310	>	arg7 = std::string(PyString_AsString(obj6));
3311	>	else
3312	>	SWIG_exception(SWIG_TypeError, "string expected");
3313	>	}
3314	>	}
3315	>	if (obj7) {
3316	>	{
3317	>	if (PyString_Check(obj7))
3318	>	arg8 = std::string(PyString_AsString(obj7));
3319	>	else
3320	>	SWIG_exception(SWIG_TypeError, "string expected");
3321	>	}
3322	>	}
3323	>	if (obj8) {
3324	>	{
3325	>	if (PyString_Check(obj8))
3326	>	arg9 = std::string(PyString_AsString(obj8));
3327	>	else
3328	>	SWIG_exception(SWIG_TypeError, "string expected");
3329	>	}
3330	>	}
3331	>	if (obj9) {
3332	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3333	>	if (PyErr_Occurred()) SWIG_fail;
3334	>	}
3335	>	if (obj10) {
3336	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3337	>	if (PyErr_Occurred()) SWIG_fail;
3338	>	}
3339	>	{
3340	>	try {
3341	>	result = (arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3342	>
3343	>	}catch (const BossSchedFailure & e) {
3344	>	PyErr_SetString ( SchedulerError, e.what() );
3345	>	return NULL;
3346	>	}catch (const std::exception& e) {
3347	>	PyErr_SetString ( BossError, e.what() );
3348	>	return NULL;
3349	>	}
3350	>	}
3351	>	{
3352	>	std::vector<BossTask * > * resultptr;
3353	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3354	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3355	>	}
3356		return resultobj;
3357		fail:
3358		return NULL;
3359		}
3360
3361
3362	<	static PyObject _wrap_new_BossTaskException(PyObject self, PyObject *args) {
3362	>	static PyObject _wrap_BossSession_getTasksByName(PyObject self, PyObject *args) {
3363		PyObject *resultobj;
3364	<	char *arg1 ;
3365	<	BossTaskException *result;
3364	>	BossSession arg1 = (BossSession ) 0 ;
3365	>	std::string *arg2 = 0 ;
3366	>	SwigValueWrapper< std::vector<BossTask * > > result;
3367	>	std::string temp2 ;
3368	>	PyObject * obj0 = 0 ;
3369	>	PyObject * obj1 = 0 ;
3370
3371	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3371	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3372	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3373	>	{
3374	>	if (PyString_Check(obj1)) {
3375	>	temp2 = std::string(PyString_AsString(obj1));
3376	>	arg2 = &temp2;
3377	>	}else {
3378	>	SWIG_exception(SWIG_TypeError, "string expected");
3379	>	}
3380	>	}
3381		{
3382		try {
3383	<	result = (BossTaskException )new BossTaskException((char const )arg1);
3383	>	result = (arg1)->getTasksByName((std::string const &)*arg2);
3384
3385	+	}catch (const BossSchedFailure & e) {
3386	+	PyErr_SetString ( SchedulerError, e.what() );
3387	+	return NULL;
3388		}catch (const std::exception& e) {
3389	<	SWIG_exception(SWIG_RuntimeError, e.what());
3389	>	PyErr_SetString ( BossError, e.what() );
3390	>	return NULL;
3391		}
3392		}
3393	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3393	>	{
3394	>	std::vector<BossTask * > * resultptr;
3395	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3396	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3397	>	}
3398		return resultobj;
3399		fail:
3400		return NULL;
3401		}
3402
3403
3404	<	static PyObject _wrap_BossTaskException_what(PyObject self, PyObject *args) {
3404	>	static PyObject _wrap_BossSession_show(PyObject self, PyObject *args) {
3405		PyObject *resultobj;
3406	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3407	<	char *result;
3406	>	BossSession arg1 = (BossSession ) 0 ;
3407	>	std::vector<std::string > *arg2 = 0 ;
3408	>	PyObject *result;
3409		PyObject * obj0 = 0 ;
3410	+	PyObject * obj1 = 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 *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3413	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3414	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3415	>	if (arg2 == NULL) {
3416	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3417	>	}
3418		{
3419		try {
3420	<	result = (char )((BossTaskException const )arg1)->what();
3420	>	result = (PyObject )BossSession_show(arg1,arg2);
3421
3422	+	}catch (const BossSchedFailure & e) {
3423	+	PyErr_SetString ( SchedulerError, e.what() );
3424	+	return NULL;
3425		}catch (const std::exception& e) {
3426	<	SWIG_exception(SWIG_RuntimeError, e.what());
3426	>	PyErr_SetString ( BossError, e.what() );
3427	>	return NULL;
3428		}
3429		}
3430	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3430	>	resultobj = result;
3431		return resultobj;
3432		fail:
3433		return NULL;
3434		}
3435
3436
3437	<	static PyObject _wrap_delete_BossTaskException(PyObject self, PyObject *args) {
3437	>	static PyObject _wrap_BossSession_CHTools(PyObject self, PyObject *args) {
3438		PyObject *resultobj;
3439	<	BossTaskException arg1 = (BossTaskException ) 0 ;
3439	>	BossSession arg1 = (BossSession ) 0 ;
3440	>	PyObject *result;
3441		PyObject * obj0 = 0 ;
3442
3443	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3444	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3443	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3444	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3445		{
3446		try {
3447	<	delete arg1;
3447	>	result = (PyObject *)BossSession_CHTools(arg1);
3448
3449	+	}catch (const BossSchedFailure & e) {
3450	+	PyErr_SetString ( SchedulerError, e.what() );
3451	+	return NULL;
3452		}catch (const std::exception& e) {
3453	<	SWIG_exception(SWIG_RuntimeError, e.what());
3453	>	PyErr_SetString ( BossError, e.what() );
3454	>	return NULL;
3455		}
3456		}
3457	<	Py_INCREF(Py_None); resultobj = Py_None;
3457	>	resultobj = result;
3458		return resultobj;
3459		fail:
3460		return NULL;
3461		}
3462
3463
3464	<	static PyObject * BossTaskException_swigregister(PyObject self, PyObject args) {
2748	<	PyObject *obj;
2749	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2750	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
2751	<	Py_INCREF(obj);
2752	<	return Py_BuildValue((char *)"");
2753	<	}
2754	<	static PyObject _wrap_BossTask_appendToPyDict(PyObject self, PyObject *args) {
3464	>	static PyObject _wrap_BossSession_ProgramTypes(PyObject self, PyObject *args) {
3465		PyObject *resultobj;
3466	<	BossTask arg1 = (BossTask ) 0 ;
2757	<	PyObject arg2 = (PyObject ) 0 ;
2758	<	BossAttributeContainer *arg3 = 0 ;
3466	>	BossSession arg1 = (BossSession ) 0 ;
3467		PyObject *result;
3468		PyObject * obj0 = 0 ;
2761	–	PyObject * obj1 = 0 ;
2762	–	PyObject * obj2 = 0 ;
3469
3470	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3471	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2766	<	arg2 = obj1;
2767	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2768	<	if (arg3 == NULL) {
2769	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2770	<	}
3470	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3471	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3472		{
3473		try {
3474	<	result = (PyObject )BossTask_appendToPyDict((BossTask const )arg1,arg2,(BossAttributeContainer const &)*arg3);
3474	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3475
3476	+	}catch (const BossSchedFailure & e) {
3477	+	PyErr_SetString ( SchedulerError, e.what() );
3478	+	return NULL;
3479		}catch (const std::exception& e) {
3480	<	SWIG_exception(SWIG_RuntimeError, e.what());
3480	>	PyErr_SetString ( BossError, e.what() );
3481	>	return NULL;
3482		}
3483		}
3484		resultobj = result;
#	Line 2783 \| Line 3488 \| *static PyObject _wrap_BossTask_appendTo**
3488		}
3489
3490
3491	<	static PyObject _wrap_BossTask_jobDict(PyObject self, PyObject *args) {
3491	>	static PyObject _wrap_BossSession_RTMons(PyObject self, PyObject *args) {
3492		PyObject *resultobj;
3493	<	BossTask arg1 = (BossTask ) 0 ;
2789	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3493	>	BossSession arg1 = (BossSession ) 0 ;
3494		PyObject *result;
3495		PyObject * obj0 = 0 ;
2792	–	PyObject * obj1 = 0 ;
3496
3497	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3498	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2796	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
2797	<	if (arg2 == NULL) {
2798	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2799	<	}
3497	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3498	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3499		{
3500		try {
3501	<	result = (PyObject )BossTask_jobDict((BossTask const )arg1,*arg2);
3501	>	result = (PyObject *)BossSession_RTMons(arg1);
3502
3503	+	}catch (const BossSchedFailure & e) {
3504	+	PyErr_SetString ( SchedulerError, e.what() );
3505	+	return NULL;
3506		}catch (const std::exception& e) {
3507	<	SWIG_exception(SWIG_RuntimeError, e.what());
3507	>	PyErr_SetString ( BossError, e.what() );
3508	>	return NULL;
3509		}
3510		}
3511		resultobj = result;
#	Line 2812 \| Line 3515 \| *static PyObject _wrap_BossTask_jobDict(**
3515		}
3516
3517
3518	<	static PyObject _wrap_BossTask_jobsMap__SWIG_1(PyObject self, PyObject *args) {
3518	>	static PyObject _wrap_BossSession_schedulers(PyObject self, PyObject *args) {
3519		PyObject *resultobj;
3520	<	BossTask arg1 = (BossTask ) 0 ;
3520	>	BossSession arg1 = (BossSession ) 0 ;
3521		PyObject *result;
3522		PyObject * obj0 = 0 ;
3523
3524	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3525	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3524	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3525	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3526		{
3527		try {
3528	<	result = (PyObject )BossTask_jobsMap__SWIG_1((BossTask const )arg1);
3528	>	result = (PyObject *)BossSession_schedulers(arg1);
3529
3530	+	}catch (const BossSchedFailure & e) {
3531	+	PyErr_SetString ( SchedulerError, e.what() );
3532	+	return NULL;
3533		}catch (const std::exception& e) {
3534	<	SWIG_exception(SWIG_RuntimeError, e.what());
3534	>	PyErr_SetString ( BossError, e.what() );
3535	>	return NULL;
3536		}
3537		}
3538		resultobj = result;
#	Line 2835 \| Line 3542 \| *static PyObject _wrap_BossTask_jobsMap_**
3542		}
3543
3544
3545	<	static PyObject _wrap_BossTask_jobsMap(PyObject self, PyObject *args) {
3546	<	int argc;
3547	<	PyObject *argv[2];
3548	<	int ii;
3545	>	static PyObject _wrap_BossSession_schedListMatch(PyObject self, PyObject *args) {
3546	>	PyObject *resultobj;
3547	>	BossSession arg1 = (BossSession ) 0 ;
3548	>	std::string *arg2 = 0 ;
3549	>	std::string *arg3 = 0 ;
3550	>	std::string const &arg4_defvalue = "" ;
3551	>	std::string arg4 = (std::string ) &arg4_defvalue ;
3552	>	std::string const &arg5_defvalue = "" ;
3553	>	std::string arg5 = (std::string ) &arg5_defvalue ;
3554	>	unsigned int arg6 = (unsigned int) 0 ;
3555	>	bool arg7 = (bool) false ;
3556	>	PyObject *result;
3557	>	std::string temp2 ;
3558	>	std::string temp3 ;
3559	>	std::string temp4 ;
3560	>	std::string temp5 ;
3561	>	PyObject * obj0 = 0 ;
3562	>	PyObject * obj1 = 0 ;
3563	>	PyObject * obj2 = 0 ;
3564	>	PyObject * obj3 = 0 ;
3565	>	PyObject * obj4 = 0 ;
3566	>	PyObject * obj5 = 0 ;
3567	>	PyObject * obj6 = 0 ;
3568
3569	<	argc = PyObject_Length(args);
3570	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3571	<	argv[ii] = PyTuple_GetItem(args,ii);
3569	>	if(!PyArg_ParseTuple(args,(char *)"OOO\|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3570	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3571	>	{
3572	>	if (PyString_Check(obj1)) {
3573	>	temp2 = std::string(PyString_AsString(obj1));
3574	>	arg2 = &temp2;
3575	>	}else {
3576	>	SWIG_exception(SWIG_TypeError, "string expected");
3577	>	}
3578		}
3579	<	if (argc == 1) {
3580	<	int _v;
3579	>	{
3580	>	if (PyString_Check(obj2)) {
3581	>	temp3 = std::string(PyString_AsString(obj2));
3582	>	arg3 = &temp3;
3583	>	}else {
3584	>	SWIG_exception(SWIG_TypeError, "string expected");
3585	>	}
3586	>	}
3587	>	if (obj3) {
3588		{
3589	<	void *ptr;
3590	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3591	<	_v = 0;
2853	<	PyErr_Clear();
3589	>	if (PyString_Check(obj3)) {
3590	>	temp4 = std::string(PyString_AsString(obj3));
3591	>	arg4 = &temp4;
3592		}else {
3593	<	_v = 1;
3593	>	SWIG_exception(SWIG_TypeError, "string expected");
3594		}
3595		}
3596	<	if (_v) {
3597	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
3596	>	}
3597	>	if (obj4) {
3598	>	{
3599	>	if (PyString_Check(obj4)) {
3600	>	temp5 = std::string(PyString_AsString(obj4));
3601	>	arg5 = &temp5;
3602	>	}else {
3603	>	SWIG_exception(SWIG_TypeError, "string expected");
3604	>	}
3605		}
3606		}
3607	<
3608	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3607	>	if (obj5) {
3608	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3609	>	if (PyErr_Occurred()) SWIG_fail;
3610	>	}
3611	>	if (obj6) {
3612	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3613	>	if (PyErr_Occurred()) SWIG_fail;
3614	>	}
3615	>	{
3616	>	try {
3617	>	result = (PyObject )BossSession_schedListMatch(arg1,(std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)*arg5,arg6,arg7);
3618	>
3619	>	}catch (const BossSchedFailure & e) {
3620	>	PyErr_SetString ( SchedulerError, e.what() );
3621	>	return NULL;
3622	>	}catch (const std::exception& e) {
3623	>	PyErr_SetString ( BossError, e.what() );
3624	>	return NULL;
3625	>	}
3626	>	}
3627	>	resultobj = result;
3628	>	return resultobj;
3629	>	fail:
3630		return NULL;
3631		}
3632
3633
3634	<	static PyObject _wrap_BossTask_progDict(PyObject self, PyObject *args) {
3634	>	static PyObject _wrap_BossSession_queryTasks(PyObject self, PyObject *args) {
3635		PyObject *resultobj;
3636	<	BossTask arg1 = (BossTask ) 0 ;
3637	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3636	>	BossSession arg1 = (BossSession ) 0 ;
3637	>	std::string const &arg2_defvalue = "" ;
3638	>	std::string arg2 = (std::string ) &arg2_defvalue ;
3639	>	std::string const &arg3_defvalue = "all" ;
3640	>	std::string arg3 = (std::string ) &arg3_defvalue ;
3641	>	std::string arg4 = (std::string) "" ;
3642	>	std::string arg5 = (std::string) "" ;
3643	>	std::string arg6 = (std::string) "" ;
3644		PyObject *result;
3645	+	std::string temp2 ;
3646	+	std::string temp3 ;
3647		PyObject * obj0 = 0 ;
3648		PyObject * obj1 = 0 ;
3649	+	PyObject * obj2 = 0 ;
3650	+	PyObject * obj3 = 0 ;
3651	+	PyObject * obj4 = 0 ;
3652	+	PyObject * obj5 = 0 ;
3653
3654	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3655	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3656	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3657	<	if (arg2 == NULL) {
3658	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3654	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3655	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3656	>	if (obj1) {
3657	>	{
3658	>	if (PyString_Check(obj1)) {
3659	>	temp2 = std::string(PyString_AsString(obj1));
3660	>	arg2 = &temp2;
3661	>	}else {
3662	>	SWIG_exception(SWIG_TypeError, "string expected");
3663	>	}
3664	>	}
3665	>	}
3666	>	if (obj2) {
3667	>	{
3668	>	if (PyString_Check(obj2)) {
3669	>	temp3 = std::string(PyString_AsString(obj2));
3670	>	arg3 = &temp3;
3671	>	}else {
3672	>	SWIG_exception(SWIG_TypeError, "string expected");
3673	>	}
3674	>	}
3675	>	}
3676	>	if (obj3) {
3677	>	{
3678	>	if (PyString_Check(obj3))
3679	>	arg4 = std::string(PyString_AsString(obj3));
3680	>	else
3681	>	SWIG_exception(SWIG_TypeError, "string expected");
3682	>	}
3683	>	}
3684	>	if (obj4) {
3685	>	{
3686	>	if (PyString_Check(obj4))
3687	>	arg5 = std::string(PyString_AsString(obj4));
3688	>	else
3689	>	SWIG_exception(SWIG_TypeError, "string expected");
3690	>	}
3691	>	}
3692	>	if (obj5) {
3693	>	{
3694	>	if (PyString_Check(obj5))
3695	>	arg6 = std::string(PyString_AsString(obj5));
3696	>	else
3697	>	SWIG_exception(SWIG_TypeError, "string expected");
3698	>	}
3699		}
3700		{
3701		try {
3702	<	result = (PyObject )BossTask_progDict((BossTask const )arg1,*arg2);
3702	>	result = (PyObject )BossSession_queryTasks(arg1,(std::string const &)arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3703
3704	+	}catch (const BossSchedFailure & e) {
3705	+	PyErr_SetString ( SchedulerError, e.what() );
3706	+	return NULL;
3707		}catch (const std::exception& e) {
3708	<	SWIG_exception(SWIG_RuntimeError, e.what());
3708	>	PyErr_SetString ( BossError, e.what() );
3709	>	return NULL;
3710		}
3711		}
3712		resultobj = result;
#	Line 2894 \| Line 3716 \| *static PyObject _wrap_BossTask_progDict**
3716		}
3717
3718
3719	<	static PyObject _wrap_BossTask_jobPrograms(PyObject self, PyObject *args) {
3719	>	static PyObject * BossSession_swigregister(PyObject self, PyObject args) {
3720	>	PyObject *obj;
3721	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3722	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3723	>	Py_INCREF(obj);
3724	>	return Py_BuildValue((char *)"");
3725	>	}
3726	>	static PyObject _wrap_BossTaskException_key_set(PyObject self, PyObject *args) {
3727		PyObject *resultobj;
3728	<	BossTask arg1 = (BossTask ) 0 ;
3729	<	std::string *arg2 = 0 ;
2901	<	PyObject *result;
2902	<	std::string temp2 ;
3728	>	BossTaskException arg1 = (BossTaskException ) 0 ;
3729	>	char *arg2 ;
3730		PyObject * obj0 = 0 ;
2904	–	PyObject * obj1 = 0 ;
3731
3732	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3733	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3732	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3733	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3734		{
3735	<	if (PyString_Check(obj1)) {
3736	<	temp2 = std::string(PyString_AsString(obj1));
3737	<	arg2 = &temp2;
3735	>	if (arg2) {
3736	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3737	>	strcpy((char *) arg1->key,arg2);
3738		}else {
3739	<	SWIG_exception(SWIG_TypeError, "string expected");
3739	>	arg1->key = 0;
3740	>	}
3741	>	}
3742	>	Py_INCREF(Py_None); resultobj = Py_None;
3743	>	return resultobj;
3744	>	fail:
3745	>	return NULL;
3746	>	}
3747	>
3748	>
3749	>	static PyObject _wrap_BossTaskException_key_get(PyObject self, PyObject *args) {
3750	>	PyObject *resultobj;
3751	>	BossTaskException arg1 = (BossTaskException ) 0 ;
3752	>	char *result;
3753	>	PyObject * obj0 = 0 ;
3754	>
3755	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3756	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3757	>	result = (char *) ((arg1)->key);
3758	>
3759	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3760	>	return resultobj;
3761	>	fail:
3762	>	return NULL;
3763	>	}
3764	>
3765	>
3766	>	static PyObject _wrap_new_BossTaskException(PyObject self, PyObject *args) {
3767	>	PyObject *resultobj;
3768	>	char *arg1 ;
3769	>	BossTaskException *result;
3770	>
3771	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3772	>	{
3773	>	try {
3774	>	result = (BossTaskException )new BossTaskException((char const )arg1);
3775	>
3776	>	}catch (const BossSchedFailure & e) {
3777	>	PyErr_SetString ( SchedulerError, e.what() );
3778	>	return NULL;
3779	>	}catch (const std::exception& e) {
3780	>	PyErr_SetString ( BossError, e.what() );
3781	>	return NULL;
3782		}
3783		}
3784	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3785	+	return resultobj;
3786	+	fail:
3787	+	return NULL;
3788	+	}
3789	+
3790	+
3791	+	static PyObject _wrap_BossTaskException_what(PyObject self, PyObject *args) {
3792	+	PyObject *resultobj;
3793	+	BossTaskException arg1 = (BossTaskException ) 0 ;
3794	+	char *result;
3795	+	PyObject * obj0 = 0 ;
3796	+
3797	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3798	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3799		{
3800		try {
3801	<	result = (PyObject )BossTask_jobPrograms((BossTask const )arg1,(std::string const &)*arg2);
3801	>	result = (char )((BossTaskException const )arg1)->what();
3802
3803	+	}catch (const BossSchedFailure & e) {
3804	+	PyErr_SetString ( SchedulerError, e.what() );
3805	+	return NULL;
3806		}catch (const std::exception& e) {
3807	<	SWIG_exception(SWIG_RuntimeError, e.what());
3807	>	PyErr_SetString ( BossError, e.what() );
3808	>	return NULL;
3809		}
3810		}
3811	<	resultobj = result;
3811	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3812	>	return resultobj;
3813	>	fail:
3814	>	return NULL;
3815	>	}
3816	>
3817	>
3818	>	static PyObject _wrap_delete_BossTaskException(PyObject self, PyObject *args) {
3819	>	PyObject *resultobj;
3820	>	BossTaskException arg1 = (BossTaskException ) 0 ;
3821	>	PyObject * obj0 = 0 ;
3822	>
3823	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3824	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
3825	>	{
3826	>	try {
3827	>	delete arg1;
3828	>
3829	>	}catch (const BossSchedFailure & e) {
3830	>	PyErr_SetString ( SchedulerError, e.what() );
3831	>	return NULL;
3832	>	}catch (const std::exception& e) {
3833	>	PyErr_SetString ( BossError, e.what() );
3834	>	return NULL;
3835	>	}
3836	>	}
3837	>	Py_INCREF(Py_None); resultobj = Py_None;
3838		return resultobj;
3839		fail:
3840		return NULL;
3841		}
3842
3843
3844	+	static PyObject * BossTaskException_swigregister(PyObject self, PyObject args) {
3845	+	PyObject *obj;
3846	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3847	+	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3848	+	Py_INCREF(obj);
3849	+	return Py_BuildValue((char *)"");
3850	+	}
3851		static PyObject _wrap_new_BossTask__SWIG_0(PyObject self, PyObject *args) {
3852		PyObject *resultobj;
3853		BossDatabase arg1 = (BossDatabase ) 0 ;
#	Line 2940 \| Line 3860 \| *static PyObject _wrap_new_BossTask__SWI**
3860		try {
3861		result = (BossTask *)new BossTask(arg1);
3862
3863	+	}catch (const BossSchedFailure & e) {
3864	+	PyErr_SetString ( SchedulerError, e.what() );
3865	+	return NULL;
3866		}catch (const std::exception& e) {
3867	<	SWIG_exception(SWIG_RuntimeError, e.what());
3867	>	PyErr_SetString ( BossError, e.what() );
3868	>	return NULL;
3869		}
3870		}
3871		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 2974 \| Line 3898 \| *static PyObject _wrap_new_BossTask__SWI**
3898		try {
3899		result = (BossTask )new BossTask(arg1,(std::string const &)arg2);
3900
3901	+	}catch (const BossSchedFailure & e) {
3902	+	PyErr_SetString ( SchedulerError, e.what() );
3903	+	return NULL;
3904		}catch (const std::exception& e) {
3905	<	SWIG_exception(SWIG_RuntimeError, e.what());
3905	>	PyErr_SetString ( BossError, e.what() );
3906	>	return NULL;
3907		}
3908		}
3909		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 2996 \| Line 3924 \| *static PyObject _wrap_delete_BossTask(P**
3924		try {
3925		delete arg1;
3926
3927	+	}catch (const BossSchedFailure & e) {
3928	+	PyErr_SetString ( SchedulerError, e.what() );
3929	+	return NULL;
3930		}catch (const std::exception& e) {
3931	<	SWIG_exception(SWIG_RuntimeError, e.what());
3931	>	PyErr_SetString ( BossError, e.what() );
3932	>	return NULL;
3933		}
3934		}
3935		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3022 \| Line 3954 \| *static PyObject _wrap_new_BossTask__SWI**
3954		try {
3955		result = (BossTask )new BossTask((BossTask const &)arg1);
3956
3957	+	}catch (const BossSchedFailure & e) {
3958	+	PyErr_SetString ( SchedulerError, e.what() );
3959	+	return NULL;
3960		}catch (const std::exception& e) {
3961	<	SWIG_exception(SWIG_RuntimeError, e.what());
3961	>	PyErr_SetString ( BossError, e.what() );
3962	>	return NULL;
3963		}
3964		}
3965		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3113 \| Line 4049 \| *static PyObject _wrap_BossTask_id(PyObj**
4049		result = (std::string *) &_result_ref;
4050		}
4051
4052	+	}catch (const BossSchedFailure & e) {
4053	+	PyErr_SetString ( SchedulerError, e.what() );
4054	+	return NULL;
4055		}catch (const std::exception& e) {
4056	<	SWIG_exception(SWIG_RuntimeError, e.what());
4056	>	PyErr_SetString ( BossError, e.what() );
4057	>	return NULL;
4058		}
4059		}
4060		{
#	Line 3141 \| Line 4081 \| *static PyObject _wrap_BossTask_name(PyO**
4081		result = (std::string *) &_result_ref;
4082		}
4083
4084	+	}catch (const BossSchedFailure & e) {
4085	+	PyErr_SetString ( SchedulerError, e.what() );
4086	+	return NULL;
4087		}catch (const std::exception& e) {
4088	<	SWIG_exception(SWIG_RuntimeError, e.what());
4088	>	PyErr_SetString ( BossError, e.what() );
4089	>	return NULL;
4090		}
4091		}
4092		{
#	Line 3166 \| Line 4110 \| *static PyObject _wrap_BossTask_taskMap(**
4110		try {
4111		result = ((BossTask const *)arg1)->taskMap();
4112
4113	+	}catch (const BossSchedFailure & e) {
4114	+	PyErr_SetString ( SchedulerError, e.what() );
4115	+	return NULL;
4116		}catch (const std::exception& e) {
4117	<	SWIG_exception(SWIG_RuntimeError, e.what());
4117	>	PyErr_SetString ( BossError, e.what() );
4118	>	return NULL;
4119		}
4120		}
4121		{
#	Line 3196 \| Line 4144 \| *static PyObject _wrap_BossTask_job_begi**
4144		try {
4145		result = ((BossTask const *)arg1)->job_begin();
4146
4147	+	}catch (const BossSchedFailure & e) {
4148	+	PyErr_SetString ( SchedulerError, e.what() );
4149	+	return NULL;
4150		}catch (const std::exception& e) {
4151	<	SWIG_exception(SWIG_RuntimeError, e.what());
4151	>	PyErr_SetString ( BossError, e.what() );
4152	>	return NULL;
4153		}
4154		}
4155		{
#	Line 3223 \| Line 4175 \| *static PyObject _wrap_BossTask_job_end(**
4175		try {
4176		result = ((BossTask const *)arg1)->job_end();
4177
4178	+	}catch (const BossSchedFailure & e) {
4179	+	PyErr_SetString ( SchedulerError, e.what() );
4180	+	return NULL;
4181		}catch (const std::exception& e) {
4182	<	SWIG_exception(SWIG_RuntimeError, e.what());
4182	>	PyErr_SetString ( BossError, e.what() );
4183	>	return NULL;
4184		}
4185		}
4186		{
#	Line 3238 \| Line 4194 \| *static PyObject _wrap_BossTask_job_end(**
4194		}
4195
4196
4197	<	static PyObject _wrap_BossTask_jobsMap__SWIG_0(PyObject self, PyObject *args) {
4197	>	static PyObject _wrap_BossTask_jobsMap(PyObject self, PyObject *args) {
4198		PyObject *resultobj;
4199		BossTask arg1 = (BossTask ) 0 ;
4200		SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
#	Line 3250 \| Line 4206 \| *static PyObject _wrap_BossTask_jobsMap_**
4206		try {
4207		result = ((BossTask const *)arg1)->jobsMap();
4208
4209	+	}catch (const BossSchedFailure & e) {
4210	+	PyErr_SetString ( SchedulerError, e.what() );
4211	+	return NULL;
4212		}catch (const std::exception& e) {
4213	<	SWIG_exception(SWIG_RuntimeError, e.what());
4213	>	PyErr_SetString ( BossError, e.what() );
4214	>	return NULL;
4215		}
4216		}
4217		{
#	Line 3288 \| Line 4248 \| *static PyObject _wrap_BossTask_jobMap__**
4248		try {
4249		result = ((BossTask const )arg1)->jobMap(arg2,arg3);
4250
4251	+	}catch (const BossSchedFailure & e) {
4252	+	PyErr_SetString ( SchedulerError, e.what() );
4253	+	return NULL;
4254		}catch (const std::exception& e) {
4255	<	SWIG_exception(SWIG_RuntimeError, e.what());
4255	>	PyErr_SetString ( BossError, e.what() );
4256	>	return NULL;
4257		}
4258		}
4259		{
#	Line 3317 \| Line 4281 \| *static PyObject _wrap_BossTask_jobMap__**
4281		try {
4282		result = ((BossTask const *)arg1)->jobMap(arg2);
4283
4284	+	}catch (const BossSchedFailure & e) {
4285	+	PyErr_SetString ( SchedulerError, e.what() );
4286	+	return NULL;
4287		}catch (const std::exception& e) {
4288	<	SWIG_exception(SWIG_RuntimeError, e.what());
4288	>	PyErr_SetString ( BossError, e.what() );
4289	>	return NULL;
4290		}
4291		}
4292		{
#	Line 3422 \| Line 4390 \| *static PyObject _wrap_BossTask_programs**
4390		try {
4391		result = ((BossTask const )arg1)->programsMap((BossJob const )arg2);
4392
4393	+	}catch (const BossSchedFailure & e) {
4394	+	PyErr_SetString ( SchedulerError, e.what() );
4395	+	return NULL;
4396		}catch (const std::exception& e) {
4397	<	SWIG_exception(SWIG_RuntimeError, e.what());
4397	>	PyErr_SetString ( BossError, e.what() );
4398	>	return NULL;
4399		}
4400		}
4401		{
#	Line 3452 \| Line 4424 \| *static PyObject _wrap_BossTask_queryJob**
4424		try {
4425		result = ((BossTask const )arg1)->queryJobPrograms((BossJob const )arg2);
4426
4427	+	}catch (const BossSchedFailure & e) {
4428	+	PyErr_SetString ( SchedulerError, e.what() );
4429	+	return NULL;
4430		}catch (const std::exception& e) {
4431	<	SWIG_exception(SWIG_RuntimeError, e.what());
4431	>	PyErr_SetString ( BossError, e.what() );
4432	>	return NULL;
4433		}
4434		}
4435		{
#	Line 3503 \| Line 4479 \| *static PyObject _wrap_BossTask_declare_**
4479		try {
4480		(arg1)->declare((std::string const &)arg2,(std::string const &)arg3);
4481
4482	+	}catch (const BossSchedFailure & e) {
4483	+	PyErr_SetString ( SchedulerError, e.what() );
4484	+	return NULL;
4485		}catch (const std::exception& e) {
4486	<	SWIG_exception(SWIG_RuntimeError, e.what());
4486	>	PyErr_SetString ( BossError, e.what() );
4487	>	return NULL;
4488		}
4489		}
4490		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3542 \| Line 4522 \| *static PyObject _wrap_BossTask_declare_**
4522		try {
4523		(arg1)->declare(arg2,(std::string const &)*arg3);
4524
4525	+	}catch (const BossSchedFailure & e) {
4526	+	PyErr_SetString ( SchedulerError, e.what() );
4527	+	return NULL;
4528		}catch (const std::exception& e) {
4529	<	SWIG_exception(SWIG_RuntimeError, e.what());
4529	>	PyErr_SetString ( BossError, e.what() );
4530	>	return NULL;
4531		}
4532		}
4533		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3641 \| Line 4625 \| *static PyObject _wrap_BossTask_remove(P**
4625		try {
4626		(arg1)->remove();
4627
4628	+	}catch (const BossSchedFailure & e) {
4629	+	PyErr_SetString ( SchedulerError, e.what() );
4630	+	return NULL;
4631		}catch (const std::exception& e) {
4632	<	SWIG_exception(SWIG_RuntimeError, e.what());
4632	>	PyErr_SetString ( BossError, e.what() );
4633	>	return NULL;
4634		}
4635		}
4636		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3677 \| Line 4665 \| *static PyObject _wrap_BossTask_archive(**
4665		try {
4666		(arg1)->archive((std::string const &)*arg2);
4667
4668	+	}catch (const BossSchedFailure & e) {
4669	+	PyErr_SetString ( SchedulerError, e.what() );
4670	+	return NULL;
4671		}catch (const std::exception& e) {
4672	<	SWIG_exception(SWIG_RuntimeError, e.what());
4672	>	PyErr_SetString ( BossError, e.what() );
4673	>	return NULL;
4674		}
4675		}
4676		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3701 \| Line 4693 \| *static PyObject _wrap_BossTask_submit(P**
4693		std::string arg5 = (std::string ) &arg5_defvalue ;
4694		std::string const &arg6_defvalue = "" ;
4695		std::string arg6 = (std::string ) &arg6_defvalue ;
4696	<	bool arg7 = (bool) false ;
4696	>	unsigned int arg7 = (unsigned int) 0 ;
4697	>	bool arg8 = (bool) false ;
4698		int result;
4699		std::string temp2 ;
4700		std::string temp3 ;
#	Line 3715 \| Line 4708 \| *static PyObject _wrap_BossTask_submit(P**
4708		PyObject * obj4 = 0 ;
4709		PyObject * obj5 = 0 ;
4710		PyObject * obj6 = 0 ;
4711	+	PyObject * obj7 = 0 ;
4712
4713	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4713	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4714		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4715		if (obj1) {
4716		{
#	Line 3769 \| Line 4763 \| *static PyObject _wrap_BossTask_submit(P**
4763		}
4764		}
4765		if (obj6) {
4766	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4766	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4767	>	if (PyErr_Occurred()) SWIG_fail;
4768	>	}
4769	>	if (obj7) {
4770	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4771		if (PyErr_Occurred()) SWIG_fail;
4772		}
4773		{
4774		try {
4775	<	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);
4775	>	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);
4776
4777	+	}catch (const BossSchedFailure & e) {
4778	+	PyErr_SetString ( SchedulerError, e.what() );
4779	+	return NULL;
4780		}catch (const std::exception& e) {
4781	<	SWIG_exception(SWIG_RuntimeError, e.what());
4781	>	PyErr_SetString ( BossError, e.what() );
4782	>	return NULL;
4783		}
4784		}
4785		resultobj = PyInt_FromLong((long)result);
#	Line 3816 \| Line 4818 \| *static PyObject _wrap_BossTask_reSubmit**
4818		try {
4819		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4820
4821	+	}catch (const BossSchedFailure & e) {
4822	+	PyErr_SetString ( SchedulerError, e.what() );
4823	+	return NULL;
4824		}catch (const std::exception& e) {
4825	<	SWIG_exception(SWIG_RuntimeError, e.what());
4825	>	PyErr_SetString ( BossError, e.what() );
4826	>	return NULL;
4827		}
4828		}
4829		resultobj = PyInt_FromLong((long)result);
#	Line 3831 \| Line 4837 \| *static PyObject _wrap_BossTask_kill(PyO**
4837		PyObject *resultobj;
4838		BossTask arg1 = (BossTask ) 0 ;
4839		std::string *arg2 = 0 ;
4840	<	bool arg3 = (bool) false ;
4840	>	unsigned int arg3 = (unsigned int) 0 ;
4841	>	bool arg4 = (bool) false ;
4842		int result;
4843		std::string temp2 ;
4844		PyObject * obj0 = 0 ;
4845		PyObject * obj1 = 0 ;
4846		PyObject * obj2 = 0 ;
4847	+	PyObject * obj3 = 0 ;
4848
4849	<	if(!PyArg_ParseTuple(args,(char *)"OO\|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4849	>	if(!PyArg_ParseTuple(args,(char *)"OO\|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
4850		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4851		{
4852		if (PyString_Check(obj1)) {
#	Line 3849 \| Line 4857 \| *static PyObject _wrap_BossTask_kill(PyO**
4857		}
4858		}
4859		if (obj2) {
4860	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4860	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
4861	>	if (PyErr_Occurred()) SWIG_fail;
4862	>	}
4863	>	if (obj3) {
4864	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4865		if (PyErr_Occurred()) SWIG_fail;
4866		}
4867		{
4868		try {
4869	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4869	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
4870
4871	+	}catch (const BossSchedFailure & e) {
4872	+	PyErr_SetString ( SchedulerError, e.what() );
4873	+	return NULL;
4874		}catch (const std::exception& e) {
4875	<	SWIG_exception(SWIG_RuntimeError, e.what());
4875	>	PyErr_SetString ( BossError, e.what() );
4876	>	return NULL;
4877		}
4878		}
4879		resultobj = PyInt_FromLong((long)result);
#	Line 3867 \| Line 4883 \| *static PyObject _wrap_BossTask_kill(PyO**
4883		}
4884
4885
4886	<	static PyObject _wrap_BossTask_getOutput__SWIG_0(PyObject self, PyObject *args) {
4886	>	static PyObject _wrap_BossTask_getOutput(PyObject self, PyObject *args) {
4887		PyObject *resultobj;
4888		BossTask arg1 = (BossTask ) 0 ;
4889		std::string const &arg2_defvalue = "all" ;
4890		std::string arg2 = (std::string ) &arg2_defvalue ;
4891		std::string const &arg3_defvalue = "" ;
4892		std::string arg3 = (std::string ) &arg3_defvalue ;
4893	<	bool arg4 = (bool) false ;
4893	>	unsigned int arg4 = (unsigned int) 0 ;
4894		bool arg5 = (bool) false ;
4895	+	bool arg6 = (bool) false ;
4896		int result;
4897		std::string temp2 ;
4898		std::string temp3 ;
#	Line 3884 \| Line 4901 \| *static PyObject _wrap_BossTask_getOutpu**
4901		PyObject * obj2 = 0 ;
4902		PyObject * obj3 = 0 ;
4903		PyObject * obj4 = 0 ;
4904	+	PyObject * obj5 = 0 ;
4905
4906	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4906	>	if(!PyArg_ParseTuple(args,(char *)"O\|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
4907		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4908		if (obj1) {
4909		{
#	Line 3908 \| Line 4926 \| *static PyObject _wrap_BossTask_getOutpu**
4926		}
4927		}
4928		if (obj3) {
4929	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4929	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
4930		if (PyErr_Occurred()) SWIG_fail;
4931		}
4932		if (obj4) {
4933		arg5 = PyInt_AsLong(obj4) ? true : false;
4934		if (PyErr_Occurred()) SWIG_fail;
4935		}
4936	+	if (obj5) {
4937	+	arg6 = PyInt_AsLong(obj5) ? true : false;
4938	+	if (PyErr_Occurred()) SWIG_fail;
4939	+	}
4940		{
4941		try {
4942	<	result = (int)(arg1)->getOutput((std::string const &)arg2,(std::string const &)arg3,arg4,arg5);
4942	>	result = (int)(arg1)->getOutput((std::string const &)arg2,(std::string const &)arg3,arg4,arg5,arg6);
4943
4944	+	}catch (const BossSchedFailure & e) {
4945	+	PyErr_SetString ( SchedulerError, e.what() );
4946	+	return NULL;
4947		}catch (const std::exception& e) {
4948	<	SWIG_exception(SWIG_RuntimeError, e.what());
4948	>	PyErr_SetString ( BossError, e.what() );
4949	>	return NULL;
4950		}
4951		}
4952		resultobj = PyInt_FromLong((long)result);
#	Line 3930 \| Line 4956 \| *static PyObject _wrap_BossTask_getOutpu**
4956		}
4957
4958
4959	<	static PyObject _wrap_BossTask_getOutput__SWIG_1(PyObject self, PyObject *args) {
4959	>	static PyObject _wrap_BossTask_loadByName(PyObject self, PyObject *args) {
4960		PyObject *resultobj;
4961		BossTask arg1 = (BossTask ) 0 ;
4962	<	std::string const &arg2_defvalue = "" ;
3937	<	std::string arg2 = (std::string ) &arg2_defvalue ;
3938	<	bool arg3 = (bool) false ;
3939	<	bool arg4 = (bool) false ;
4962	>	std::string *arg2 = 0 ;
4963		int result;
4964		std::string temp2 ;
4965		PyObject * obj0 = 0 ;
4966		PyObject * obj1 = 0 ;
3944	–	PyObject * obj2 = 0 ;
3945	–	PyObject * obj3 = 0 ;
4967
4968	<	if(!PyArg_ParseTuple(args,(char *)"O\|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4968	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
4969		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
4970	<	if (obj1) {
4971	<	{
4972	<	if (PyString_Check(obj1)) {
4973	<	temp2 = std::string(PyString_AsString(obj1));
4974	<	arg2 = &temp2;
4975	<	}else {
3955	<	SWIG_exception(SWIG_TypeError, "string expected");
3956	<	}
4970	>	{
4971	>	if (PyString_Check(obj1)) {
4972	>	temp2 = std::string(PyString_AsString(obj1));
4973	>	arg2 = &temp2;
4974	>	}else {
4975	>	SWIG_exception(SWIG_TypeError, "string expected");
4976		}
4977		}
3959	–	if (obj2) {
3960	–	arg3 = PyInt_AsLong(obj2) ? true : false;
3961	–	if (PyErr_Occurred()) SWIG_fail;
3962	–	}
3963	–	if (obj3) {
3964	–	arg4 = PyInt_AsLong(obj3) ? true : false;
3965	–	if (PyErr_Occurred()) SWIG_fail;
3966	–	}
4978		{
4979		try {
4980	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
4980	>	result = (int)(arg1)->loadByName((std::string const &)*arg2);
4981
4982	+	}catch (const BossSchedFailure & e) {
4983	+	PyErr_SetString ( SchedulerError, e.what() );
4984	+	return NULL;
4985		}catch (const std::exception& e) {
4986	<	SWIG_exception(SWIG_RuntimeError, e.what());
4986	>	PyErr_SetString ( BossError, e.what() );
4987	>	return NULL;
4988		}
4989		}
4990		resultobj = PyInt_FromLong((long)result);
#	Line 3979 \| Line 4994 \| *static PyObject _wrap_BossTask_getOutpu**
4994		}
4995
4996
4997	<	static PyObject _wrap_BossTask_getOutput(PyObject self, PyObject *args) {
4998	<	int argc;
4999	<	PyObject *argv[6];
5000	<	int ii;
4997	>	static PyObject _wrap_BossTask_load(PyObject self, PyObject *args) {
4998	>	PyObject *resultobj;
4999	>	BossTask arg1 = (BossTask ) 0 ;
5000	>	int arg2 = (int) SCHEDULED ;
5001	>	std::string const &arg3_defvalue = "all" ;
5002	>	std::string arg3 = (std::string ) &arg3_defvalue ;
5003	>	std::string const &arg4_defvalue = "" ;
5004	>	std::string arg4 = (std::string ) &arg4_defvalue ;
5005	>	std::string arg5 = (std::string) "" ;
5006	>	std::string arg6 = (std::string) "" ;
5007	>	std::string arg7 = (std::string) "" ;
5008	>	std::string arg8 = (std::string) "" ;
5009	>	int result;
5010	>	std::string temp3 ;
5011	>	std::string temp4 ;
5012	>	PyObject * obj0 = 0 ;
5013	>	PyObject * obj2 = 0 ;
5014	>	PyObject * obj3 = 0 ;
5015	>	PyObject * obj4 = 0 ;
5016	>	PyObject * obj5 = 0 ;
5017	>	PyObject * obj6 = 0 ;
5018	>	PyObject * obj7 = 0 ;
5019
5020	<	argc = PyObject_Length(args);
5021	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
5022	<	argv[ii] = PyTuple_GetItem(args,ii);
3990	<	}
3991	<	if ((argc >= 1) && (argc <= 5)) {
3992	<	int _v;
5020	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5021	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5022	>	if (obj2) {
5023		{
5024	<	void *ptr;
5025	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5026	<	_v = 0;
3997	<	PyErr_Clear();
5024	>	if (PyString_Check(obj2)) {
5025	>	temp3 = std::string(PyString_AsString(obj2));
5026	>	arg3 = &temp3;
5027		}else {
5028	<	_v = 1;
4000	<	}
4001	<	}
4002	<	if (_v) {
4003	<	if (argc <= 1) {
4004	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4005	<	}
4006	<	{
4007	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4008	<	}
4009	<	if (_v) {
4010	<	if (argc <= 2) {
4011	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4012	<	}
4013	<	{
4014	<	_v = PyString_Check(argv[2]) ? 1 : 0;
4015	<	}
4016	<	if (_v) {
4017	<	if (argc <= 3) {
4018	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4019	<	}
4020	<	{
4021	<	_v = (PyInt_Check(argv[3]) \|\| PyLong_Check(argv[3])) ? 1 : 0;
4022	<	}
4023	<	if (_v) {
4024	<	if (argc <= 4) {
4025	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4026	<	}
4027	<	{
4028	<	_v = (PyInt_Check(argv[4]) \|\| PyLong_Check(argv[4])) ? 1 : 0;
4029	<	}
4030	<	if (_v) {
4031	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4032	<	}
4033	<	}
4034	<	}
5028	>	SWIG_exception(SWIG_TypeError, "string expected");
5029		}
5030		}
5031		}
5032	<	if ((argc >= 1) && (argc <= 4)) {
4039	<	int _v;
5032	>	if (obj3) {
5033		{
5034	<	void *ptr;
5035	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
5036	<	_v = 0;
4044	<	PyErr_Clear();
5034	>	if (PyString_Check(obj3)) {
5035	>	temp4 = std::string(PyString_AsString(obj3));
5036	>	arg4 = &temp4;
5037		}else {
5038	<	_v = 1;
5038	>	SWIG_exception(SWIG_TypeError, "string expected");
5039		}
5040		}
5041	<	if (_v) {
5042	<	if (argc <= 1) {
5043	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
5044	<	}
5045	<	{
5046	<	_v = PyString_Check(argv[1]) ? 1 : 0;
5047	<	}
4056	<	if (_v) {
4057	<	if (argc <= 2) {
4058	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4059	<	}
4060	<	{
4061	<	_v = (PyInt_Check(argv[2]) \|\| PyLong_Check(argv[2])) ? 1 : 0;
4062	<	}
4063	<	if (_v) {
4064	<	if (argc <= 3) {
4065	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4066	<	}
4067	<	{
4068	<	_v = (PyInt_Check(argv[3]) \|\| PyLong_Check(argv[3])) ? 1 : 0;
4069	<	}
4070	<	if (_v) {
4071	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4072	<	}
4073	<	}
4074	<	}
5041	>	}
5042	>	if (obj4) {
5043	>	{
5044	>	if (PyString_Check(obj4))
5045	>	arg5 = std::string(PyString_AsString(obj4));
5046	>	else
5047	>	SWIG_exception(SWIG_TypeError, "string expected");
5048		}
5049		}
5050	<
5051	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
5050	>	if (obj5) {
5051	>	{
5052	>	if (PyString_Check(obj5))
5053	>	arg6 = std::string(PyString_AsString(obj5));
5054	>	else
5055	>	SWIG_exception(SWIG_TypeError, "string expected");
5056	>	}
5057	>	}
5058	>	if (obj6) {
5059	>	{
5060	>	if (PyString_Check(obj6))
5061	>	arg7 = std::string(PyString_AsString(obj6));
5062	>	else
5063	>	SWIG_exception(SWIG_TypeError, "string expected");
5064	>	}
5065	>	}
5066	>	if (obj7) {
5067	>	{
5068	>	if (PyString_Check(obj7))
5069	>	arg8 = std::string(PyString_AsString(obj7));
5070	>	else
5071	>	SWIG_exception(SWIG_TypeError, "string expected");
5072	>	}
5073	>	}
5074	>	{
5075	>	try {
5076	>	result = (int)(arg1)->load(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8);
5077	>
5078	>	}catch (const BossSchedFailure & e) {
5079	>	PyErr_SetString ( SchedulerError, e.what() );
5080	>	return NULL;
5081	>	}catch (const std::exception& e) {
5082	>	PyErr_SetString ( BossError, e.what() );
5083	>	return NULL;
5084	>	}
5085	>	}
5086	>	resultobj = PyInt_FromLong((long)result);
5087	>	return resultobj;
5088	>	fail:
5089		return NULL;
5090		}
5091
#	Line 4092 \| Line 5102 \| *static PyObject _wrap_BossTask_query(Py**
5102		std::string arg6 = (std::string) "" ;
5103		std::string arg7 = (std::string) "" ;
5104		std::string arg8 = (std::string) "" ;
5105	<	bool arg9 = (bool) false ;
5105	>	unsigned int arg9 = (unsigned int) 0 ;
5106	>	bool arg10 = (bool) false ;
5107		int result;
5108		std::string temp3 ;
5109		std::string temp4 ;
#	Line 4104 \| Line 5115 \| *static PyObject _wrap_BossTask_query(Py**
5115		PyObject * obj6 = 0 ;
5116		PyObject * obj7 = 0 ;
5117		PyObject * obj8 = 0 ;
5118	+	PyObject * obj9 = 0 ;
5119
5120	<	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5120	>	if(!PyArg_ParseTuple(args,(char *)"O\|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5121		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5122		if (obj2) {
5123		{
#	Line 4160 \| Line 5172 \| *static PyObject _wrap_BossTask_query(Py**
5172		}
5173		}
5174		if (obj8) {
5175	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5175	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5176	>	if (PyErr_Occurred()) SWIG_fail;
5177	>	}
5178	>	if (obj9) {
5179	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5180		if (PyErr_Occurred()) SWIG_fail;
5181		}
5182		{
5183		try {
5184	<	result = (int)(arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9);
5184	>	result = (int)(arg1)->query(arg2,(std::string const &)arg3,(std::string const &)arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5185
5186	+	}catch (const BossSchedFailure & e) {
5187	+	PyErr_SetString ( SchedulerError, e.what() );
5188	+	return NULL;
5189		}catch (const std::exception& e) {
5190	<	SWIG_exception(SWIG_RuntimeError, e.what());
5190	>	PyErr_SetString ( BossError, e.what() );
5191	>	return NULL;
5192		}
5193		}
5194		resultobj = PyInt_FromLong((long)result);
#	Line 4226 \| Line 5246 \| *static PyObject _wrap_BossTask_query_ou**
5246		try {
5247		((BossTask const )arg1)->query_out(arg2,(jobStates const &)arg3,(printOption const &)arg4,arg5);
5248
5249	+	}catch (const BossSchedFailure & e) {
5250	+	PyErr_SetString ( SchedulerError, e.what() );
5251	+	return NULL;
5252		}catch (const std::exception& e) {
5253	<	SWIG_exception(SWIG_RuntimeError, e.what());
5253	>	PyErr_SetString ( BossError, e.what() );
5254	>	return NULL;
5255		}
5256		}
5257		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4248 \| Line 5272 \| *static PyObject _wrap_BossTask_clear(Py**
5272		try {
5273		(arg1)->clear();
5274
5275	+	}catch (const BossSchedFailure & e) {
5276	+	PyErr_SetString ( SchedulerError, e.what() );
5277	+	return NULL;
5278		}catch (const std::exception& e) {
5279	<	SWIG_exception(SWIG_RuntimeError, e.what());
5279	>	PyErr_SetString ( BossError, e.what() );
5280	>	return NULL;
5281		}
5282		}
5283		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4259 \| Line 5287 \| *static PyObject _wrap_BossTask_clear(Py**
5287		}
5288
5289
5290	<	static PyObject * BossTask_swigregister(PyObject self, PyObject args) {
5291	<	PyObject *obj;
5292	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5293	<	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5294	<	Py_INCREF(obj);
5295	<	return Py_BuildValue((char *)"");
5290	>	static PyObject _wrap_BossTask_appendToPyDict(PyObject self, PyObject *args) {
5291	>	PyObject *resultobj;
5292	>	BossTask arg1 = (BossTask ) 0 ;
5293	>	PyObject arg2 = (PyObject ) 0 ;
5294	>	BossAttributeContainer *arg3 = 0 ;
5295	>	PyObject * obj0 = 0 ;
5296	>	PyObject * obj1 = 0 ;
5297	>	PyObject * obj2 = 0 ;
5298	>
5299	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5300	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5301	>	arg2 = obj1;
5302	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5303	>	if (arg3 == NULL) {
5304	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5305	>	}
5306	>	{
5307	>	try {
5308	>	BossTask_appendToPyDict((BossTask const )arg1,arg2,(BossAttributeContainer const &)arg3);
5309	>
5310	>	}catch (const BossSchedFailure & e) {
5311	>	PyErr_SetString ( SchedulerError, e.what() );
5312	>	return NULL;
5313	>	}catch (const std::exception& e) {
5314	>	PyErr_SetString ( BossError, e.what() );
5315	>	return NULL;
5316	>	}
5317	>	}
5318	>	Py_INCREF(Py_None); resultobj = Py_None;
5319	>	return resultobj;
5320	>	fail:
5321	>	return NULL;
5322		}
5323	<	static PyObject _wrap_prompt(PyObject self, PyObject *args) {
5323	>
5324	>
5325	>	static PyObject _wrap_BossTask_jobDict(PyObject self, PyObject *args) {
5326		PyObject *resultobj;
5327	<	std::string *arg1 = 0 ;
5328	<	bool result;
5329	<	std::string temp1 ;
5327	>	BossTask arg1 = (BossTask ) 0 ;
5328	>	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5329	>	PyObject arg3 = (PyObject ) 0 ;
5330		PyObject * obj0 = 0 ;
5331	+	PyObject * obj1 = 0 ;
5332	+	PyObject * obj2 = 0 ;
5333
5334	<	if(!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) goto fail;
5334	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5335	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5336	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5337	>	if (arg2 == NULL) {
5338	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5339	>	}
5340	>	arg3 = obj2;
5341		{
5342	<	if (PyString_Check(obj0)) {
5343	<	temp1 = std::string(PyString_AsString(obj0));
5344	<	arg1 = &temp1;
5342	>	try {
5343	>	BossTask_jobDict((BossTask const )arg1,arg2,arg3);
5344	>
5345	>	}catch (const BossSchedFailure & e) {
5346	>	PyErr_SetString ( SchedulerError, e.what() );
5347	>	return NULL;
5348	>	}catch (const std::exception& e) {
5349	>	PyErr_SetString ( BossError, e.what() );
5350	>	return NULL;
5351	>	}
5352	>	}
5353	>	Py_INCREF(Py_None); resultobj = Py_None;
5354	>	return resultobj;
5355	>	fail:
5356	>	return NULL;
5357	>	}
5358	>
5359	>
5360	>	static PyObject _wrap_BossTask_jobsDict(PyObject self, PyObject *args) {
5361	>	PyObject *resultobj;
5362	>	BossTask arg1 = (BossTask ) 0 ;
5363	>	PyObject *result;
5364	>	PyObject * obj0 = 0 ;
5365	>
5366	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5367	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5368	>	{
5369	>	try {
5370	>	result = (PyObject *)BossTask_jobsDict(arg1);
5371	>
5372	>	}catch (const BossSchedFailure & e) {
5373	>	PyErr_SetString ( SchedulerError, e.what() );
5374	>	return NULL;
5375	>	}catch (const std::exception& e) {
5376	>	PyErr_SetString ( BossError, e.what() );
5377	>	return NULL;
5378	>	}
5379	>	}
5380	>	resultobj = result;
5381	>	return resultobj;
5382	>	fail:
5383	>	return NULL;
5384	>	}
5385	>
5386	>
5387	>	static PyObject _wrap_BossTask_progDict(PyObject self, PyObject *args) {
5388	>	PyObject *resultobj;
5389	>	BossTask arg1 = (BossTask ) 0 ;
5390	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5391	>	PyObject *result;
5392	>	PyObject * obj0 = 0 ;
5393	>	PyObject * obj1 = 0 ;
5394	>
5395	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5396	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5397	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5398	>	if (arg2 == NULL) {
5399	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5400	>	}
5401	>	{
5402	>	try {
5403	>	result = (PyObject )BossTask_progDict((BossTask const )arg1,*arg2);
5404	>
5405	>	}catch (const BossSchedFailure & e) {
5406	>	PyErr_SetString ( SchedulerError, e.what() );
5407	>	return NULL;
5408	>	}catch (const std::exception& e) {
5409	>	PyErr_SetString ( BossError, e.what() );
5410	>	return NULL;
5411	>	}
5412	>	}
5413	>	resultobj = result;
5414	>	return resultobj;
5415	>	fail:
5416	>	return NULL;
5417	>	}
5418	>
5419	>
5420	>	static PyObject _wrap_BossTask_jobPrograms(PyObject self, PyObject *args) {
5421	>	PyObject *resultobj;
5422	>	BossTask arg1 = (BossTask ) 0 ;
5423	>	std::string *arg2 = 0 ;
5424	>	PyObject *result;
5425	>	std::string temp2 ;
5426	>	PyObject * obj0 = 0 ;
5427	>	PyObject * obj1 = 0 ;
5428	>
5429	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5430	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
5431	>	{
5432	>	if (PyString_Check(obj1)) {
5433	>	temp2 = std::string(PyString_AsString(obj1));
5434	>	arg2 = &temp2;
5435		}else {
5436		SWIG_exception(SWIG_TypeError, "string expected");
5437		}
5438		}
5439		{
5440		try {
5441	<	result = (bool)prompt((std::string const &)*arg1);
5441	>	result = (PyObject )BossTask_jobPrograms((BossTask const )arg1,(std::string const &)*arg2);
5442
5443	+	}catch (const BossSchedFailure & e) {
5444	+	PyErr_SetString ( SchedulerError, e.what() );
5445	+	return NULL;
5446		}catch (const std::exception& e) {
5447	<	SWIG_exception(SWIG_RuntimeError, e.what());
5447	>	PyErr_SetString ( BossError, e.what() );
5448	>	return NULL;
5449		}
5450		}
5451	<	resultobj = PyInt_FromLong((long)result);
5451	>	resultobj = result;
5452		return resultobj;
5453		fail:
5454		return NULL;
5455		}
5456
5457
5458	+	static PyObject * BossTask_swigregister(PyObject self, PyObject args) {
5459	+	PyObject *obj;
5460	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5461	+	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5462	+	Py_INCREF(obj);
5463	+	return Py_BuildValue((char *)"");
5464	+	}
5465		static PyObject _wrap_new_BossAdministratorSession(PyObject self, PyObject *args) {
5466		PyObject *resultobj;
5467		std::string arg1 = (std::string) "" ;
5468	<	bool arg2 = (bool) false ;
5468	>	std::string arg2 = (std::string) "2" ;
5469	>	std::string arg3 = (std::string) "" ;
5470	>	std::string arg4 = (std::string) "" ;
5471	>	bool arg5 = (bool) false ;
5472		BossAdministratorSession *result;
5473		PyObject * obj0 = 0 ;
5474		PyObject * obj1 = 0 ;
5475	+	PyObject * obj2 = 0 ;
5476	+	PyObject * obj3 = 0 ;
5477	+	PyObject * obj4 = 0 ;
5478
5479	<	if(!PyArg_ParseTuple(args,(char *)"\|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
5479	>	if(!PyArg_ParseTuple(args,(char *)"\|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5480		if (obj0) {
5481		{
5482		if (PyString_Check(obj0))
#	Line 4315 \| Line 5486 \| *static PyObject _wrap_new_BossAdministr**
5486		}
5487		}
5488		if (obj1) {
5489	<	arg2 = PyInt_AsLong(obj1) ? true : false;
5489	>	{
5490	>	if (PyString_Check(obj1))
5491	>	arg2 = std::string(PyString_AsString(obj1));
5492	>	else
5493	>	SWIG_exception(SWIG_TypeError, "string expected");
5494	>	}
5495	>	}
5496	>	if (obj2) {
5497	>	{
5498	>	if (PyString_Check(obj2))
5499	>	arg3 = std::string(PyString_AsString(obj2));
5500	>	else
5501	>	SWIG_exception(SWIG_TypeError, "string expected");
5502	>	}
5503	>	}
5504	>	if (obj3) {
5505	>	{
5506	>	if (PyString_Check(obj3))
5507	>	arg4 = std::string(PyString_AsString(obj3));
5508	>	else
5509	>	SWIG_exception(SWIG_TypeError, "string expected");
5510	>	}
5511	>	}
5512	>	if (obj4) {
5513	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5514		if (PyErr_Occurred()) SWIG_fail;
5515		}
5516		{
5517		try {
5518	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
5518	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5519
5520	+	}catch (const BossSchedFailure & e) {
5521	+	PyErr_SetString ( SchedulerError, e.what() );
5522	+	return NULL;
5523		}catch (const std::exception& e) {
5524	<	SWIG_exception(SWIG_RuntimeError, e.what());
5524	>	PyErr_SetString ( BossError, e.what() );
5525	>	return NULL;
5526		}
5527		}
5528		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 4344 \| Line 5543 \| *static PyObject _wrap_delete_BossAdmini**
5543		try {
5544		delete arg1;
5545
5546	+	}catch (const BossSchedFailure & e) {
5547	+	PyErr_SetString ( SchedulerError, e.what() );
5548	+	return NULL;
5549		}catch (const std::exception& e) {
5550	<	SWIG_exception(SWIG_RuntimeError, e.what());
5550	>	PyErr_SetString ( BossError, e.what() );
5551	>	return NULL;
5552		}
5553		}
5554		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4367 \| Line 5570 \| *static PyObject _wrap_BossAdministrator**
5570		try {
5571		result = (int)(arg1)->configureDB();
5572
5573	+	}catch (const BossSchedFailure & e) {
5574	+	PyErr_SetString ( SchedulerError, e.what() );
5575	+	return NULL;
5576		}catch (const std::exception& e) {
5577	<	SWIG_exception(SWIG_RuntimeError, e.what());
5577	>	PyErr_SetString ( BossError, e.what() );
5578	>	return NULL;
5579		}
5580		}
5581		resultobj = PyInt_FromLong((long)result);
#	Line 4401 \| Line 5608 \| *static PyObject _wrap_BossAdministrator**
5608		try {
5609		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5610
5611	+	}catch (const BossSchedFailure & e) {
5612	+	PyErr_SetString ( SchedulerError, e.what() );
5613	+	return NULL;
5614		}catch (const std::exception& e) {
5615	<	SWIG_exception(SWIG_RuntimeError, e.what());
5615	>	PyErr_SetString ( BossError, e.what() );
5616	>	return NULL;
5617		}
5618		}
5619		resultobj = PyInt_FromLong((long)result);
#	Line 4435 \| Line 5646 \| *static PyObject _wrap_BossAdministrator**
5646		try {
5647		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5648
5649	+	}catch (const BossSchedFailure & e) {
5650	+	PyErr_SetString ( SchedulerError, e.what() );
5651	+	return NULL;
5652		}catch (const std::exception& e) {
5653	<	SWIG_exception(SWIG_RuntimeError, e.what());
5653	>	PyErr_SetString ( BossError, e.what() );
5654	>	return NULL;
5655		}
5656		}
5657		resultobj = PyInt_FromLong((long)result);
#	Line 4469 \| Line 5684 \| *static PyObject _wrap_BossAdministrator**
5684		try {
5685		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5686
5687	+	}catch (const BossSchedFailure & e) {
5688	+	PyErr_SetString ( SchedulerError, e.what() );
5689	+	return NULL;
5690		}catch (const std::exception& e) {
5691	<	SWIG_exception(SWIG_RuntimeError, e.what());
5691	>	PyErr_SetString ( BossError, e.what() );
5692	>	return NULL;
5693		}
5694		}
5695		resultobj = PyInt_FromLong((long)result);
#	Line 4503 \| Line 5722 \| *static PyObject _wrap_BossAdministrator**
5722		try {
5723		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5724
5725	+	}catch (const BossSchedFailure & e) {
5726	+	PyErr_SetString ( SchedulerError, e.what() );
5727	+	return NULL;
5728		}catch (const std::exception& e) {
5729	<	SWIG_exception(SWIG_RuntimeError, e.what());
5729	>	PyErr_SetString ( BossError, e.what() );
5730	>	return NULL;
5731		}
5732		}
5733		resultobj = PyInt_FromLong((long)result);
#	Line 4537 \| Line 5760 \| *static PyObject _wrap_BossAdministrator**
5760		try {
5761		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5762
5763	+	}catch (const BossSchedFailure & e) {
5764	+	PyErr_SetString ( SchedulerError, e.what() );
5765	+	return NULL;
5766		}catch (const std::exception& e) {
5767	<	SWIG_exception(SWIG_RuntimeError, e.what());
5767	>	PyErr_SetString ( BossError, e.what() );
5768	>	return NULL;
5769		}
5770		}
5771		resultobj = PyInt_FromLong((long)result);
#	Line 4603 \| Line 5830 \| *static PyObject _wrap_BossAdministrator**
5830		try {
5831		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5832
5833	+	}catch (const BossSchedFailure & e) {
5834	+	PyErr_SetString ( SchedulerError, e.what() );
5835	+	return NULL;
5836		}catch (const std::exception& e) {
5837	<	SWIG_exception(SWIG_RuntimeError, e.what());
5837	>	PyErr_SetString ( BossError, e.what() );
5838	>	return NULL;
5839		}
5840		}
5841		resultobj = PyInt_FromLong((long)result);
#	Line 4693 \| Line 5924 \| *static PyObject _wrap_BossAdministrator**
5924		try {
5925		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5926
5927	+	}catch (const BossSchedFailure & e) {
5928	+	PyErr_SetString ( SchedulerError, e.what() );
5929	+	return NULL;
5930		}catch (const std::exception& e) {
5931	<	SWIG_exception(SWIG_RuntimeError, e.what());
5931	>	PyErr_SetString ( BossError, e.what() );
5932	>	return NULL;
5933		}
5934		}
5935		resultobj = PyInt_FromLong((long)result);
#	Line 4769 \| Line 6004 \| *static PyObject _wrap_BossAdministrator**
6004		try {
6005		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6006
6007	+	}catch (const BossSchedFailure & e) {
6008	+	PyErr_SetString ( SchedulerError, e.what() );
6009	+	return NULL;
6010		}catch (const std::exception& e) {
6011	<	SWIG_exception(SWIG_RuntimeError, e.what());
6011	>	PyErr_SetString ( BossError, e.what() );
6012	>	return NULL;
6013		}
6014		}
6015		resultobj = PyInt_FromLong((long)result);
#	Line 4798 \| Line 6037 \| *static PyObject _wrap_BossAdministrator**
6037		std::string arg13 = (std::string) "" ;
6038		bool arg14 = (bool) false ;
6039		bool arg15 = (bool) false ;
6040	+	bool arg16 = (bool) false ;
6041	+	bool arg17 = (bool) false ;
6042		int result;
6043		std::string temp2 ;
6044		std::string temp11 ;
#	Line 4816 \| Line 6057 \| *static PyObject _wrap_BossAdministrator**
6057		PyObject * obj12 = 0 ;
6058		PyObject * obj13 = 0 ;
6059		PyObject * obj14 = 0 ;
6060	+	PyObject * obj15 = 0 ;
6061	+	PyObject * obj16 = 0 ;
6062
6063	<	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;
6063	>	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;
6064		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
6065		{
6066		if (PyString_Check(obj1)) {
#	Line 4925 \| Line 6168 \| *static PyObject _wrap_BossAdministrator**
6168		arg15 = PyInt_AsLong(obj14) ? true : false;
6169		if (PyErr_Occurred()) SWIG_fail;
6170		}
6171	+	if (obj15) {
6172	+	arg16 = PyInt_AsLong(obj15) ? true : false;
6173	+	if (PyErr_Occurred()) SWIG_fail;
6174	+	}
6175	+	if (obj16) {
6176	+	arg17 = PyInt_AsLong(obj16) ? true : false;
6177	+	if (PyErr_Occurred()) SWIG_fail;
6178	+	}
6179		{
6180		try {
6181	<	result = (int)(arg1)->registerScheduler((std::string const &)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)arg11,arg12,arg13,arg14,arg15);
6181	>	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);
6182
6183	+	}catch (const BossSchedFailure & e) {
6184	+	PyErr_SetString ( SchedulerError, e.what() );
6185	+	return NULL;
6186		}catch (const std::exception& e) {
6187	<	SWIG_exception(SWIG_RuntimeError, e.what());
6187	>	PyErr_SetString ( BossError, e.what() );
6188	>	return NULL;
6189		}
6190		}
6191		resultobj = PyInt_FromLong((long)result);
#	Line 4952 \| Line 6207 \| *static PyObject _wrap_BossAdministrator**
6207		try {
6208		result = (arg1)->help();
6209
6210	+	}catch (const BossSchedFailure & e) {
6211	+	PyErr_SetString ( SchedulerError, e.what() );
6212	+	return NULL;
6213		}catch (const std::exception& e) {
6214	<	SWIG_exception(SWIG_RuntimeError, e.what());
6214	>	PyErr_SetString ( BossError, e.what() );
6215	>	return NULL;
6216		}
6217		}
6218		{
#	Line 4991 \| Line 6250 \| *static PyObject _wrap_BossAdministrator**
6250		try {
6251		result = (arg1)->SQL(arg2,arg3);
6252
6253	+	}catch (const BossSchedFailure & e) {
6254	+	PyErr_SetString ( SchedulerError, e.what() );
6255	+	return NULL;
6256		}catch (const std::exception& e) {
6257	<	SWIG_exception(SWIG_RuntimeError, e.what());
6257	>	PyErr_SetString ( BossError, e.what() );
6258	>	return NULL;
6259		}
6260		}
6261		{
#	Line 5063 \| Line 6326 \| *static PyObject _wrap_BossAdministrator**
6326		try {
6327		result = (int)(arg1)->purge((std::string const &)arg2,(std::string const &)arg3,(std::string const &)arg4,(std::string const &)arg5);
6328
6329	+	}catch (const BossSchedFailure & e) {
6330	+	PyErr_SetString ( SchedulerError, e.what() );
6331	+	return NULL;
6332		}catch (const std::exception& e) {
6333	<	SWIG_exception(SWIG_RuntimeError, e.what());
6333	>	PyErr_SetString ( BossError, e.what() );
6334	>	return NULL;
6335	>	}
6336	>	}
6337	>	resultobj = PyInt_FromLong((long)result);
6338	>	return resultobj;
6339	>	fail:
6340	>	return NULL;
6341	>	}
6342	>
6343	>
6344	>	static PyObject _wrap_BossAdministratorSession_registerPlugins(PyObject self, PyObject *args) {
6345	>	PyObject *resultobj;
6346	>	BossAdministratorSession arg1 = (BossAdministratorSession ) 0 ;
6347	>	std::string arg2 ;
6348	>	int result;
6349	>	PyObject * obj0 = 0 ;
6350	>	PyObject * obj1 = 0 ;
6351	>
6352	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6353	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION \| 0 )) == -1) SWIG_fail;
6354	>	{
6355	>	if (PyString_Check(obj1))
6356	>	arg2 = std::string(PyString_AsString(obj1));
6357	>	else
6358	>	SWIG_exception(SWIG_TypeError, "string expected");
6359	>	}
6360	>	{
6361	>	try {
6362	>	result = (int)(arg1)->registerPlugins(arg2);
6363	>
6364	>	}catch (const BossSchedFailure & e) {
6365	>	PyErr_SetString ( SchedulerError, e.what() );
6366	>	return NULL;
6367	>	}catch (const std::exception& e) {
6368	>	PyErr_SetString ( BossError, e.what() );
6369	>	return NULL;
6370		}
6371		}
6372		resultobj = PyInt_FromLong((long)result);
#	Line 5097 \| Line 6399 \| static PyMethodDef SwigMethods[] = {
6399		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6400		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6401		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6402	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6403	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6404	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6405	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6406	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6407	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6402	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6403	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6404	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6405	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6406	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6407	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6408	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6409	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6410	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6411	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6412	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6413	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6414	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6415	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6416		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6417		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6418	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6419		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6420		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6421		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6422	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6423	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6424	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6425	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6426		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6427		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6428		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5119 \| Line 6434 \| static PyMethodDef SwigMethods[] = {
6434		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6435		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6436		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6437	+	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
6438	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6439	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
6440	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6441	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6442	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6443	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6444	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6445	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6446	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6447		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6448		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6449		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5126 \| Line 6451 \| static PyMethodDef SwigMethods[] = {
6451		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6452		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6453		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5129	–	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5130	–	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5131	–	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5132	–	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5133	–	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6454		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6455		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6456		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
#	Line 5138 \| Line 6458 \| static PyMethodDef SwigMethods[] = {
6458		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6459		{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6460		{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6461	+	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
6462		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6463		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6464		{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
#	Line 5148 \| Line 6469 \| static PyMethodDef SwigMethods[] = {
6469		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6470		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6471		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6472	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
6473	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6474		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6475		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6476		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6477	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6478	+	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6479	+	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6480	+	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6481	+	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6482		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5155	–	{ (char *)"prompt", _wrap_prompt, METH_VARARGS },
6483		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6484		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
6485		{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
#	Line 5168 \| Line 6495 \| static PyMethodDef SwigMethods[] = {
6495		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
6496		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
6497		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
6498	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
6499		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
6500		{ NULL, NULL }
6501		};
#	Line 5178 \| Line 6506 \| static PyMethodDef SwigMethods[] = {
6506		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6507		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}};
6508		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}};
6509	+	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}};
6510		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}};
6511	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6512		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6513		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5184	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
5185	–	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6514		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6515	+	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6516		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6517		static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6518		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6519		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}};
6520		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}};
6521		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5193	–	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}};
6522		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}};
6523	+	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}};
6524		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6525
6526		static swig_type_info *swig_types_initial[] = {
6527		_swigt__p_XMLDoc,
6528		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6529		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6530	+	_swigt__p_std__vectorTBossTask_p_t,
6531		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6532	+	_swigt__p_std__ostream,
6533		_swigt__p_BossTask,
6534		_swigt__p_BossTaskException,
5204	–	_swigt__p_std__ostream,
5205	–	_swigt__p_BossAttributeContainer,
6535		_swigt__p_printOption,
6536	+	_swigt__p_BossAttributeContainer,
6537		_swigt__p_BossJob,
6538		_swigt__p_BossDatabase,
6539		_swigt__p_BossSession,
6540		_swigt__p_std__vectorTstd__string_t,
6541		_swigt__p_std__mapTstd__string_std__string_t,
6542		_swigt__p_BossAdministratorSession,
5213	–	_swigt__p_BossTask__job_iterator,
6543		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6544	+	_swigt__p_BossTask__job_iterator,
6545		_swigt__p_jobStates,
6546		0
6547		};
#	Line 5255 \| Line 6585 \| SWIGEXPORT(void) SWIG_init(void) {
6585		}
6586		SWIG_InstallConstants(d,swig_const_table);
6587
6588	+
6589	+	// define custom exceptions
6590	+	PyObject *e;
6591	+	PyMethodDef tp_methods = {
6592	+	NULL, NULL, 0, NULL
6593	+	};
6594	+	e = Py_InitModule("BossSession", &tp_methods);
6595	+	// generic BOSS exception
6596	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6597	+	Py_INCREF(BossError);
6598	+	PyModule_AddObject(e, "BossError", BossError);
6599	+	// scheduler interaction BOSS exception
6600	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6601	+	Py_INCREF(SchedulerError);
6602	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6603	+
6604		}
6605

Diff Legend

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents): Revision 1.7 by gcodispo, Fri Oct 27 13:36:09 2006 UTC vs. Revision 1.27 by gcodispo, Thu Mar 8 17:52:39 2007 UTC

Diff Legend

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.7 by gcodispo, Fri Oct 27 13:36:09 2006 UTC vs.
Revision 1.27 by gcodispo, Thu Mar 8 17:52:39 2007 UTC