ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.18 by gcodispo, Mon Dec 11 09:16:06 2006 UTC vs.
Revision 1.26 by gcodispo, Thu Mar 8 11:06:25 2007 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[0]
658	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[1]
659	<	#define  SWIGTYPE_p_XMLDoc swig_types[2]
657	>	#define  SWIGTYPE_p_XMLDoc swig_types[0]
658	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
659	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660		#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[3]
661		#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662	<	#define  SWIGTYPE_p_BossTask swig_types[5]
663	<	#define  SWIGTYPE_p_BossTaskException swig_types[6]
664	<	#define  SWIGTYPE_p_std__ostream swig_types[7]
665	<	#define  SWIGTYPE_p_BossAttributeContainer swig_types[8]
666	<	#define  SWIGTYPE_p_printOption swig_types[9]
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_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_BossTask__job_iterator swig_types[16]
674	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[17]
673	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[17]
675		#define  SWIGTYPE_p_jobStates swig_types[18]
676		static swig_type_info *swig_types[20];
677
#	Line 917 | Line 917 | void std_vectorlstd_string_g___delslice_
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 928 | Line 930 | void std_vectorlstd_string_g___delslice_
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 954 | Line 957 | PyObject *BossSession_schedulers(BossSes
957		std::vector<std::string> my_vec = self->showSchedulers();
958		return BossSession_show( self, my_vec );
959		}
960	<	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
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);
965	>	jobid,
966	>	timeout);
967		return BossSession_show( self, my_vec );
968		}
969	<	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,bool avoidCheck){
970	<	if ( !avoidCheck ) {
971	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
972	<	type, user, after, before);
973	<	}
974	<	PyObject * job_dict = PyList_New(0);
975	<	std::vector <std::string>
976	<	taskList = self->selectTasks( taskRange, before, after, user);
973	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
974	<	it!= taskList.end(); ++it ) {
975	<	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
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	>	std::cout << "taskRange\n";
976	>	taskList = self->selectTasksByName( taskName );
977		}
978	<	return  job_dict;
979	<	}
980	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
980	<	std::string tmp;
981	<	BossAttributeContainer::const_iterator it_end = obj.end ();
982	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
983	<	it != it_end; ++it) {
984	<	tmp = (*it).first.name ();
985	<	char * key = new char[ tmp.size() ];
986	<	key = strdup(tmp.c_str());
987	<	tmp = (*it).second.value ();
988	<	PyObject * val = PyString_FromString( tmp.c_str() );
989	<	PyDict_SetItemString( dict, key, val );
990	<	delete [] key;
978	>	for ( std::vector <std::string>::const_iterator it= taskList.begin();
979	>	it!= taskList.end(); ++it ) {
980	>	PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
981		}
982	<	return dict;
982	>	return  task_list;
983		}
984	<	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
984	>	void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
985	>	std::string tmp;
986	>	BossAttributeContainer::const_iterator it_end = obj.end ();
987	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
988	>	it != it_end; ++it) {
989	>
990	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
991	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
992	>	PyDict_SetItem( dict, key, val);
993	>	Py_DECREF(key);
994	>	Py_DECREF(val);
995	>	}
996	>	return;
997	>	}
998	>	void BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit,PyObject *job_dict){
999
1000	<	PyObject * job_dict = PyDict_New();
1000	>	//    PyObject * job_dict = PyDict_New();
1001		std::string tmp;
1002
1003		BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1004	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1004	>	BossTask_appendToPyDict ( self, job_dict, obj );
1005
1006		std::set<std::string> sch = (*jit)->getSchedulerElements();
1007		std::set<std::string>::const_iterator sch_end =  sch.end();
1008		for (std::set<std::string>::const_iterator it =sch.begin();
1009		it != sch_end; ++ it ) {
1010	<	tmp = (*it);
1007	<	char * key = new char[ tmp.size() ];
1008	<	key = strdup(tmp.c_str());
1010	>
1011		tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1012	+	PyObject * key = PyString_FromString( it->c_str() );
1013		PyObject * val = PyString_FromString( tmp.c_str() );
1014	<	PyDict_SetItemString( job_dict, key, val );
1015	<	delete [] key;
1014	>	PyDict_SetItem( job_dict, key, val);
1015	>	Py_DECREF(key);
1016	>	Py_DECREF(val);
1017		}
1018	<	return job_dict;
1018	>	return;
1019		}
1020		PyObject *BossTask_jobsDict(BossTask *self){
1021
#	Line 1019 | Line 1023 | PyObject *BossTask_jobsDict(BossTask *se
1023		if ( self->job_begin () == self->job_end ()) self->load(ALL);
1024		for (BossTask::job_iterator jit = self->job_begin ();
1025		jit != self->job_end (); ++jit) {
1026	<	std::string id = (*jit)->chainId();
1027	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1028	<	PyObject * myid =  PyString_FromString(id.c_str() );
1029	<	PyDict_SetItem( job_dict, myid,tmp );
1026	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1027	>	PyObject * tmp_dict = PyDict_New();
1028	>	BossTask_jobDict( self, jit, tmp_dict );
1029	>	PyDict_SetItem( job_dict, id, tmp_dict );
1030	>	Py_DECREF(id);
1031	>	Py_DECREF(tmp_dict);
1032		}
1033		return job_dict;
1034		}
#	Line 1067 | Line 1073 | PyObject *BossTask_jobPrograms(BossTask
1073		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1074		++programs_it  ) {
1075		std::string id = (programs_it->first)["PROGRAM.ID"];
1076	<	PyObject * tmp =  BossTask_progDict( self, programs_it );
1076	>	PyObject * tmp_dict =  BossTask_progDict( self, programs_it );
1077		PyObject * myid =  PyString_FromString(id.c_str() );
1078	<	PyDict_SetItem( job_dict, myid,tmp );
1078	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1079	>	Py_DECREF(myid);
1080	>	Py_DECREF(tmp_dict);
1081		}
1082		return job_dict;
1083		}
#	Line 1086 | Line 1094 | static PyObject *_wrap_new_objectMap__SW
1094		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1095
1096		}catch (const BossSchedFailure & e) {
1097	<	SWIG_exception(SWIG_ValueError, e.what());
1097	>	PyErr_SetString ( SchedulerError, e.what() );
1098	>	return NULL;
1099		}catch (const std::exception& e) {
1100	<	SWIG_exception(SWIG_RuntimeError, e.what());
1100	>	PyErr_SetString ( BossError, e.what() );
1101	>	return NULL;
1102		}
1103		}
1104		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1147 | Line 1157 | static PyObject *_wrap_new_objectMap__SW
1157		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1158
1159		}catch (const BossSchedFailure & e) {
1160	<	SWIG_exception(SWIG_ValueError, e.what());
1160	>	PyErr_SetString ( SchedulerError, e.what() );
1161	>	return NULL;
1162		}catch (const std::exception& e) {
1163	<	SWIG_exception(SWIG_RuntimeError, e.what());
1163	>	PyErr_SetString ( BossError, e.what() );
1164	>	return NULL;
1165		}
1166		}
1167		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
#	Line 1264 | Line 1276 | static PyObject *_wrap_objectMap___len__
1276		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1277
1278		}catch (const BossSchedFailure & e) {
1279	<	SWIG_exception(SWIG_ValueError, e.what());
1279	>	PyErr_SetString ( SchedulerError, e.what() );
1280	>	return NULL;
1281		}catch (const std::exception& e) {
1282	<	SWIG_exception(SWIG_RuntimeError, e.what());
1282	>	PyErr_SetString ( BossError, e.what() );
1283	>	return NULL;
1284		}
1285		}
1286		resultobj = PyInt_FromLong((long)result);
#	Line 1288 | Line 1302 | static PyObject *_wrap_objectMap_clear(P
1302		(arg1)->clear();
1303
1304		}catch (const BossSchedFailure & e) {
1305	<	SWIG_exception(SWIG_ValueError, e.what());
1305	>	PyErr_SetString ( SchedulerError, e.what() );
1306	>	return NULL;
1307		}catch (const std::exception& e) {
1308	<	SWIG_exception(SWIG_RuntimeError, e.what());
1308	>	PyErr_SetString ( BossError, e.what() );
1309	>	return NULL;
1310		}
1311		}
1312		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1313 | Line 1329 | static PyObject *_wrap_objectMap___nonze
1329		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1330
1331		}catch (const BossSchedFailure & e) {
1332	<	SWIG_exception(SWIG_ValueError, e.what());
1332	>	PyErr_SetString ( SchedulerError, e.what() );
1333	>	return NULL;
1334		}catch (const std::exception& e) {
1335	<	SWIG_exception(SWIG_RuntimeError, e.what());
1335	>	PyErr_SetString ( BossError, e.what() );
1336	>	return NULL;
1337		}
1338		}
1339		resultobj = PyInt_FromLong((long)result);
#	Line 1387 | Line 1405 | static PyObject *_wrap_objectMap___setit
1405		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1406
1407		}catch (const BossSchedFailure & e) {
1408	<	SWIG_exception(SWIG_ValueError, e.what());
1408	>	PyErr_SetString ( SchedulerError, e.what() );
1409	>	return NULL;
1410		}catch (const std::exception& e) {
1411	<	SWIG_exception(SWIG_RuntimeError, e.what());
1411	>	PyErr_SetString ( BossError, e.what() );
1412	>	return NULL;
1413		}
1414		}
1415		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1451 | Line 1471 | static PyObject *_wrap_objectMap_has_key
1471		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1472
1473		}catch (const BossSchedFailure & e) {
1474	<	SWIG_exception(SWIG_ValueError, e.what());
1474	>	PyErr_SetString ( SchedulerError, e.what() );
1475	>	return NULL;
1476		}catch (const std::exception& e) {
1477	<	SWIG_exception(SWIG_RuntimeError, e.what());
1477	>	PyErr_SetString ( BossError, e.what() );
1478	>	return NULL;
1479		}
1480		}
1481		resultobj = PyInt_FromLong((long)result);
#	Line 1476 | Line 1498 | static PyObject *_wrap_objectMap_keys(Py
1498		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1499
1500		}catch (const BossSchedFailure & e) {
1501	<	SWIG_exception(SWIG_ValueError, e.what());
1501	>	PyErr_SetString ( SchedulerError, e.what() );
1502	>	return NULL;
1503		}catch (const std::exception& e) {
1504	<	SWIG_exception(SWIG_RuntimeError, e.what());
1504	>	PyErr_SetString ( BossError, e.what() );
1505	>	return NULL;
1506		}
1507		}
1508		resultobj = result;
#	Line 1501 | Line 1525 | static PyObject *_wrap_objectMap_values(
1525		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1526
1527		}catch (const BossSchedFailure & e) {
1528	<	SWIG_exception(SWIG_ValueError, e.what());
1528	>	PyErr_SetString ( SchedulerError, e.what() );
1529	>	return NULL;
1530		}catch (const std::exception& e) {
1531	<	SWIG_exception(SWIG_RuntimeError, e.what());
1531	>	PyErr_SetString ( BossError, e.what() );
1532	>	return NULL;
1533		}
1534		}
1535		resultobj = result;
#	Line 1526 | Line 1552 | static PyObject *_wrap_objectMap_items(P
1552		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1553
1554		}catch (const BossSchedFailure & e) {
1555	<	SWIG_exception(SWIG_ValueError, e.what());
1555	>	PyErr_SetString ( SchedulerError, e.what() );
1556	>	return NULL;
1557		}catch (const std::exception& e) {
1558	<	SWIG_exception(SWIG_RuntimeError, e.what());
1558	>	PyErr_SetString ( BossError, e.what() );
1559	>	return NULL;
1560		}
1561		}
1562		resultobj = result;
#	Line 1559 | Line 1587 | static PyObject *_wrap_objectMap___conta
1587		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1588
1589		}catch (const BossSchedFailure & e) {
1590	<	SWIG_exception(SWIG_ValueError, e.what());
1590	>	PyErr_SetString ( SchedulerError, e.what() );
1591	>	return NULL;
1592		}catch (const std::exception& e) {
1593	<	SWIG_exception(SWIG_RuntimeError, e.what());
1593	>	PyErr_SetString ( BossError, e.what() );
1594	>	return NULL;
1595		}
1596		}
1597		resultobj = PyInt_FromLong((long)result);
#	Line 1607 | Line 1637 | static PyObject *_wrap_delete_objectMap(
1637		delete arg1;
1638
1639		}catch (const BossSchedFailure & e) {
1640	<	SWIG_exception(SWIG_ValueError, e.what());
1640	>	PyErr_SetString ( SchedulerError, e.what() );
1641	>	return NULL;
1642		}catch (const std::exception& e) {
1643	<	SWIG_exception(SWIG_RuntimeError, e.what());
1643	>	PyErr_SetString ( BossError, e.what() );
1644	>	return NULL;
1645		}
1646		}
1647		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1642 | Line 1674 | static PyObject *_wrap_new_vector_string
1674		result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1675
1676		}catch (const BossSchedFailure & e) {
1677	<	SWIG_exception(SWIG_ValueError, e.what());
1677	>	PyErr_SetString ( SchedulerError, e.what() );
1678	>	return NULL;
1679		}catch (const std::exception& e) {
1680	<	SWIG_exception(SWIG_RuntimeError, e.what());
1680	>	PyErr_SetString ( BossError, e.what() );
1681	>	return NULL;
1682		}
1683		}
1684		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1679 | Line 1713 | static PyObject *_wrap_new_vector_string
1713		result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1714
1715		}catch (const BossSchedFailure & e) {
1716	<	SWIG_exception(SWIG_ValueError, e.what());
1716	>	PyErr_SetString ( SchedulerError, e.what() );
1717	>	return NULL;
1718		}catch (const std::exception& e) {
1719	<	SWIG_exception(SWIG_RuntimeError, e.what());
1719	>	PyErr_SetString ( BossError, e.what() );
1720	>	return NULL;
1721		}
1722		}
1723		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1733 | Line 1769 | static PyObject *_wrap_new_vector_string
1769		result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1770
1771		}catch (const BossSchedFailure & e) {
1772	<	SWIG_exception(SWIG_ValueError, e.what());
1772	>	PyErr_SetString ( SchedulerError, e.what() );
1773	>	return NULL;
1774		}catch (const std::exception& e) {
1775	<	SWIG_exception(SWIG_RuntimeError, e.what());
1775	>	PyErr_SetString ( BossError, e.what() );
1776	>	return NULL;
1777		}
1778		}
1779		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
#	Line 1862 | Line 1900 | static PyObject *_wrap_vector_string___l
1900		result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1901
1902		}catch (const BossSchedFailure & e) {
1903	<	SWIG_exception(SWIG_ValueError, e.what());
1903	>	PyErr_SetString ( SchedulerError, e.what() );
1904	>	return NULL;
1905		}catch (const std::exception& e) {
1906	<	SWIG_exception(SWIG_RuntimeError, e.what());
1906	>	PyErr_SetString ( BossError, e.what() );
1907	>	return NULL;
1908		}
1909		}
1910		resultobj = PyInt_FromLong((long)result);
#	Line 1916 | Line 1956 | static PyObject *_wrap_vector_string___n
1956		result = (bool)((std::vector<std::string > const *)arg1)->empty();
1957
1958		}catch (const BossSchedFailure & e) {
1959	<	SWIG_exception(SWIG_ValueError, e.what());
1959	>	PyErr_SetString ( SchedulerError, e.what() );
1960	>	return NULL;
1961		}catch (const std::exception& e) {
1962	<	SWIG_exception(SWIG_RuntimeError, e.what());
1962	>	PyErr_SetString ( BossError, e.what() );
1963	>	return NULL;
1964		}
1965		}
1966		resultobj = PyInt_FromLong((long)result);
#	Line 1940 | Line 1982 | static PyObject *_wrap_vector_string_cle
1982		(arg1)->clear();
1983
1984		}catch (const BossSchedFailure & e) {
1985	<	SWIG_exception(SWIG_ValueError, e.what());
1985	>	PyErr_SetString ( SchedulerError, e.what() );
1986	>	return NULL;
1987		}catch (const std::exception& e) {
1988	<	SWIG_exception(SWIG_RuntimeError, e.what());
1988	>	PyErr_SetString ( BossError, e.what() );
1989	>	return NULL;
1990		}
1991		}
1992		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 1972 | Line 2016 | static PyObject *_wrap_vector_string_app
2016		(arg1)->push_back(arg2);
2017
2018		}catch (const BossSchedFailure & e) {
2019	<	SWIG_exception(SWIG_ValueError, e.what());
2019	>	PyErr_SetString ( SchedulerError, e.what() );
2020	>	return NULL;
2021		}catch (const std::exception& e) {
2022	<	SWIG_exception(SWIG_RuntimeError, e.what());
2022	>	PyErr_SetString ( BossError, e.what() );
2023	>	return NULL;
2024		}
2025		}
2026		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2050 | Line 2096 | static PyObject *_wrap_vector_string___g
2096		result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2097
2098		}catch (const BossSchedFailure & e) {
2099	<	SWIG_exception(SWIG_ValueError, e.what());
2099	>	PyErr_SetString ( SchedulerError, e.what() );
2100	>	return NULL;
2101		}catch (const std::exception& e) {
2102	<	SWIG_exception(SWIG_RuntimeError, e.what());
2102	>	PyErr_SetString ( BossError, e.what() );
2103	>	return NULL;
2104		}
2105		}
2106		{
#	Line 2144 | Line 2192 | static PyObject *_wrap_vector_string___s
2192		std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2193
2194		}catch (const BossSchedFailure & e) {
2195	<	SWIG_exception(SWIG_ValueError, e.what());
2195	>	PyErr_SetString ( SchedulerError, e.what() );
2196	>	return NULL;
2197		}catch (const std::exception& e) {
2198	<	SWIG_exception(SWIG_RuntimeError, e.what());
2198	>	PyErr_SetString ( BossError, e.what() );
2199	>	return NULL;
2200		}
2201		}
2202		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2193 | Line 2243 | static PyObject *_wrap_vector_string___d
2243		std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2244
2245		}catch (const BossSchedFailure & e) {
2246	<	SWIG_exception(SWIG_ValueError, e.what());
2246	>	PyErr_SetString ( SchedulerError, e.what() );
2247	>	return NULL;
2248		}catch (const std::exception& e) {
2249	<	SWIG_exception(SWIG_RuntimeError, e.what());
2249	>	PyErr_SetString ( BossError, e.what() );
2250	>	return NULL;
2251		}
2252		}
2253		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2217 | Line 2269 | static PyObject *_wrap_delete_vector_str
2269		delete arg1;
2270
2271		}catch (const BossSchedFailure & e) {
2272	<	SWIG_exception(SWIG_ValueError, e.what());
2272	>	PyErr_SetString ( SchedulerError, e.what() );
2273	>	return NULL;
2274		}catch (const std::exception& e) {
2275	<	SWIG_exception(SWIG_RuntimeError, e.what());
2275	>	PyErr_SetString ( BossError, e.what() );
2276	>	return NULL;
2277		}
2278		}
2279		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2236 | Line 2290 | static PyObject * vector_string_swigregi
2290		Py_INCREF(obj);
2291		return Py_BuildValue((char *)"");
2292		}
2293	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
2293	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2294		PyObject *resultobj;
2295	<	BossSession *arg1 = (BossSession *) 0 ;
2296	<	std::vector<std::string > *arg2 = 0 ;
2297	<	PyObject *result;
2295	>	std::string arg1 = (std::string) "" ;
2296	>	std::string arg2 = (std::string) "2" ;
2297	>	std::string arg3 = (std::string) "" ;
2298	>	std::string arg4 = (std::string) "" ;
2299	>	BossSession *result;
2300		PyObject * obj0 = 0 ;
2301		PyObject * obj1 = 0 ;
2302	+	PyObject * obj2 = 0 ;
2303	+	PyObject * obj3 = 0 ;
2304
2305	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2306	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2307	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2308	<	if (arg2 == NULL) {
2309	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2305	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2306	>	if (obj0) {
2307	>	{
2308	>	if (PyString_Check(obj0))
2309	>	arg1 = std::string(PyString_AsString(obj0));
2310	>	else
2311	>	SWIG_exception(SWIG_TypeError, "string expected");
2312	>	}
2313		}
2314	<	{
2315	<	try {
2316	<	result = (PyObject *)BossSession_show(arg1,*arg2);
2317	<
2318	<	}catch (const BossSchedFailure & e) {
2319	<	SWIG_exception(SWIG_ValueError, e.what());
2320	<	}catch (const std::exception& e) {
2321	<	SWIG_exception(SWIG_RuntimeError, e.what());
2314	>	if (obj1) {
2315	>	{
2316	>	if (PyString_Check(obj1))
2317	>	arg2 = std::string(PyString_AsString(obj1));
2318	>	else
2319	>	SWIG_exception(SWIG_TypeError, "string expected");
2320	>	}
2321	>	}
2322	>	if (obj2) {
2323	>	{
2324	>	if (PyString_Check(obj2))
2325	>	arg3 = std::string(PyString_AsString(obj2));
2326	>	else
2327	>	SWIG_exception(SWIG_TypeError, "string expected");
2328	>	}
2329	>	}
2330	>	if (obj3) {
2331	>	{
2332	>	if (PyString_Check(obj3))
2333	>	arg4 = std::string(PyString_AsString(obj3));
2334	>	else
2335	>	SWIG_exception(SWIG_TypeError, "string expected");
2336		}
2337		}
2263	–	resultobj = result;
2264	–	return resultobj;
2265	–	fail:
2266	–	return NULL;
2267	–	}
2268	–
2269	–
2270	–	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
2271	–	PyObject *resultobj;
2272	–	BossSession *arg1 = (BossSession *) 0 ;
2273	–	PyObject *result;
2274	–	PyObject * obj0 = 0 ;
2275	–
2276	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2277	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2338		{
2339		try {
2340	<	result = (PyObject *)BossSession_CHTools(arg1);
2340	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2341
2342		}catch (const BossSchedFailure & e) {
2343	<	SWIG_exception(SWIG_ValueError, e.what());
2343	>	PyErr_SetString ( SchedulerError, e.what() );
2344	>	return NULL;
2345		}catch (const std::exception& e) {
2346	<	SWIG_exception(SWIG_RuntimeError, e.what());
2346	>	PyErr_SetString ( BossError, e.what() );
2347	>	return NULL;
2348		}
2349		}
2350	<	resultobj = result;
2350	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2351		return resultobj;
2352		fail:
2353		return NULL;
2354		}
2355
2356
2357	<	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
2357	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2358		PyObject *resultobj;
2359		BossSession *arg1 = (BossSession *) 0 ;
2298	–	PyObject *result;
2360		PyObject * obj0 = 0 ;
2361
2362	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2362	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2363		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2364		{
2365		try {
2366	<	result = (PyObject *)BossSession_ProgramTypes(arg1);
2366	>	delete arg1;
2367
2368		}catch (const BossSchedFailure & e) {
2369	<	SWIG_exception(SWIG_ValueError, e.what());
2369	>	PyErr_SetString ( SchedulerError, e.what() );
2370	>	return NULL;
2371		}catch (const std::exception& e) {
2372	<	SWIG_exception(SWIG_RuntimeError, e.what());
2372	>	PyErr_SetString ( BossError, e.what() );
2373	>	return NULL;
2374		}
2375		}
2376	<	resultobj = result;
2376	>	Py_INCREF(Py_None); resultobj = Py_None;
2377		return resultobj;
2378		fail:
2379		return NULL;
2380		}
2381
2382
2383	<	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
2383	>	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2384		PyObject *resultobj;
2385		BossSession *arg1 = (BossSession *) 0 ;
2323	–	PyObject *result;
2386		PyObject * obj0 = 0 ;
2387
2388	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2388	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2389		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2390		{
2391		try {
2392	<	result = (PyObject *)BossSession_RTMons(arg1);
2392	>	(arg1)->resetDB();
2393
2394		}catch (const BossSchedFailure & e) {
2395	<	SWIG_exception(SWIG_ValueError, e.what());
2395	>	PyErr_SetString ( SchedulerError, e.what() );
2396	>	return NULL;
2397		}catch (const std::exception& e) {
2398	<	SWIG_exception(SWIG_RuntimeError, e.what());
2398	>	PyErr_SetString ( BossError, e.what() );
2399	>	return NULL;
2400		}
2401		}
2402	<	resultobj = result;
2402	>	Py_INCREF(Py_None); resultobj = Py_None;
2403		return resultobj;
2404		fail:
2405		return NULL;
2406		}
2407
2408
2409	<	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
2409	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2410		PyObject *resultobj;
2411		BossSession *arg1 = (BossSession *) 0 ;
2348	–	PyObject *result;
2412		PyObject * obj0 = 0 ;
2413
2414	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2414	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2415		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2416		{
2417		try {
2418	<	result = (PyObject *)BossSession_schedulers(arg1);
2418	>	(arg1)->clear();
2419
2420		}catch (const BossSchedFailure & e) {
2421	<	SWIG_exception(SWIG_ValueError, e.what());
2421	>	PyErr_SetString ( SchedulerError, e.what() );
2422	>	return NULL;
2423		}catch (const std::exception& e) {
2424	<	SWIG_exception(SWIG_RuntimeError, e.what());
2424	>	PyErr_SetString ( BossError, e.what() );
2425	>	return NULL;
2426		}
2427		}
2428	<	resultobj = result;
2428	>	Py_INCREF(Py_None); resultobj = Py_None;
2429		return resultobj;
2430		fail:
2431		return NULL;
2432		}
2433
2434
2435	<	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
2435	>	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2436		PyObject *resultobj;
2437		BossSession *arg1 = (BossSession *) 0 ;
2438	<	std::string *arg2 = 0 ;
2439	<	std::string *arg3 = 0 ;
2440	<	std::string const &arg4_defvalue = "" ;
2376	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
2377	<	std::string const &arg5_defvalue = "" ;
2378	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2379	<	bool arg6 = (bool) false ;
2380	<	PyObject *result;
2438	>	std::string const &arg2_defvalue = "" ;
2439	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
2440	>	BossTask *result;
2441		std::string temp2 ;
2382	–	std::string temp3 ;
2383	–	std::string temp4 ;
2384	–	std::string temp5 ;
2442		PyObject * obj0 = 0 ;
2443		PyObject * obj1 = 0 ;
2387	–	PyObject * obj2 = 0 ;
2388	–	PyObject * obj3 = 0 ;
2389	–	PyObject * obj4 = 0 ;
2390	–	PyObject * obj5 = 0 ;
2444
2445	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2445	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2446		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2447	<	{
2395	<	if (PyString_Check(obj1)) {
2396	<	temp2 = std::string(PyString_AsString(obj1));
2397	<	arg2 = &temp2;
2398	<	}else {
2399	<	SWIG_exception(SWIG_TypeError, "string expected");
2400	<	}
2401	<	}
2402	<	{
2403	<	if (PyString_Check(obj2)) {
2404	<	temp3 = std::string(PyString_AsString(obj2));
2405	<	arg3 = &temp3;
2406	<	}else {
2407	<	SWIG_exception(SWIG_TypeError, "string expected");
2408	<	}
2409	<	}
2410	<	if (obj3) {
2411	<	{
2412	<	if (PyString_Check(obj3)) {
2413	<	temp4 = std::string(PyString_AsString(obj3));
2414	<	arg4 = &temp4;
2415	<	}else {
2416	<	SWIG_exception(SWIG_TypeError, "string expected");
2417	<	}
2418	<	}
2419	<	}
2420	<	if (obj4) {
2447	>	if (obj1) {
2448		{
2449	<	if (PyString_Check(obj4)) {
2450	<	temp5 = std::string(PyString_AsString(obj4));
2451	<	arg5 = &temp5;
2449	>	if (PyString_Check(obj1)) {
2450	>	temp2 = std::string(PyString_AsString(obj1));
2451	>	arg2 = &temp2;
2452		}else {
2453		SWIG_exception(SWIG_TypeError, "string expected");
2454		}
2455		}
2456		}
2430	–	if (obj5) {
2431	–	arg6 = PyInt_AsLong(obj5) ? true : false;
2432	–	if (PyErr_Occurred()) SWIG_fail;
2433	–	}
2457		{
2458		try {
2459	<	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
2459	>	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2460
2461		}catch (const BossSchedFailure & e) {
2462	<	SWIG_exception(SWIG_ValueError, e.what());
2462	>	PyErr_SetString ( SchedulerError, e.what() );
2463	>	return NULL;
2464		}catch (const std::exception& e) {
2465	<	SWIG_exception(SWIG_RuntimeError, e.what());
2465	>	PyErr_SetString ( BossError, e.what() );
2466	>	return NULL;
2467		}
2468		}
2469	<	resultobj = result;
2469	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2470		return resultobj;
2471		fail:
2472		return NULL;
2473		}
2474
2475
2476	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2476	>	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2477		PyObject *resultobj;
2478		BossSession *arg1 = (BossSession *) 0 ;
2479	<	int arg2 = (int) SCHEDULED ;
2455	<	std::string const &arg3_defvalue = "all" ;
2456	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
2457	<	std::string const &arg4_defvalue = "all" ;
2458	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
2459	<	std::string const &arg5_defvalue = "" ;
2460	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2461	<	std::string arg6 = (std::string) "" ;
2462	<	std::string arg7 = (std::string) "" ;
2463	<	std::string arg8 = (std::string) "" ;
2464	<	std::string arg9 = (std::string) "" ;
2465	<	bool arg10 = (bool) false ;
2466	<	PyObject *result;
2467	<	std::string temp3 ;
2468	<	std::string temp4 ;
2469	<	std::string temp5 ;
2470	<	PyObject * obj0 = 0 ;
2471	<	PyObject * obj2 = 0 ;
2472	<	PyObject * obj3 = 0 ;
2473	<	PyObject * obj4 = 0 ;
2474	<	PyObject * obj5 = 0 ;
2475	<	PyObject * obj6 = 0 ;
2476	<	PyObject * obj7 = 0 ;
2477	<	PyObject * obj8 = 0 ;
2478	<	PyObject * obj9 = 0 ;
2479	<
2480	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2481	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2482	<	if (obj2) {
2483	<	{
2484	<	if (PyString_Check(obj2)) {
2485	<	temp3 = std::string(PyString_AsString(obj2));
2486	<	arg3 = &temp3;
2487	<	}else {
2488	<	SWIG_exception(SWIG_TypeError, "string expected");
2489	<	}
2490	<	}
2491	<	}
2492	<	if (obj3) {
2493	<	{
2494	<	if (PyString_Check(obj3)) {
2495	<	temp4 = std::string(PyString_AsString(obj3));
2496	<	arg4 = &temp4;
2497	<	}else {
2498	<	SWIG_exception(SWIG_TypeError, "string expected");
2499	<	}
2500	<	}
2501	<	}
2502	<	if (obj4) {
2503	<	{
2504	<	if (PyString_Check(obj4)) {
2505	<	temp5 = std::string(PyString_AsString(obj4));
2506	<	arg5 = &temp5;
2507	<	}else {
2508	<	SWIG_exception(SWIG_TypeError, "string expected");
2509	<	}
2510	<	}
2511	<	}
2512	<	if (obj5) {
2513	<	{
2514	<	if (PyString_Check(obj5))
2515	<	arg6 = std::string(PyString_AsString(obj5));
2516	<	else
2517	<	SWIG_exception(SWIG_TypeError, "string expected");
2518	<	}
2519	<	}
2520	<	if (obj6) {
2521	<	{
2522	<	if (PyString_Check(obj6))
2523	<	arg7 = std::string(PyString_AsString(obj6));
2524	<	else
2525	<	SWIG_exception(SWIG_TypeError, "string expected");
2526	<	}
2527	<	}
2528	<	if (obj7) {
2529	<	{
2530	<	if (PyString_Check(obj7))
2531	<	arg8 = std::string(PyString_AsString(obj7));
2532	<	else
2533	<	SWIG_exception(SWIG_TypeError, "string expected");
2534	<	}
2535	<	}
2536	<	if (obj8) {
2537	<	{
2538	<	if (PyString_Check(obj8))
2539	<	arg9 = std::string(PyString_AsString(obj8));
2540	<	else
2541	<	SWIG_exception(SWIG_TypeError, "string expected");
2542	<	}
2543	<	}
2544	<	if (obj9) {
2545	<	arg10 = PyInt_AsLong(obj9) ? true : false;
2546	<	if (PyErr_Occurred()) SWIG_fail;
2547	<	}
2548	<	{
2549	<	try {
2550	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2551	<
2552	<	}catch (const BossSchedFailure & e) {
2553	<	SWIG_exception(SWIG_ValueError, e.what());
2554	<	}catch (const std::exception& e) {
2555	<	SWIG_exception(SWIG_RuntimeError, e.what());
2556	<	}
2557	<	}
2558	<	resultobj = result;
2559	<	return resultobj;
2560	<	fail:
2561	<	return NULL;
2562	<	}
2563	<
2564	<
2565	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2566	<	PyObject *resultobj;
2567	<	std::string arg1 = (std::string) "" ;
2568	<	std::string arg2 = (std::string) "2" ;
2569	<	std::string arg3 = (std::string) "" ;
2570	<	std::string arg4 = (std::string) "" ;
2571	<	BossSession *result;
2479	>	BossTask *arg2 = (BossTask *) 0 ;
2480		PyObject * obj0 = 0 ;
2481		PyObject * obj1 = 0 ;
2574	–	PyObject * obj2 = 0 ;
2575	–	PyObject * obj3 = 0 ;
2576	–
2577	–	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2578	–	if (obj0) {
2579	–	{
2580	–	if (PyString_Check(obj0))
2581	–	arg1 = std::string(PyString_AsString(obj0));
2582	–	else
2583	–	SWIG_exception(SWIG_TypeError, "string expected");
2584	–	}
2585	–	}
2586	–	if (obj1) {
2587	–	{
2588	–	if (PyString_Check(obj1))
2589	–	arg2 = std::string(PyString_AsString(obj1));
2590	–	else
2591	–	SWIG_exception(SWIG_TypeError, "string expected");
2592	–	}
2593	–	}
2594	–	if (obj2) {
2595	–	{
2596	–	if (PyString_Check(obj2))
2597	–	arg3 = std::string(PyString_AsString(obj2));
2598	–	else
2599	–	SWIG_exception(SWIG_TypeError, "string expected");
2600	–	}
2601	–	}
2602	–	if (obj3) {
2603	–	{
2604	–	if (PyString_Check(obj3))
2605	–	arg4 = std::string(PyString_AsString(obj3));
2606	–	else
2607	–	SWIG_exception(SWIG_TypeError, "string expected");
2608	–	}
2609	–	}
2610	–	{
2611	–	try {
2612	–	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2613	–
2614	–	}catch (const BossSchedFailure & e) {
2615	–	SWIG_exception(SWIG_ValueError, e.what());
2616	–	}catch (const std::exception& e) {
2617	–	SWIG_exception(SWIG_RuntimeError, e.what());
2618	–	}
2619	–	}
2620	–	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2621	–	return resultobj;
2622	–	fail:
2623	–	return NULL;
2624	–	}
2625	–
2626	–
2627	–	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2628	–	PyObject *resultobj;
2629	–	BossSession *arg1 = (BossSession *) 0 ;
2630	–	PyObject * obj0 = 0 ;
2482
2483	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2483	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2484		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2485	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2486		{
2487		try {
2488	<	delete arg1;
2488	>	(arg1)->destroyBossTask(arg2);
2489
2490		}catch (const BossSchedFailure & e) {
2491	<	SWIG_exception(SWIG_ValueError, e.what());
2491	>	PyErr_SetString ( SchedulerError, e.what() );
2492	>	return NULL;
2493		}catch (const std::exception& e) {
2494	<	SWIG_exception(SWIG_RuntimeError, e.what());
2494	>	PyErr_SetString ( BossError, e.what() );
2495	>	return NULL;
2496		}
2497		}
2498		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 2648 | Line 2502 | static PyObject *_wrap_delete_BossSessio
2502		}
2503
2504
2505	<	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2505	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2506		PyObject *resultobj;
2507		BossSession *arg1 = (BossSession *) 0 ;
2508	+	std::vector<std::string > result;
2509		PyObject * obj0 = 0 ;
2510
2511	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2511	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2512		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2513		{
2514		try {
2515	<	(arg1)->resetDB();
2515	>	result = (arg1)->showCHTools();
2516
2517		}catch (const BossSchedFailure & e) {
2518	<	SWIG_exception(SWIG_ValueError, e.what());
2518	>	PyErr_SetString ( SchedulerError, e.what() );
2519	>	return NULL;
2520		}catch (const std::exception& e) {
2521	<	SWIG_exception(SWIG_RuntimeError, e.what());
2521	>	PyErr_SetString ( BossError, e.what() );
2522	>	return NULL;
2523		}
2524		}
2525	<	Py_INCREF(Py_None); resultobj = Py_None;
2525	>	{
2526	>	resultobj = PyTuple_New((&result)->size());
2527	>	for (unsigned int i=0; i<(&result)->size(); i++)
2528	>	PyTuple_SetItem(resultobj,i,
2529	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2530	>	}
2531		return resultobj;
2532		fail:
2533		return NULL;
2534		}
2535
2536
2537	<	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2537	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2538		PyObject *resultobj;
2539		BossSession *arg1 = (BossSession *) 0 ;
2540	+	std::vector<std::string > result;
2541		PyObject * obj0 = 0 ;
2542
2543	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2543	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2544		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2545		{
2546		try {
2547	<	(arg1)->clear();
2547	>	result = (arg1)->showProgramTypes();
2548
2549		}catch (const BossSchedFailure & e) {
2550	<	SWIG_exception(SWIG_ValueError, e.what());
2550	>	PyErr_SetString ( SchedulerError, e.what() );
2551	>	return NULL;
2552		}catch (const std::exception& e) {
2553	<	SWIG_exception(SWIG_RuntimeError, e.what());
2553	>	PyErr_SetString ( BossError, e.what() );
2554	>	return NULL;
2555		}
2556		}
2557	<	Py_INCREF(Py_None); resultobj = Py_None;
2557	>	{
2558	>	resultobj = PyTuple_New((&result)->size());
2559	>	for (unsigned int i=0; i<(&result)->size(); i++)
2560	>	PyTuple_SetItem(resultobj,i,
2561	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2562	>	}
2563		return resultobj;
2564		fail:
2565		return NULL;
2566		}
2567
2568
2569	<	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2569	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2570		PyObject *resultobj;
2571		BossSession *arg1 = (BossSession *) 0 ;
2572	<	std::string const &arg2_defvalue = "" ;
2703	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2704	<	BossTask *result;
2705	<	std::string temp2 ;
2572	>	std::vector<std::string > result;
2573		PyObject * obj0 = 0 ;
2707	–	PyObject * obj1 = 0 ;
2574
2575	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2575	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2576		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2711	–	if (obj1) {
2712	–	{
2713	–	if (PyString_Check(obj1)) {
2714	–	temp2 = std::string(PyString_AsString(obj1));
2715	–	arg2 = &temp2;
2716	–	}else {
2717	–	SWIG_exception(SWIG_TypeError, "string expected");
2718	–	}
2719	–	}
2720	–	}
2577		{
2578		try {
2579	<	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2579	>	result = (arg1)->showRTMon();
2580
2581		}catch (const BossSchedFailure & e) {
2582	<	SWIG_exception(SWIG_ValueError, e.what());
2582	>	PyErr_SetString ( SchedulerError, e.what() );
2583	>	return NULL;
2584		}catch (const std::exception& e) {
2585	<	SWIG_exception(SWIG_RuntimeError, e.what());
2585	>	PyErr_SetString ( BossError, e.what() );
2586	>	return NULL;
2587		}
2588		}
2589	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2589	>	{
2590	>	resultobj = PyTuple_New((&result)->size());
2591	>	for (unsigned int i=0; i<(&result)->size(); i++)
2592	>	PyTuple_SetItem(resultobj,i,
2593	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2594	>	}
2595		return resultobj;
2596		fail:
2597		return NULL;
2598		}
2599
2600
2601	<	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2601	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2602		PyObject *resultobj;
2603		BossSession *arg1 = (BossSession *) 0 ;
2604	<	BossTask *arg2 = (BossTask *) 0 ;
2604	>	std::vector<std::string > result;
2605		PyObject * obj0 = 0 ;
2743	–	PyObject * obj1 = 0 ;
2606
2607	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2607	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2608		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2747	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2609		{
2610		try {
2611	<	(arg1)->destroyBossTask(arg2);
2611	>	result = (arg1)->showSchedulers();
2612
2613		}catch (const BossSchedFailure & e) {
2614	<	SWIG_exception(SWIG_ValueError, e.what());
2614	>	PyErr_SetString ( SchedulerError, e.what() );
2615	>	return NULL;
2616		}catch (const std::exception& e) {
2617	<	SWIG_exception(SWIG_RuntimeError, e.what());
2617	>	PyErr_SetString ( BossError, e.what() );
2618	>	return NULL;
2619		}
2620		}
2621	<	Py_INCREF(Py_None); resultobj = Py_None;
2621	>	{
2622	>	resultobj = PyTuple_New((&result)->size());
2623	>	for (unsigned int i=0; i<(&result)->size(); i++)
2624	>	PyTuple_SetItem(resultobj,i,
2625	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2626	>	}
2627		return resultobj;
2628		fail:
2629		return NULL;
#	Line 2775 | Line 2643 | static PyObject *_wrap_BossSession_defau
2643		result = (arg1)->defaultCHTool();
2644
2645		}catch (const BossSchedFailure & e) {
2646	<	SWIG_exception(SWIG_ValueError, e.what());
2646	>	PyErr_SetString ( SchedulerError, e.what() );
2647	>	return NULL;
2648		}catch (const std::exception& e) {
2649	<	SWIG_exception(SWIG_RuntimeError, e.what());
2649	>	PyErr_SetString ( BossError, e.what() );
2650	>	return NULL;
2651		}
2652		}
2653		{
#	Line 2802 | Line 2672 | static PyObject *_wrap_BossSession_defau
2672		result = (arg1)->defaultProgramType();
2673
2674		}catch (const BossSchedFailure & e) {
2675	<	SWIG_exception(SWIG_ValueError, e.what());
2675	>	PyErr_SetString ( SchedulerError, e.what() );
2676	>	return NULL;
2677		}catch (const std::exception& e) {
2678	<	SWIG_exception(SWIG_RuntimeError, e.what());
2678	>	PyErr_SetString ( BossError, e.what() );
2679	>	return NULL;
2680		}
2681		}
2682		{
#	Line 2829 | Line 2701 | static PyObject *_wrap_BossSession_defau
2701		result = (arg1)->defaultRTMon();
2702
2703		}catch (const BossSchedFailure & e) {
2704	<	SWIG_exception(SWIG_ValueError, e.what());
2704	>	PyErr_SetString ( SchedulerError, e.what() );
2705	>	return NULL;
2706		}catch (const std::exception& e) {
2707	<	SWIG_exception(SWIG_RuntimeError, e.what());
2707	>	PyErr_SetString ( BossError, e.what() );
2708	>	return NULL;
2709		}
2710		}
2711		{
#	Line 2856 | Line 2730 | static PyObject *_wrap_BossSession_defau
2730		result = (arg1)->defaultScheduler();
2731
2732		}catch (const BossSchedFailure & e) {
2733	<	SWIG_exception(SWIG_ValueError, e.what());
2733	>	PyErr_SetString ( SchedulerError, e.what() );
2734	>	return NULL;
2735		}catch (const std::exception& e) {
2736	<	SWIG_exception(SWIG_RuntimeError, e.what());
2736	>	PyErr_SetString ( BossError, e.what() );
2737	>	return NULL;
2738		}
2739		}
2740		{
#	Line 2883 | Line 2759 | static PyObject *_wrap_BossSession_versi
2759		result = (arg1)->version();
2760
2761		}catch (const BossSchedFailure & e) {
2762	<	SWIG_exception(SWIG_ValueError, e.what());
2762	>	PyErr_SetString ( SchedulerError, e.what() );
2763	>	return NULL;
2764		}catch (const std::exception& e) {
2765	<	SWIG_exception(SWIG_RuntimeError, e.what());
2765	>	PyErr_SetString ( BossError, e.what() );
2766	>	return NULL;
2767		}
2768		}
2769		{
#	Line 2910 | Line 2788 | static PyObject *_wrap_BossSession_clien
2788		result = (arg1)->clientID();
2789
2790		}catch (const BossSchedFailure & e) {
2791	<	SWIG_exception(SWIG_ValueError, e.what());
2791	>	PyErr_SetString ( SchedulerError, e.what() );
2792	>	return NULL;
2793		}catch (const std::exception& e) {
2794	<	SWIG_exception(SWIG_RuntimeError, e.what());
2794	>	PyErr_SetString ( BossError, e.what() );
2795	>	return NULL;
2796		}
2797		}
2798		{
#	Line 2943 | Line 2823 | static PyObject *_wrap_BossSession_showC
2823		result = (int)(arg1)->showConfigs(arg2);
2824
2825		}catch (const BossSchedFailure & e) {
2826	<	SWIG_exception(SWIG_ValueError, e.what());
2826	>	PyErr_SetString ( SchedulerError, e.what() );
2827	>	return NULL;
2828		}catch (const std::exception& e) {
2829	<	SWIG_exception(SWIG_RuntimeError, e.what());
2829	>	PyErr_SetString ( BossError, e.what() );
2830	>	return NULL;
2831		}
2832		}
2833		resultobj = PyInt_FromLong((long)result);
#	Line 2998 | Line 2880 | static PyObject *_wrap_BossSession_RTupd
2880		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2881
2882		}catch (const BossSchedFailure & e) {
2883	<	SWIG_exception(SWIG_ValueError, e.what());
2883	>	PyErr_SetString ( SchedulerError, e.what() );
2884	>	return NULL;
2885		}catch (const std::exception& e) {
2886	<	SWIG_exception(SWIG_RuntimeError, e.what());
2886	>	PyErr_SetString ( BossError, e.what() );
2887	>	return NULL;
2888		}
2889		}
2890		resultobj = PyInt_FromLong((long)result);
#	Line 3020 | Line 2904 | static PyObject *_wrap_BossSession_listM
2904		std::string *arg5 = (std::string *) &arg5_defvalue ;
2905		std::string const &arg6_defvalue = "" ;
2906		std::string *arg6 = (std::string *) &arg6_defvalue ;
2907	+	unsigned int arg7 = (unsigned int) 0 ;
2908		std::vector<std::string > result;
2909		std::string temp2 ;
2910		std::string temp3 ;
#	Line 3031 | Line 2916 | static PyObject *_wrap_BossSession_listM
2916		PyObject * obj3 = 0 ;
2917		PyObject * obj4 = 0 ;
2918		PyObject * obj5 = 0 ;
2919	+	PyObject * obj6 = 0 ;
2920
2921	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2921	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2922		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2923		{
2924		if (PyString_Check(obj1)) {
#	Line 3074 | Line 2960 | static PyObject *_wrap_BossSession_listM
2960		}
2961		}
2962		}
2963	+	if (obj6) {
2964	+	arg7 = (unsigned int) PyInt_AsLong(obj6);
2965	+	if (PyErr_Occurred()) SWIG_fail;
2966	+	}
2967		{
2968		try {
2969	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2969	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
2970
2971		}catch (const BossSchedFailure & e) {
2972	<	SWIG_exception(SWIG_ValueError, e.what());
2972	>	PyErr_SetString ( SchedulerError, e.what() );
2973	>	return NULL;
2974		}catch (const std::exception& e) {
2975	<	SWIG_exception(SWIG_RuntimeError, e.what());
2975	>	PyErr_SetString ( BossError, e.what() );
2976	>	return NULL;
2977		}
2978		}
2979		{
#	Line 3110 | Line 3002 | static PyObject *_wrap_BossSession_sched
3002		std::string arg7 = (std::string) "" ;
3003		std::string arg8 = (std::string) "" ;
3004		std::string arg9 = (std::string) "" ;
3005	+	unsigned int arg10 = (unsigned int) 0 ;
3006		std::string temp3 ;
3007		std::string temp4 ;
3008		std::string temp5 ;
#	Line 3121 | Line 3014 | static PyObject *_wrap_BossSession_sched
3014		PyObject * obj6 = 0 ;
3015		PyObject * obj7 = 0 ;
3016		PyObject * obj8 = 0 ;
3017	+	PyObject * obj9 = 0 ;
3018
3019	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3019	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3020		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3021		if (obj2) {
3022		{
#	Line 3186 | Line 3080 | static PyObject *_wrap_BossSession_sched
3080		SWIG_exception(SWIG_TypeError, "string expected");
3081		}
3082		}
3083	+	if (obj9) {
3084	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3085	+	if (PyErr_Occurred()) SWIG_fail;
3086	+	}
3087		{
3088		try {
3089	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3089	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3090
3091		}catch (const BossSchedFailure & e) {
3092	<	SWIG_exception(SWIG_ValueError, e.what());
3092	>	PyErr_SetString ( SchedulerError, e.what() );
3093	>	return NULL;
3094		}catch (const std::exception& e) {
3095	<	SWIG_exception(SWIG_RuntimeError, e.what());
3095	>	PyErr_SetString ( BossError, e.what() );
3096	>	return NULL;
3097		}
3098		}
3099		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3272 | Line 3172 | static PyObject *_wrap_BossSession_selec
3172		result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3173
3174		}catch (const BossSchedFailure & e) {
3175	<	SWIG_exception(SWIG_ValueError, e.what());
3175	>	PyErr_SetString ( SchedulerError, e.what() );
3176	>	return NULL;
3177	>	}catch (const std::exception& e) {
3178	>	PyErr_SetString ( BossError, e.what() );
3179	>	return NULL;
3180	>	}
3181	>	}
3182	>	{
3183	>	resultobj = PyTuple_New((&result)->size());
3184	>	for (unsigned int i=0; i<(&result)->size(); i++)
3185	>	PyTuple_SetItem(resultobj,i,
3186	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3187	>	}
3188	>	return resultobj;
3189	>	fail:
3190	>	return NULL;
3191	>	}
3192	>
3193	>
3194	>	static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
3195	>	PyObject *resultobj;
3196	>	BossSession *arg1 = (BossSession *) 0 ;
3197	>	std::string *arg2 = 0 ;
3198	>	std::vector<std::string > result;
3199	>	std::string temp2 ;
3200	>	PyObject * obj0 = 0 ;
3201	>	PyObject * obj1 = 0 ;
3202	>
3203	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3204	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3205	>	{
3206	>	if (PyString_Check(obj1)) {
3207	>	temp2 = std::string(PyString_AsString(obj1));
3208	>	arg2 = &temp2;
3209	>	}else {
3210	>	SWIG_exception(SWIG_TypeError, "string expected");
3211	>	}
3212	>	}
3213	>	{
3214	>	try {
3215	>	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3216	>
3217	>	}catch (const BossSchedFailure & e) {
3218	>	PyErr_SetString ( SchedulerError, e.what() );
3219	>	return NULL;
3220		}catch (const std::exception& e) {
3221	<	SWIG_exception(SWIG_RuntimeError, e.what());
3221	>	PyErr_SetString ( BossError, e.what() );
3222	>	return NULL;
3223		}
3224		}
3225		{
#	Line 3303 | Line 3248 | static PyObject *_wrap_BossSession_query
3248		std::string arg7 = (std::string) "" ;
3249		std::string arg8 = (std::string) "" ;
3250		std::string arg9 = (std::string) "" ;
3251	<	bool arg10 = (bool) false ;
3251	>	unsigned int arg10 = (unsigned int) 0 ;
3252	>	bool arg11 = (bool) false ;
3253		SwigValueWrapper< std::vector<BossTask * > > result;
3254		std::string temp3 ;
3255		std::string temp4 ;
#	Line 3317 | Line 3263 | static PyObject *_wrap_BossSession_query
3263		PyObject * obj7 = 0 ;
3264		PyObject * obj8 = 0 ;
3265		PyObject * obj9 = 0 ;
3266	+	PyObject * obj10 = 0 ;
3267
3268	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3268	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3269		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3270		if (obj2) {
3271		{
#	Line 3383 | Line 3330 | static PyObject *_wrap_BossSession_query
3330		}
3331		}
3332		if (obj9) {
3333	<	arg10 = PyInt_AsLong(obj9) ? true : false;
3333	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3334	>	if (PyErr_Occurred()) SWIG_fail;
3335	>	}
3336	>	if (obj10) {
3337	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3338		if (PyErr_Occurred()) SWIG_fail;
3339		}
3340		{
3341		try {
3342	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3342	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3343
3344		}catch (const BossSchedFailure & e) {
3345	<	SWIG_exception(SWIG_ValueError, e.what());
3345	>	PyErr_SetString ( SchedulerError, e.what() );
3346	>	return NULL;
3347		}catch (const std::exception& e) {
3348	<	SWIG_exception(SWIG_RuntimeError, e.what());
3348	>	PyErr_SetString ( BossError, e.what() );
3349	>	return NULL;
3350		}
3351		}
3352		{
#	Line 3407 | Line 3360 | static PyObject *_wrap_BossSession_query
3360		}
3361
3362
3363	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3411	<	PyObject *obj;
3412	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3413	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3414	<	Py_INCREF(obj);
3415	<	return Py_BuildValue((char *)"");
3416	<	}
3417	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3363	>	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3364		PyObject *resultobj;
3365	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3366	<	char *arg2 ;
3365	>	BossSession *arg1 = (BossSession *) 0 ;
3366	>	std::string *arg2 = 0 ;
3367	>	SwigValueWrapper< std::vector<BossTask * > > result;
3368	>	std::string temp2 ;
3369		PyObject * obj0 = 0 ;
3370	+	PyObject * obj1 = 0 ;
3371
3372	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3373	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3372	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3373	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3374		{
3375	<	if (arg2) {
3376	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3377	<	strcpy((char *) arg1->key,arg2);
3375	>	if (PyString_Check(obj1)) {
3376	>	temp2 = std::string(PyString_AsString(obj1));
3377	>	arg2 = &temp2;
3378		}else {
3379	<	arg1->key = 0;
3379	>	SWIG_exception(SWIG_TypeError, "string expected");
3380		}
3381		}
3382	<	Py_INCREF(Py_None); resultobj = Py_None;
3382	>	{
3383	>	try {
3384	>	result = (arg1)->getTasksByName((std::string const &)*arg2);
3385	>
3386	>	}catch (const BossSchedFailure & e) {
3387	>	PyErr_SetString ( SchedulerError, e.what() );
3388	>	return NULL;
3389	>	}catch (const std::exception& e) {
3390	>	PyErr_SetString ( BossError, e.what() );
3391	>	return NULL;
3392	>	}
3393	>	}
3394	>	{
3395	>	std::vector<BossTask * > * resultptr;
3396	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3397	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3398	>	}
3399		return resultobj;
3400		fail:
3401		return NULL;
3402		}
3403
3404
3405	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3405	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3406		PyObject *resultobj;
3407	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3408	<	char *result;
3407	>	BossSession *arg1 = (BossSession *) 0 ;
3408	>	std::vector<std::string > *arg2 = 0 ;
3409	>	PyObject *result;
3410		PyObject * obj0 = 0 ;
3411	+	PyObject * obj1 = 0 ;
3412
3413	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3414	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3415	<	result = (char *) ((arg1)->key);
3416	<
3417	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3413	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3414	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3415	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3416	>	if (arg2 == NULL) {
3417	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3418	>	}
3419	>	{
3420	>	try {
3421	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3422	>
3423	>	}catch (const BossSchedFailure & e) {
3424	>	PyErr_SetString ( SchedulerError, e.what() );
3425	>	return NULL;
3426	>	}catch (const std::exception& e) {
3427	>	PyErr_SetString ( BossError, e.what() );
3428	>	return NULL;
3429	>	}
3430	>	}
3431	>	resultobj = result;
3432		return resultobj;
3433		fail:
3434		return NULL;
3435		}
3436
3437
3438	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3438	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3439		PyObject *resultobj;
3440	<	char *arg1 ;
3441	<	BossTaskException *result;
3440	>	BossSession *arg1 = (BossSession *) 0 ;
3441	>	PyObject *result;
3442	>	PyObject * obj0 = 0 ;
3443
3444	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3444	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3445	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3446		{
3447		try {
3448	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3448	>	result = (PyObject *)BossSession_CHTools(arg1);
3449
3450		}catch (const BossSchedFailure & e) {
3451	<	SWIG_exception(SWIG_ValueError, e.what());
3451	>	PyErr_SetString ( SchedulerError, e.what() );
3452	>	return NULL;
3453		}catch (const std::exception& e) {
3454	<	SWIG_exception(SWIG_RuntimeError, e.what());
3454	>	PyErr_SetString ( BossError, e.what() );
3455	>	return NULL;
3456		}
3457		}
3458	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3458	>	resultobj = result;
3459		return resultobj;
3460		fail:
3461		return NULL;
3462		}
3463
3464
3465	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3465	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3466		PyObject *resultobj;
3467	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3468	<	char *result;
3467	>	BossSession *arg1 = (BossSession *) 0 ;
3468	>	PyObject *result;
3469		PyObject * obj0 = 0 ;
3470
3471	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3472	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3471	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3472	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3473		{
3474		try {
3475	<	result = (char *)((BossTaskException const *)arg1)->what();
3475	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3476
3477		}catch (const BossSchedFailure & e) {
3478	<	SWIG_exception(SWIG_ValueError, e.what());
3478	>	PyErr_SetString ( SchedulerError, e.what() );
3479	>	return NULL;
3480		}catch (const std::exception& e) {
3481	<	SWIG_exception(SWIG_RuntimeError, e.what());
3481	>	PyErr_SetString ( BossError, e.what() );
3482	>	return NULL;
3483		}
3484		}
3485	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3485	>	resultobj = result;
3486		return resultobj;
3487		fail:
3488		return NULL;
3489		}
3490
3491
3492	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3492	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3493		PyObject *resultobj;
3494	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3494	>	BossSession *arg1 = (BossSession *) 0 ;
3495	>	PyObject *result;
3496		PyObject * obj0 = 0 ;
3497
3498	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3499	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3498	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3499	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3500		{
3501		try {
3502	<	delete arg1;
3502	>	result = (PyObject *)BossSession_RTMons(arg1);
3503
3504		}catch (const BossSchedFailure & e) {
3505	<	SWIG_exception(SWIG_ValueError, e.what());
3505	>	PyErr_SetString ( SchedulerError, e.what() );
3506	>	return NULL;
3507		}catch (const std::exception& e) {
3508	<	SWIG_exception(SWIG_RuntimeError, e.what());
3508	>	PyErr_SetString ( BossError, e.what() );
3509	>	return NULL;
3510		}
3511		}
3512	<	Py_INCREF(Py_None); resultobj = Py_None;
3512	>	resultobj = result;
3513		return resultobj;
3514		fail:
3515		return NULL;
3516		}
3517
3518
3519	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3530	<	PyObject *obj;
3531	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3532	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3533	<	Py_INCREF(obj);
3534	<	return Py_BuildValue((char *)"");
3535	<	}
3536	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3519	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3520		PyObject *resultobj;
3521	<	BossTask *arg1 = (BossTask *) 0 ;
3539	<	PyObject *arg2 = (PyObject *) 0 ;
3540	<	BossAttributeContainer *arg3 = 0 ;
3521	>	BossSession *arg1 = (BossSession *) 0 ;
3522		PyObject *result;
3523		PyObject * obj0 = 0 ;
3543	–	PyObject * obj1 = 0 ;
3544	–	PyObject * obj2 = 0 ;
3524
3525	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3526	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3548	<	arg2 = obj1;
3549	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3550	<	if (arg3 == NULL) {
3551	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3552	<	}
3525	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3526	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3527		{
3528		try {
3529	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3529	>	result = (PyObject *)BossSession_schedulers(arg1);
3530
3531		}catch (const BossSchedFailure & e) {
3532	<	SWIG_exception(SWIG_ValueError, e.what());
3532	>	PyErr_SetString ( SchedulerError, e.what() );
3533	>	return NULL;
3534		}catch (const std::exception& e) {
3535	<	SWIG_exception(SWIG_RuntimeError, e.what());
3535	>	PyErr_SetString ( BossError, e.what() );
3536	>	return NULL;
3537		}
3538		}
3539		resultobj = result;
#	Line 3567 | Line 3543 | static PyObject *_wrap_BossTask_appendTo
3543		}
3544
3545
3546	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3546	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3547		PyObject *resultobj;
3548	<	BossTask *arg1 = (BossTask *) 0 ;
3549	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3548	>	BossSession *arg1 = (BossSession *) 0 ;
3549	>	std::string *arg2 = 0 ;
3550	>	std::string *arg3 = 0 ;
3551	>	std::string const &arg4_defvalue = "" ;
3552	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3553	>	std::string const &arg5_defvalue = "" ;
3554	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3555	>	unsigned int arg6 = (unsigned int) 0 ;
3556	>	bool arg7 = (bool) false ;
3557		PyObject *result;
3558	+	std::string temp2 ;
3559	+	std::string temp3 ;
3560	+	std::string temp4 ;
3561	+	std::string temp5 ;
3562		PyObject * obj0 = 0 ;
3563		PyObject * obj1 = 0 ;
3564	+	PyObject * obj2 = 0 ;
3565	+	PyObject * obj3 = 0 ;
3566	+	PyObject * obj4 = 0 ;
3567	+	PyObject * obj5 = 0 ;
3568	+	PyObject * obj6 = 0 ;
3569
3570	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3571	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3572	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3573	<	if (arg2 == NULL) {
3574	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3570	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3571	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3572	>	{
3573	>	if (PyString_Check(obj1)) {
3574	>	temp2 = std::string(PyString_AsString(obj1));
3575	>	arg2 = &temp2;
3576	>	}else {
3577	>	SWIG_exception(SWIG_TypeError, "string expected");
3578	>	}
3579	>	}
3580	>	{
3581	>	if (PyString_Check(obj2)) {
3582	>	temp3 = std::string(PyString_AsString(obj2));
3583	>	arg3 = &temp3;
3584	>	}else {
3585	>	SWIG_exception(SWIG_TypeError, "string expected");
3586	>	}
3587	>	}
3588	>	if (obj3) {
3589	>	{
3590	>	if (PyString_Check(obj3)) {
3591	>	temp4 = std::string(PyString_AsString(obj3));
3592	>	arg4 = &temp4;
3593	>	}else {
3594	>	SWIG_exception(SWIG_TypeError, "string expected");
3595	>	}
3596	>	}
3597	>	}
3598	>	if (obj4) {
3599	>	{
3600	>	if (PyString_Check(obj4)) {
3601	>	temp5 = std::string(PyString_AsString(obj4));
3602	>	arg5 = &temp5;
3603	>	}else {
3604	>	SWIG_exception(SWIG_TypeError, "string expected");
3605	>	}
3606	>	}
3607	>	}
3608	>	if (obj5) {
3609	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3610	>	if (PyErr_Occurred()) SWIG_fail;
3611	>	}
3612	>	if (obj6) {
3613	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3614	>	if (PyErr_Occurred()) SWIG_fail;
3615		}
3616		{
3617		try {
3618	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3618	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3619
3620		}catch (const BossSchedFailure & e) {
3621	<	SWIG_exception(SWIG_ValueError, e.what());
3621	>	PyErr_SetString ( SchedulerError, e.what() );
3622	>	return NULL;
3623		}catch (const std::exception& e) {
3624	<	SWIG_exception(SWIG_RuntimeError, e.what());
3624	>	PyErr_SetString ( BossError, e.what() );
3625	>	return NULL;
3626		}
3627		}
3628		resultobj = result;
#	Line 3598 | Line 3632 | static PyObject *_wrap_BossTask_jobDict(
3632		}
3633
3634
3635	<	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
3635	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3636		PyObject *resultobj;
3637	<	BossTask *arg1 = (BossTask *) 0 ;
3637	>	BossSession *arg1 = (BossSession *) 0 ;
3638	>	std::string const &arg2_defvalue = "" ;
3639	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3640	>	std::string const &arg3_defvalue = "all" ;
3641	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3642	>	std::string arg4 = (std::string) "" ;
3643	>	std::string arg5 = (std::string) "" ;
3644	>	std::string arg6 = (std::string) "" ;
3645		PyObject *result;
3646	+	std::string temp2 ;
3647	+	std::string temp3 ;
3648		PyObject * obj0 = 0 ;
3649	+	PyObject * obj1 = 0 ;
3650	+	PyObject * obj2 = 0 ;
3651	+	PyObject * obj3 = 0 ;
3652	+	PyObject * obj4 = 0 ;
3653	+	PyObject * obj5 = 0 ;
3654
3655	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3656	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3655	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3656	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3657	>	if (obj1) {
3658	>	{
3659	>	if (PyString_Check(obj1)) {
3660	>	temp2 = std::string(PyString_AsString(obj1));
3661	>	arg2 = &temp2;
3662	>	}else {
3663	>	SWIG_exception(SWIG_TypeError, "string expected");
3664	>	}
3665	>	}
3666	>	}
3667	>	if (obj2) {
3668	>	{
3669	>	if (PyString_Check(obj2)) {
3670	>	temp3 = std::string(PyString_AsString(obj2));
3671	>	arg3 = &temp3;
3672	>	}else {
3673	>	SWIG_exception(SWIG_TypeError, "string expected");
3674	>	}
3675	>	}
3676	>	}
3677	>	if (obj3) {
3678	>	{
3679	>	if (PyString_Check(obj3))
3680	>	arg4 = std::string(PyString_AsString(obj3));
3681	>	else
3682	>	SWIG_exception(SWIG_TypeError, "string expected");
3683	>	}
3684	>	}
3685	>	if (obj4) {
3686	>	{
3687	>	if (PyString_Check(obj4))
3688	>	arg5 = std::string(PyString_AsString(obj4));
3689	>	else
3690	>	SWIG_exception(SWIG_TypeError, "string expected");
3691	>	}
3692	>	}
3693	>	if (obj5) {
3694	>	{
3695	>	if (PyString_Check(obj5))
3696	>	arg6 = std::string(PyString_AsString(obj5));
3697	>	else
3698	>	SWIG_exception(SWIG_TypeError, "string expected");
3699	>	}
3700	>	}
3701		{
3702		try {
3703	<	result = (PyObject *)BossTask_jobsDict(arg1);
3703	>	result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3704
3705		}catch (const BossSchedFailure & e) {
3706	<	SWIG_exception(SWIG_ValueError, e.what());
3706	>	PyErr_SetString ( SchedulerError, e.what() );
3707	>	return NULL;
3708		}catch (const std::exception& e) {
3709	<	SWIG_exception(SWIG_RuntimeError, e.what());
3709	>	PyErr_SetString ( BossError, e.what() );
3710	>	return NULL;
3711		}
3712		}
3713		resultobj = result;
#	Line 3623 | Line 3717 | static PyObject *_wrap_BossTask_jobsDict
3717		}
3718
3719
3720	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3720	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3721	>	PyObject *obj;
3722	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3723	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3724	>	Py_INCREF(obj);
3725	>	return Py_BuildValue((char *)"");
3726	>	}
3727	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3728		PyObject *resultobj;
3729	<	BossTask *arg1 = (BossTask *) 0 ;
3730	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3630	<	PyObject *result;
3729	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3730	>	char *arg2 ;
3731		PyObject * obj0 = 0 ;
3632	–	PyObject * obj1 = 0 ;
3732
3733	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3734	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3735	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3736	<	if (arg2 == NULL) {
3737	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3733	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3734	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3735	>	{
3736	>	if (arg2) {
3737	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3738	>	strcpy((char *) arg1->key,arg2);
3739	>	}else {
3740	>	arg1->key = 0;
3741	>	}
3742		}
3743	+	Py_INCREF(Py_None); resultobj = Py_None;
3744	+	return resultobj;
3745	+	fail:
3746	+	return NULL;
3747	+	}
3748	+
3749	+
3750	+	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3751	+	PyObject *resultobj;
3752	+	BossTaskException *arg1 = (BossTaskException *) 0 ;
3753	+	char *result;
3754	+	PyObject * obj0 = 0 ;
3755	+
3756	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3757	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3758	+	result = (char *) ((arg1)->key);
3759	+
3760	+	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3761	+	return resultobj;
3762	+	fail:
3763	+	return NULL;
3764	+	}
3765	+
3766	+
3767	+	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3768	+	PyObject *resultobj;
3769	+	char *arg1 ;
3770	+	BossTaskException *result;
3771	+
3772	+	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3773		{
3774		try {
3775	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3775	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3776
3777		}catch (const BossSchedFailure & e) {
3778	<	SWIG_exception(SWIG_ValueError, e.what());
3778	>	PyErr_SetString ( SchedulerError, e.what() );
3779	>	return NULL;
3780		}catch (const std::exception& e) {
3781	<	SWIG_exception(SWIG_RuntimeError, e.what());
3781	>	PyErr_SetString ( BossError, e.what() );
3782	>	return NULL;
3783		}
3784		}
3785	<	resultobj = result;
3785	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3786		return resultobj;
3787		fail:
3788		return NULL;
3789		}
3790
3791
3792	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
3792	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3793		PyObject *resultobj;
3794	<	BossTask *arg1 = (BossTask *) 0 ;
3795	<	std::string *arg2 = 0 ;
3661	<	PyObject *result;
3662	<	std::string temp2 ;
3794	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3795	>	char *result;
3796		PyObject * obj0 = 0 ;
3664	–	PyObject * obj1 = 0 ;
3797
3798	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3799	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3798	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3799	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3800		{
3801	<	if (PyString_Check(obj1)) {
3802	<	temp2 = std::string(PyString_AsString(obj1));
3803	<	arg2 = &temp2;
3804	<	}else {
3805	<	SWIG_exception(SWIG_TypeError, "string expected");
3801	>	try {
3802	>	result = (char *)((BossTaskException const *)arg1)->what();
3803	>
3804	>	}catch (const BossSchedFailure & e) {
3805	>	PyErr_SetString ( SchedulerError, e.what() );
3806	>	return NULL;
3807	>	}catch (const std::exception& e) {
3808	>	PyErr_SetString ( BossError, e.what() );
3809	>	return NULL;
3810		}
3811		}
3812	+	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3813	+	return resultobj;
3814	+	fail:
3815	+	return NULL;
3816	+	}
3817	+
3818	+
3819	+	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3820	+	PyObject *resultobj;
3821	+	BossTaskException *arg1 = (BossTaskException *) 0 ;
3822	+	PyObject * obj0 = 0 ;
3823	+
3824	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3825	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3826		{
3827		try {
3828	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3828	>	delete arg1;
3829
3830		}catch (const BossSchedFailure & e) {
3831	<	SWIG_exception(SWIG_ValueError, e.what());
3831	>	PyErr_SetString ( SchedulerError, e.what() );
3832	>	return NULL;
3833		}catch (const std::exception& e) {
3834	<	SWIG_exception(SWIG_RuntimeError, e.what());
3834	>	PyErr_SetString ( BossError, e.what() );
3835	>	return NULL;
3836		}
3837		}
3838	<	resultobj = result;
3838	>	Py_INCREF(Py_None); resultobj = Py_None;
3839		return resultobj;
3840		fail:
3841		return NULL;
3842		}
3843
3844
3845	+	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3846	+	PyObject *obj;
3847	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3848	+	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3849	+	Py_INCREF(obj);
3850	+	return Py_BuildValue((char *)"");
3851	+	}
3852		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3853		PyObject *resultobj;
3854		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 3703 | Line 3862 | static PyObject *_wrap_new_BossTask__SWI
3862		result = (BossTask *)new BossTask(arg1);
3863
3864		}catch (const BossSchedFailure & e) {
3865	<	SWIG_exception(SWIG_ValueError, e.what());
3865	>	PyErr_SetString ( SchedulerError, e.what() );
3866	>	return NULL;
3867		}catch (const std::exception& e) {
3868	<	SWIG_exception(SWIG_RuntimeError, e.what());
3868	>	PyErr_SetString ( BossError, e.what() );
3869	>	return NULL;
3870		}
3871		}
3872		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3739 | Line 3900 | static PyObject *_wrap_new_BossTask__SWI
3900		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3901
3902		}catch (const BossSchedFailure & e) {
3903	<	SWIG_exception(SWIG_ValueError, e.what());
3903	>	PyErr_SetString ( SchedulerError, e.what() );
3904	>	return NULL;
3905		}catch (const std::exception& e) {
3906	<	SWIG_exception(SWIG_RuntimeError, e.what());
3906	>	PyErr_SetString ( BossError, e.what() );
3907	>	return NULL;
3908		}
3909		}
3910		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3763 | Line 3926 | static PyObject *_wrap_delete_BossTask(P
3926		delete arg1;
3927
3928		}catch (const BossSchedFailure & e) {
3929	<	SWIG_exception(SWIG_ValueError, e.what());
3929	>	PyErr_SetString ( SchedulerError, e.what() );
3930	>	return NULL;
3931		}catch (const std::exception& e) {
3932	<	SWIG_exception(SWIG_RuntimeError, e.what());
3932	>	PyErr_SetString ( BossError, e.what() );
3933	>	return NULL;
3934		}
3935		}
3936		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3791 | Line 3956 | static PyObject *_wrap_new_BossTask__SWI
3956		result = (BossTask *)new BossTask((BossTask const &)*arg1);
3957
3958		}catch (const BossSchedFailure & e) {
3959	<	SWIG_exception(SWIG_ValueError, e.what());
3959	>	PyErr_SetString ( SchedulerError, e.what() );
3960	>	return NULL;
3961		}catch (const std::exception& e) {
3962	<	SWIG_exception(SWIG_RuntimeError, e.what());
3962	>	PyErr_SetString ( BossError, e.what() );
3963	>	return NULL;
3964		}
3965		}
3966		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
#	Line 3884 | Line 4051 | static PyObject *_wrap_BossTask_id(PyObj
4051		}
4052
4053		}catch (const BossSchedFailure & e) {
4054	<	SWIG_exception(SWIG_ValueError, e.what());
4054	>	PyErr_SetString ( SchedulerError, e.what() );
4055	>	return NULL;
4056		}catch (const std::exception& e) {
4057	<	SWIG_exception(SWIG_RuntimeError, e.what());
4057	>	PyErr_SetString ( BossError, e.what() );
4058	>	return NULL;
4059		}
4060		}
4061		{
#	Line 3914 | Line 4083 | static PyObject *_wrap_BossTask_name(PyO
4083		}
4084
4085		}catch (const BossSchedFailure & e) {
4086	<	SWIG_exception(SWIG_ValueError, e.what());
4086	>	PyErr_SetString ( SchedulerError, e.what() );
4087	>	return NULL;
4088		}catch (const std::exception& e) {
4089	<	SWIG_exception(SWIG_RuntimeError, e.what());
4089	>	PyErr_SetString ( BossError, e.what() );
4090	>	return NULL;
4091		}
4092		}
4093		{
#	Line 3941 | Line 4112 | static PyObject *_wrap_BossTask_taskMap(
4112		result = ((BossTask const *)arg1)->taskMap();
4113
4114		}catch (const BossSchedFailure & e) {
4115	<	SWIG_exception(SWIG_ValueError, e.what());
4115	>	PyErr_SetString ( SchedulerError, e.what() );
4116	>	return NULL;
4117		}catch (const std::exception& e) {
4118	<	SWIG_exception(SWIG_RuntimeError, e.what());
4118	>	PyErr_SetString ( BossError, e.what() );
4119	>	return NULL;
4120		}
4121		}
4122		{
#	Line 3973 | Line 4146 | static PyObject *_wrap_BossTask_job_begi
4146		result = ((BossTask const *)arg1)->job_begin();
4147
4148		}catch (const BossSchedFailure & e) {
4149	<	SWIG_exception(SWIG_ValueError, e.what());
4149	>	PyErr_SetString ( SchedulerError, e.what() );
4150	>	return NULL;
4151		}catch (const std::exception& e) {
4152	<	SWIG_exception(SWIG_RuntimeError, e.what());
4152	>	PyErr_SetString ( BossError, e.what() );
4153	>	return NULL;
4154		}
4155		}
4156		{
#	Line 4002 | Line 4177 | static PyObject *_wrap_BossTask_job_end(
4177		result = ((BossTask const *)arg1)->job_end();
4178
4179		}catch (const BossSchedFailure & e) {
4180	<	SWIG_exception(SWIG_ValueError, e.what());
4180	>	PyErr_SetString ( SchedulerError, e.what() );
4181	>	return NULL;
4182		}catch (const std::exception& e) {
4183	<	SWIG_exception(SWIG_RuntimeError, e.what());
4183	>	PyErr_SetString ( BossError, e.what() );
4184	>	return NULL;
4185		}
4186		}
4187		{
#	Line 4031 | Line 4208 | static PyObject *_wrap_BossTask_jobsMap(
4208		result = ((BossTask const *)arg1)->jobsMap();
4209
4210		}catch (const BossSchedFailure & e) {
4211	<	SWIG_exception(SWIG_ValueError, e.what());
4211	>	PyErr_SetString ( SchedulerError, e.what() );
4212	>	return NULL;
4213		}catch (const std::exception& e) {
4214	<	SWIG_exception(SWIG_RuntimeError, e.what());
4214	>	PyErr_SetString ( BossError, e.what() );
4215	>	return NULL;
4216		}
4217		}
4218		{
#	Line 4071 | Line 4250 | static PyObject *_wrap_BossTask_jobMap__
4250		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4251
4252		}catch (const BossSchedFailure & e) {
4253	<	SWIG_exception(SWIG_ValueError, e.what());
4253	>	PyErr_SetString ( SchedulerError, e.what() );
4254	>	return NULL;
4255		}catch (const std::exception& e) {
4256	<	SWIG_exception(SWIG_RuntimeError, e.what());
4256	>	PyErr_SetString ( BossError, e.what() );
4257	>	return NULL;
4258		}
4259		}
4260		{
#	Line 4102 | Line 4283 | static PyObject *_wrap_BossTask_jobMap__
4283		result = ((BossTask const *)arg1)->jobMap(arg2);
4284
4285		}catch (const BossSchedFailure & e) {
4286	<	SWIG_exception(SWIG_ValueError, e.what());
4286	>	PyErr_SetString ( SchedulerError, e.what() );
4287	>	return NULL;
4288		}catch (const std::exception& e) {
4289	<	SWIG_exception(SWIG_RuntimeError, e.what());
4289	>	PyErr_SetString ( BossError, e.what() );
4290	>	return NULL;
4291		}
4292		}
4293		{
#	Line 4209 | Line 4392 | static PyObject *_wrap_BossTask_programs
4392		result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4393
4394		}catch (const BossSchedFailure & e) {
4395	<	SWIG_exception(SWIG_ValueError, e.what());
4395	>	PyErr_SetString ( SchedulerError, e.what() );
4396	>	return NULL;
4397		}catch (const std::exception& e) {
4398	<	SWIG_exception(SWIG_RuntimeError, e.what());
4398	>	PyErr_SetString ( BossError, e.what() );
4399	>	return NULL;
4400		}
4401		}
4402		{
#	Line 4241 | Line 4426 | static PyObject *_wrap_BossTask_queryJob
4426		result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4427
4428		}catch (const BossSchedFailure & e) {
4429	<	SWIG_exception(SWIG_ValueError, e.what());
4429	>	PyErr_SetString ( SchedulerError, e.what() );
4430	>	return NULL;
4431		}catch (const std::exception& e) {
4432	<	SWIG_exception(SWIG_RuntimeError, e.what());
4432	>	PyErr_SetString ( BossError, e.what() );
4433	>	return NULL;
4434		}
4435		}
4436		{
#	Line 4294 | Line 4481 | static PyObject *_wrap_BossTask_declare_
4481		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4482
4483		}catch (const BossSchedFailure & e) {
4484	<	SWIG_exception(SWIG_ValueError, e.what());
4484	>	PyErr_SetString ( SchedulerError, e.what() );
4485	>	return NULL;
4486		}catch (const std::exception& e) {
4487	<	SWIG_exception(SWIG_RuntimeError, e.what());
4487	>	PyErr_SetString ( BossError, e.what() );
4488	>	return NULL;
4489		}
4490		}
4491		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4335 | Line 4524 | static PyObject *_wrap_BossTask_declare_
4524		(arg1)->declare(arg2,(std::string const &)*arg3);
4525
4526		}catch (const BossSchedFailure & e) {
4527	<	SWIG_exception(SWIG_ValueError, e.what());
4527	>	PyErr_SetString ( SchedulerError, e.what() );
4528	>	return NULL;
4529		}catch (const std::exception& e) {
4530	<	SWIG_exception(SWIG_RuntimeError, e.what());
4530	>	PyErr_SetString ( BossError, e.what() );
4531	>	return NULL;
4532		}
4533		}
4534		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4436 | Line 4627 | static PyObject *_wrap_BossTask_remove(P
4627		(arg1)->remove();
4628
4629		}catch (const BossSchedFailure & e) {
4630	<	SWIG_exception(SWIG_ValueError, e.what());
4630	>	PyErr_SetString ( SchedulerError, e.what() );
4631	>	return NULL;
4632		}catch (const std::exception& e) {
4633	<	SWIG_exception(SWIG_RuntimeError, e.what());
4633	>	PyErr_SetString ( BossError, e.what() );
4634	>	return NULL;
4635		}
4636		}
4637		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4474 | Line 4667 | static PyObject *_wrap_BossTask_archive(
4667		(arg1)->archive((std::string const &)*arg2);
4668
4669		}catch (const BossSchedFailure & e) {
4670	<	SWIG_exception(SWIG_ValueError, e.what());
4670	>	PyErr_SetString ( SchedulerError, e.what() );
4671	>	return NULL;
4672		}catch (const std::exception& e) {
4673	<	SWIG_exception(SWIG_RuntimeError, e.what());
4673	>	PyErr_SetString ( BossError, e.what() );
4674	>	return NULL;
4675		}
4676		}
4677		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 4499 | Line 4694 | static PyObject *_wrap_BossTask_submit(P
4694		std::string *arg5 = (std::string *) &arg5_defvalue ;
4695		std::string const &arg6_defvalue = "" ;
4696		std::string *arg6 = (std::string *) &arg6_defvalue ;
4697	<	bool arg7 = (bool) false ;
4697	>	unsigned int arg7 = (unsigned int) 0 ;
4698	>	bool arg8 = (bool) false ;
4699		int result;
4700		std::string temp2 ;
4701		std::string temp3 ;
#	Line 4513 | Line 4709 | static PyObject *_wrap_BossTask_submit(P
4709		PyObject * obj4 = 0 ;
4710		PyObject * obj5 = 0 ;
4711		PyObject * obj6 = 0 ;
4712	+	PyObject * obj7 = 0 ;
4713
4714	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4714	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4715		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4716		if (obj1) {
4717		{
#	Line 4567 | Line 4764 | static PyObject *_wrap_BossTask_submit(P
4764		}
4765		}
4766		if (obj6) {
4767	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4767	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4768	>	if (PyErr_Occurred()) SWIG_fail;
4769	>	}
4770	>	if (obj7) {
4771	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4772		if (PyErr_Occurred()) SWIG_fail;
4773		}
4774		{
4775		try {
4776	<	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);
4776	>	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);
4777
4778		}catch (const BossSchedFailure & e) {
4779	<	SWIG_exception(SWIG_ValueError, e.what());
4779	>	PyErr_SetString ( SchedulerError, e.what() );
4780	>	return NULL;
4781		}catch (const std::exception& e) {
4782	<	SWIG_exception(SWIG_RuntimeError, e.what());
4782	>	PyErr_SetString ( BossError, e.what() );
4783	>	return NULL;
4784		}
4785		}
4786		resultobj = PyInt_FromLong((long)result);
#	Line 4617 | Line 4820 | static PyObject *_wrap_BossTask_reSubmit
4820		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4821
4822		}catch (const BossSchedFailure & e) {
4823	<	SWIG_exception(SWIG_ValueError, e.what());
4823	>	PyErr_SetString ( SchedulerError, e.what() );
4824	>	return NULL;
4825		}catch (const std::exception& e) {
4826	<	SWIG_exception(SWIG_RuntimeError, e.what());
4826	>	PyErr_SetString ( BossError, e.what() );
4827	>	return NULL;
4828		}
4829		}
4830		resultobj = PyInt_FromLong((long)result);
#	Line 4633 | Line 4838 | static PyObject *_wrap_BossTask_kill(PyO
4838		PyObject *resultobj;
4839		BossTask *arg1 = (BossTask *) 0 ;
4840		std::string *arg2 = 0 ;
4841	<	bool arg3 = (bool) false ;
4841	>	unsigned int arg3 = (unsigned int) 0 ;
4842	>	bool arg4 = (bool) false ;
4843		int result;
4844		std::string temp2 ;
4845		PyObject * obj0 = 0 ;
4846		PyObject * obj1 = 0 ;
4847		PyObject * obj2 = 0 ;
4848	+	PyObject * obj3 = 0 ;
4849
4850	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4850	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
4851		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4852		{
4853		if (PyString_Check(obj1)) {
#	Line 4651 | Line 4858 | static PyObject *_wrap_BossTask_kill(PyO
4858		}
4859		}
4860		if (obj2) {
4861	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4861	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
4862	>	if (PyErr_Occurred()) SWIG_fail;
4863	>	}
4864	>	if (obj3) {
4865	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4866		if (PyErr_Occurred()) SWIG_fail;
4867		}
4868		{
4869		try {
4870	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4870	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
4871
4872		}catch (const BossSchedFailure & e) {
4873	<	SWIG_exception(SWIG_ValueError, e.what());
4873	>	PyErr_SetString ( SchedulerError, e.what() );
4874	>	return NULL;
4875		}catch (const std::exception& e) {
4876	<	SWIG_exception(SWIG_RuntimeError, e.what());
4876	>	PyErr_SetString ( BossError, e.what() );
4877	>	return NULL;
4878		}
4879		}
4880		resultobj = PyInt_FromLong((long)result);
#	Line 4678 | Line 4891 | static PyObject *_wrap_BossTask_getOutpu
4891		std::string *arg2 = (std::string *) &arg2_defvalue ;
4892		std::string const &arg3_defvalue = "" ;
4893		std::string *arg3 = (std::string *) &arg3_defvalue ;
4894	<	bool arg4 = (bool) false ;
4894	>	unsigned int arg4 = (unsigned int) 0 ;
4895		bool arg5 = (bool) false ;
4896	+	bool arg6 = (bool) false ;
4897		int result;
4898		std::string temp2 ;
4899		std::string temp3 ;
#	Line 4688 | Line 4902 | static PyObject *_wrap_BossTask_getOutpu
4902		PyObject * obj2 = 0 ;
4903		PyObject * obj3 = 0 ;
4904		PyObject * obj4 = 0 ;
4905	+	PyObject * obj5 = 0 ;
4906
4907	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4907	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
4908		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4909		if (obj1) {
4910		{
#	Line 4712 | Line 4927 | static PyObject *_wrap_BossTask_getOutpu
4927		}
4928		}
4929		if (obj3) {
4930	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4930	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
4931		if (PyErr_Occurred()) SWIG_fail;
4932		}
4933		if (obj4) {
4934		arg5 = PyInt_AsLong(obj4) ? true : false;
4935		if (PyErr_Occurred()) SWIG_fail;
4936		}
4937	+	if (obj5) {
4938	+	arg6 = PyInt_AsLong(obj5) ? true : false;
4939	+	if (PyErr_Occurred()) SWIG_fail;
4940	+	}
4941	+	{
4942	+	try {
4943	+	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
4944	+
4945	+	}catch (const BossSchedFailure & e) {
4946	+	PyErr_SetString ( SchedulerError, e.what() );
4947	+	return NULL;
4948	+	}catch (const std::exception& e) {
4949	+	PyErr_SetString ( BossError, e.what() );
4950	+	return NULL;
4951	+	}
4952	+	}
4953	+	resultobj = PyInt_FromLong((long)result);
4954	+	return resultobj;
4955	+	fail:
4956	+	return NULL;
4957	+	}
4958	+
4959	+
4960	+	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
4961	+	PyObject *resultobj;
4962	+	BossTask *arg1 = (BossTask *) 0 ;
4963	+	std::string *arg2 = 0 ;
4964	+	int result;
4965	+	std::string temp2 ;
4966	+	PyObject * obj0 = 0 ;
4967	+	PyObject * obj1 = 0 ;
4968	+
4969	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
4970	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4971	+	{
4972	+	if (PyString_Check(obj1)) {
4973	+	temp2 = std::string(PyString_AsString(obj1));
4974	+	arg2 = &temp2;
4975	+	}else {
4976	+	SWIG_exception(SWIG_TypeError, "string expected");
4977	+	}
4978	+	}
4979		{
4980		try {
4981	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4981	>	result = (int)(arg1)->loadByName((std::string const &)*arg2);
4982
4983		}catch (const BossSchedFailure & e) {
4984	<	SWIG_exception(SWIG_ValueError, e.what());
4984	>	PyErr_SetString ( SchedulerError, e.what() );
4985	>	return NULL;
4986		}catch (const std::exception& e) {
4987	<	SWIG_exception(SWIG_RuntimeError, e.what());
4987	>	PyErr_SetString ( BossError, e.what() );
4988	>	return NULL;
4989		}
4990		}
4991		resultobj = PyInt_FromLong((long)result);
#	Line 4818 | Line 5077 | static PyObject *_wrap_BossTask_load(PyO
5077		result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
5078
5079		}catch (const BossSchedFailure & e) {
5080	<	SWIG_exception(SWIG_ValueError, e.what());
5080	>	PyErr_SetString ( SchedulerError, e.what() );
5081	>	return NULL;
5082		}catch (const std::exception& e) {
5083	<	SWIG_exception(SWIG_RuntimeError, e.what());
5083	>	PyErr_SetString ( BossError, e.what() );
5084	>	return NULL;
5085		}
5086		}
5087		resultobj = PyInt_FromLong((long)result);
#	Line 4842 | Line 5103 | static PyObject *_wrap_BossTask_query(Py
5103		std::string arg6 = (std::string) "" ;
5104		std::string arg7 = (std::string) "" ;
5105		std::string arg8 = (std::string) "" ;
5106	<	bool arg9 = (bool) false ;
5106	>	unsigned int arg9 = (unsigned int) 0 ;
5107	>	bool arg10 = (bool) false ;
5108		int result;
5109		std::string temp3 ;
5110		std::string temp4 ;
#	Line 4854 | Line 5116 | static PyObject *_wrap_BossTask_query(Py
5116		PyObject * obj6 = 0 ;
5117		PyObject * obj7 = 0 ;
5118		PyObject * obj8 = 0 ;
5119	+	PyObject * obj9 = 0 ;
5120
5121	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5121	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5122		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5123		if (obj2) {
5124		{
#	Line 4910 | Line 5173 | static PyObject *_wrap_BossTask_query(Py
5173		}
5174		}
5175		if (obj8) {
5176	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5176	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5177	>	if (PyErr_Occurred()) SWIG_fail;
5178	>	}
5179	>	if (obj9) {
5180	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5181		if (PyErr_Occurred()) SWIG_fail;
5182		}
5183		{
5184		try {
5185	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5185	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5186
5187		}catch (const BossSchedFailure & e) {
5188	<	SWIG_exception(SWIG_ValueError, e.what());
5188	>	PyErr_SetString ( SchedulerError, e.what() );
5189	>	return NULL;
5190		}catch (const std::exception& e) {
5191	<	SWIG_exception(SWIG_RuntimeError, e.what());
5191	>	PyErr_SetString ( BossError, e.what() );
5192	>	return NULL;
5193		}
5194		}
5195		resultobj = PyInt_FromLong((long)result);
#	Line 4979 | Line 5248 | static PyObject *_wrap_BossTask_query_ou
5248		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5249
5250		}catch (const BossSchedFailure & e) {
5251	<	SWIG_exception(SWIG_ValueError, e.what());
5251	>	PyErr_SetString ( SchedulerError, e.what() );
5252	>	return NULL;
5253		}catch (const std::exception& e) {
5254	<	SWIG_exception(SWIG_RuntimeError, e.what());
5254	>	PyErr_SetString ( BossError, e.what() );
5255	>	return NULL;
5256		}
5257		}
5258		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5003 | Line 5274 | static PyObject *_wrap_BossTask_clear(Py
5274		(arg1)->clear();
5275
5276		}catch (const BossSchedFailure & e) {
5277	<	SWIG_exception(SWIG_ValueError, e.what());
5277	>	PyErr_SetString ( SchedulerError, e.what() );
5278	>	return NULL;
5279	>	}catch (const std::exception& e) {
5280	>	PyErr_SetString ( BossError, e.what() );
5281	>	return NULL;
5282	>	}
5283	>	}
5284	>	Py_INCREF(Py_None); resultobj = Py_None;
5285	>	return resultobj;
5286	>	fail:
5287	>	return NULL;
5288	>	}
5289	>
5290	>
5291	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5292	>	PyObject *resultobj;
5293	>	BossTask *arg1 = (BossTask *) 0 ;
5294	>	PyObject *arg2 = (PyObject *) 0 ;
5295	>	BossAttributeContainer *arg3 = 0 ;
5296	>	PyObject * obj0 = 0 ;
5297	>	PyObject * obj1 = 0 ;
5298	>	PyObject * obj2 = 0 ;
5299	>
5300	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5301	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5302	>	arg2 = obj1;
5303	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5304	>	if (arg3 == NULL) {
5305	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5306	>	}
5307	>	{
5308	>	try {
5309	>	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5310	>
5311	>	}catch (const BossSchedFailure & e) {
5312	>	PyErr_SetString ( SchedulerError, e.what() );
5313	>	return NULL;
5314		}catch (const std::exception& e) {
5315	<	SWIG_exception(SWIG_RuntimeError, e.what());
5315	>	PyErr_SetString ( BossError, e.what() );
5316	>	return NULL;
5317		}
5318		}
5319		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5015 | Line 5323 | static PyObject *_wrap_BossTask_clear(Py
5323		}
5324
5325
5326	+	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5327	+	PyObject *resultobj;
5328	+	BossTask *arg1 = (BossTask *) 0 ;
5329	+	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5330	+	PyObject *arg3 = (PyObject *) 0 ;
5331	+	PyObject * obj0 = 0 ;
5332	+	PyObject * obj1 = 0 ;
5333	+	PyObject * obj2 = 0 ;
5334	+
5335	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5336	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5337	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5338	+	if (arg2 == NULL) {
5339	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5340	+	}
5341	+	arg3 = obj2;
5342	+	{
5343	+	try {
5344	+	BossTask_jobDict((BossTask const *)arg1,*arg2,arg3);
5345	+
5346	+	}catch (const BossSchedFailure & e) {
5347	+	PyErr_SetString ( SchedulerError, e.what() );
5348	+	return NULL;
5349	+	}catch (const std::exception& e) {
5350	+	PyErr_SetString ( BossError, e.what() );
5351	+	return NULL;
5352	+	}
5353	+	}
5354	+	Py_INCREF(Py_None); resultobj = Py_None;
5355	+	return resultobj;
5356	+	fail:
5357	+	return NULL;
5358	+	}
5359	+
5360	+
5361	+	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5362	+	PyObject *resultobj;
5363	+	BossTask *arg1 = (BossTask *) 0 ;
5364	+	PyObject *result;
5365	+	PyObject * obj0 = 0 ;
5366	+
5367	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5368	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5369	+	{
5370	+	try {
5371	+	result = (PyObject *)BossTask_jobsDict(arg1);
5372	+
5373	+	}catch (const BossSchedFailure & e) {
5374	+	PyErr_SetString ( SchedulerError, e.what() );
5375	+	return NULL;
5376	+	}catch (const std::exception& e) {
5377	+	PyErr_SetString ( BossError, e.what() );
5378	+	return NULL;
5379	+	}
5380	+	}
5381	+	resultobj = result;
5382	+	return resultobj;
5383	+	fail:
5384	+	return NULL;
5385	+	}
5386	+
5387	+
5388	+	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5389	+	PyObject *resultobj;
5390	+	BossTask *arg1 = (BossTask *) 0 ;
5391	+	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5392	+	PyObject *result;
5393	+	PyObject * obj0 = 0 ;
5394	+	PyObject * obj1 = 0 ;
5395	+
5396	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5397	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5398	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5399	+	if (arg2 == NULL) {
5400	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5401	+	}
5402	+	{
5403	+	try {
5404	+	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5405	+
5406	+	}catch (const BossSchedFailure & e) {
5407	+	PyErr_SetString ( SchedulerError, e.what() );
5408	+	return NULL;
5409	+	}catch (const std::exception& e) {
5410	+	PyErr_SetString ( BossError, e.what() );
5411	+	return NULL;
5412	+	}
5413	+	}
5414	+	resultobj = result;
5415	+	return resultobj;
5416	+	fail:
5417	+	return NULL;
5418	+	}
5419	+
5420	+
5421	+	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5422	+	PyObject *resultobj;
5423	+	BossTask *arg1 = (BossTask *) 0 ;
5424	+	std::string *arg2 = 0 ;
5425	+	PyObject *result;
5426	+	std::string temp2 ;
5427	+	PyObject * obj0 = 0 ;
5428	+	PyObject * obj1 = 0 ;
5429	+
5430	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5431	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5432	+	{
5433	+	if (PyString_Check(obj1)) {
5434	+	temp2 = std::string(PyString_AsString(obj1));
5435	+	arg2 = &temp2;
5436	+	}else {
5437	+	SWIG_exception(SWIG_TypeError, "string expected");
5438	+	}
5439	+	}
5440	+	{
5441	+	try {
5442	+	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5443	+
5444	+	}catch (const BossSchedFailure & e) {
5445	+	PyErr_SetString ( SchedulerError, e.what() );
5446	+	return NULL;
5447	+	}catch (const std::exception& e) {
5448	+	PyErr_SetString ( BossError, e.what() );
5449	+	return NULL;
5450	+	}
5451	+	}
5452	+	resultobj = result;
5453	+	return resultobj;
5454	+	fail:
5455	+	return NULL;
5456	+	}
5457	+
5458	+
5459		static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5460		PyObject *obj;
5461		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 5078 | Line 5519 | static PyObject *_wrap_new_BossAdministr
5519		result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5520
5521		}catch (const BossSchedFailure & e) {
5522	<	SWIG_exception(SWIG_ValueError, e.what());
5522	>	PyErr_SetString ( SchedulerError, e.what() );
5523	>	return NULL;
5524		}catch (const std::exception& e) {
5525	<	SWIG_exception(SWIG_RuntimeError, e.what());
5525	>	PyErr_SetString ( BossError, e.what() );
5526	>	return NULL;
5527		}
5528		}
5529		resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
#	Line 5102 | Line 5545 | static PyObject *_wrap_delete_BossAdmini
5545		delete arg1;
5546
5547		}catch (const BossSchedFailure & e) {
5548	<	SWIG_exception(SWIG_ValueError, e.what());
5548	>	PyErr_SetString ( SchedulerError, e.what() );
5549	>	return NULL;
5550		}catch (const std::exception& e) {
5551	<	SWIG_exception(SWIG_RuntimeError, e.what());
5551	>	PyErr_SetString ( BossError, e.what() );
5552	>	return NULL;
5553		}
5554		}
5555		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 5127 | Line 5572 | static PyObject *_wrap_BossAdministrator
5572		result = (int)(arg1)->configureDB();
5573
5574		}catch (const BossSchedFailure & e) {
5575	<	SWIG_exception(SWIG_ValueError, e.what());
5575	>	PyErr_SetString ( SchedulerError, e.what() );
5576	>	return NULL;
5577		}catch (const std::exception& e) {
5578	<	SWIG_exception(SWIG_RuntimeError, e.what());
5578	>	PyErr_SetString ( BossError, e.what() );
5579	>	return NULL;
5580		}
5581		}
5582		resultobj = PyInt_FromLong((long)result);
#	Line 5163 | Line 5610 | static PyObject *_wrap_BossAdministrator
5610		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5611
5612		}catch (const BossSchedFailure & e) {
5613	<	SWIG_exception(SWIG_ValueError, e.what());
5613	>	PyErr_SetString ( SchedulerError, e.what() );
5614	>	return NULL;
5615		}catch (const std::exception& e) {
5616	<	SWIG_exception(SWIG_RuntimeError, e.what());
5616	>	PyErr_SetString ( BossError, e.what() );
5617	>	return NULL;
5618		}
5619		}
5620		resultobj = PyInt_FromLong((long)result);
#	Line 5199 | Line 5648 | static PyObject *_wrap_BossAdministrator
5648		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5649
5650		}catch (const BossSchedFailure & e) {
5651	<	SWIG_exception(SWIG_ValueError, e.what());
5651	>	PyErr_SetString ( SchedulerError, e.what() );
5652	>	return NULL;
5653		}catch (const std::exception& e) {
5654	<	SWIG_exception(SWIG_RuntimeError, e.what());
5654	>	PyErr_SetString ( BossError, e.what() );
5655	>	return NULL;
5656		}
5657		}
5658		resultobj = PyInt_FromLong((long)result);
#	Line 5235 | Line 5686 | static PyObject *_wrap_BossAdministrator
5686		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5687
5688		}catch (const BossSchedFailure & e) {
5689	<	SWIG_exception(SWIG_ValueError, e.what());
5689	>	PyErr_SetString ( SchedulerError, e.what() );
5690	>	return NULL;
5691		}catch (const std::exception& e) {
5692	<	SWIG_exception(SWIG_RuntimeError, e.what());
5692	>	PyErr_SetString ( BossError, e.what() );
5693	>	return NULL;
5694		}
5695		}
5696		resultobj = PyInt_FromLong((long)result);
#	Line 5271 | Line 5724 | static PyObject *_wrap_BossAdministrator
5724		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5725
5726		}catch (const BossSchedFailure & e) {
5727	<	SWIG_exception(SWIG_ValueError, e.what());
5727	>	PyErr_SetString ( SchedulerError, e.what() );
5728	>	return NULL;
5729		}catch (const std::exception& e) {
5730	<	SWIG_exception(SWIG_RuntimeError, e.what());
5730	>	PyErr_SetString ( BossError, e.what() );
5731	>	return NULL;
5732		}
5733		}
5734		resultobj = PyInt_FromLong((long)result);
#	Line 5307 | Line 5762 | static PyObject *_wrap_BossAdministrator
5762		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5763
5764		}catch (const BossSchedFailure & e) {
5765	<	SWIG_exception(SWIG_ValueError, e.what());
5765	>	PyErr_SetString ( SchedulerError, e.what() );
5766	>	return NULL;
5767		}catch (const std::exception& e) {
5768	<	SWIG_exception(SWIG_RuntimeError, e.what());
5768	>	PyErr_SetString ( BossError, e.what() );
5769	>	return NULL;
5770		}
5771		}
5772		resultobj = PyInt_FromLong((long)result);
#	Line 5375 | Line 5832 | static PyObject *_wrap_BossAdministrator
5832		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5833
5834		}catch (const BossSchedFailure & e) {
5835	<	SWIG_exception(SWIG_ValueError, e.what());
5835	>	PyErr_SetString ( SchedulerError, e.what() );
5836	>	return NULL;
5837		}catch (const std::exception& e) {
5838	<	SWIG_exception(SWIG_RuntimeError, e.what());
5838	>	PyErr_SetString ( BossError, e.what() );
5839	>	return NULL;
5840		}
5841		}
5842		resultobj = PyInt_FromLong((long)result);
#	Line 5467 | Line 5926 | static PyObject *_wrap_BossAdministrator
5926		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5927
5928		}catch (const BossSchedFailure & e) {
5929	<	SWIG_exception(SWIG_ValueError, e.what());
5929	>	PyErr_SetString ( SchedulerError, e.what() );
5930	>	return NULL;
5931		}catch (const std::exception& e) {
5932	<	SWIG_exception(SWIG_RuntimeError, e.what());
5932	>	PyErr_SetString ( BossError, e.what() );
5933	>	return NULL;
5934		}
5935		}
5936		resultobj = PyInt_FromLong((long)result);
#	Line 5545 | Line 6006 | static PyObject *_wrap_BossAdministrator
6006		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
6007
6008		}catch (const BossSchedFailure & e) {
6009	<	SWIG_exception(SWIG_ValueError, e.what());
6009	>	PyErr_SetString ( SchedulerError, e.what() );
6010	>	return NULL;
6011		}catch (const std::exception& e) {
6012	<	SWIG_exception(SWIG_RuntimeError, e.what());
6012	>	PyErr_SetString ( BossError, e.what() );
6013	>	return NULL;
6014		}
6015		}
6016		resultobj = PyInt_FromLong((long)result);
#	Line 5719 | Line 6182 | static PyObject *_wrap_BossAdministrator
6182		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);
6183
6184		}catch (const BossSchedFailure & e) {
6185	<	SWIG_exception(SWIG_ValueError, e.what());
6185	>	PyErr_SetString ( SchedulerError, e.what() );
6186	>	return NULL;
6187		}catch (const std::exception& e) {
6188	<	SWIG_exception(SWIG_RuntimeError, e.what());
6188	>	PyErr_SetString ( BossError, e.what() );
6189	>	return NULL;
6190		}
6191		}
6192		resultobj = PyInt_FromLong((long)result);
#	Line 5744 | Line 6209 | static PyObject *_wrap_BossAdministrator
6209		result = (arg1)->help();
6210
6211		}catch (const BossSchedFailure & e) {
6212	<	SWIG_exception(SWIG_ValueError, e.what());
6212	>	PyErr_SetString ( SchedulerError, e.what() );
6213	>	return NULL;
6214		}catch (const std::exception& e) {
6215	<	SWIG_exception(SWIG_RuntimeError, e.what());
6215	>	PyErr_SetString ( BossError, e.what() );
6216	>	return NULL;
6217		}
6218		}
6219		{
#	Line 5785 | Line 6252 | static PyObject *_wrap_BossAdministrator
6252		result = (arg1)->SQL(arg2,arg3);
6253
6254		}catch (const BossSchedFailure & e) {
6255	<	SWIG_exception(SWIG_ValueError, e.what());
6255	>	PyErr_SetString ( SchedulerError, e.what() );
6256	>	return NULL;
6257		}catch (const std::exception& e) {
6258	<	SWIG_exception(SWIG_RuntimeError, e.what());
6258	>	PyErr_SetString ( BossError, e.what() );
6259	>	return NULL;
6260		}
6261		}
6262		{
#	Line 5859 | Line 6328 | static PyObject *_wrap_BossAdministrator
6328		result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6329
6330		}catch (const BossSchedFailure & e) {
6331	<	SWIG_exception(SWIG_ValueError, e.what());
6331	>	PyErr_SetString ( SchedulerError, e.what() );
6332	>	return NULL;
6333		}catch (const std::exception& e) {
6334	<	SWIG_exception(SWIG_RuntimeError, e.what());
6334	>	PyErr_SetString ( BossError, e.what() );
6335	>	return NULL;
6336		}
6337		}
6338		resultobj = PyInt_FromLong((long)result);
#	Line 5892 | Line 6363 | static PyObject *_wrap_BossAdministrator
6363		result = (int)(arg1)->registerPlugins(arg2);
6364
6365		}catch (const BossSchedFailure & e) {
6366	<	SWIG_exception(SWIG_ValueError, e.what());
6366	>	PyErr_SetString ( SchedulerError, e.what() );
6367	>	return NULL;
6368		}catch (const std::exception& e) {
6369	<	SWIG_exception(SWIG_RuntimeError, e.what());
6369	>	PyErr_SetString ( BossError, e.what() );
6370	>	return NULL;
6371		}
6372		}
6373		resultobj = PyInt_FromLong((long)result);
#	Line 5941 | Line 6414 | static PyMethodDef SwigMethods[] = {
6414		{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6415		{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6416		{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5944	–	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5945	–	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5946	–	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5947	–	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5948	–	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5949	–	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5950	–	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6417		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6418		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6419		{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6420		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6421		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6422		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6423	+	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6424	+	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6425	+	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6426	+	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6427		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6428		{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6429		{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
#	Line 5965 | Line 6435 | static PyMethodDef SwigMethods[] = {
6435		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6436		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6437		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6438	+	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
6439		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6440	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
6441	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6442	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6443	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6444	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6445	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6446	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6447	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6448		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6449		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6450		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5973 | Line 6452 | static PyMethodDef SwigMethods[] = {
6452		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6453		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6454		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5976	–	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5977	–	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5978	–	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
5979	–	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5980	–	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6455		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6456		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6457		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
#	Line 5996 | Line 6470 | static PyMethodDef SwigMethods[] = {
6470		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6471		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6472		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6473	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
6474		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6475		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6476		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6477		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6478	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6479	+	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6480	+	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6481	+	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6482	+	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6483		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6484		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6485		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 6024 | Line 6504 | static PyMethodDef SwigMethods[] = {
6504
6505		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6506
6507	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6508		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}};
6509		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}};
6029	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6510		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}};
6511		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}};
6512	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6513		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6514		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
6034	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6035	–	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6515		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6516	+	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6517		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6518		static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6519		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6520		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}};
6521		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}};
6522		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
6043	–	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}};
6523		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}};
6524	+	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}};
6525		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6526
6527		static swig_type_info *swig_types_initial[] = {
6528	+	_swigt__p_XMLDoc,
6529		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6530		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6050	–	_swigt__p_XMLDoc,
6531		_swigt__p_std__vectorTBossTask_p_t,
6532		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6533	+	_swigt__p_std__ostream,
6534		_swigt__p_BossTask,
6535		_swigt__p_BossTaskException,
6055	–	_swigt__p_std__ostream,
6056	–	_swigt__p_BossAttributeContainer,
6536		_swigt__p_printOption,
6537	+	_swigt__p_BossAttributeContainer,
6538		_swigt__p_BossJob,
6539		_swigt__p_BossDatabase,
6540		_swigt__p_BossSession,
6541		_swigt__p_std__vectorTstd__string_t,
6542		_swigt__p_std__mapTstd__string_std__string_t,
6543		_swigt__p_BossAdministratorSession,
6064	–	_swigt__p_BossTask__job_iterator,
6544		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6545	+	_swigt__p_BossTask__job_iterator,
6546		_swigt__p_jobStates,
6547		0
6548		};
#	Line 6106 | Line 6586 | SWIGEXPORT(void) SWIG_init(void) {
6586		}
6587		SWIG_InstallConstants(d,swig_const_table);
6588
6589	+
6590	+	// define custom exceptions
6591	+	PyObject *e;
6592	+	PyMethodDef tp_methods = {
6593	+	NULL, NULL, 0, NULL
6594	+	};
6595	+	e = Py_InitModule("BossSession", &tp_methods);
6596	+	// generic BOSS exception
6597	+	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6598	+	Py_INCREF(BossError);
6599	+	PyModule_AddObject(e, "BossError", BossError);
6600	+	// scheduler interaction BOSS exception
6601	+	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6602	+	Py_INCREF(SchedulerError);
6603	+	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6604	+
6605		}
6606

Diff Legend

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