ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.7 by gcodispo, Fri Oct 27 13:36:09 2006 UTC vs.
Revision 1.18 by gcodispo, Mon Dec 11 09:16:06 2006 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_XMLDoc swig_types[0]
658	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
659	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660	<	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[3]
661	<	#define  SWIGTYPE_p_BossTask swig_types[4]
662	<	#define  SWIGTYPE_p_BossTaskException swig_types[5]
663	<	#define  SWIGTYPE_p_std__ostream swig_types[6]
664	<	#define  SWIGTYPE_p_BossAttributeContainer swig_types[7]
665	<	#define  SWIGTYPE_p_printOption swig_types[8]
666	<	#define  SWIGTYPE_p_BossJob swig_types[9]
667	<	#define  SWIGTYPE_p_BossDatabase swig_types[10]
668	<	#define  SWIGTYPE_p_BossSession swig_types[11]
669	<	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[12]
670	<	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[13]
671	<	#define  SWIGTYPE_p_BossAdministratorSession swig_types[14]
672	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[15]
673	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	<	#define  SWIGTYPE_p_jobStates swig_types[17]
675	<	static swig_type_info *swig_types[19];
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]
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]
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]
675	>	#define  SWIGTYPE_p_jobStates swig_types[18]
676	>	static swig_type_info *swig_types[20];
677
678		/* -------- TYPES TABLE (END) -------- */
679
#	Line 850 | Line 851 | PyObject *std_maplstd_stringcstd_string_
851		" for iterator support");
852		#endif
853		}
854	+	std::string std_vectorlstd_string_g_pop___(std::vector<std::string > *self){
855	+	if (self->size() == 0)
856	+	throw std::out_of_range("pop from empty vector");
857	+	std::string x = self->back();
858	+	self->pop_back();
859	+	return x;
860	+	}
861	+	std::string std_vectorlstd_string_g___getitem_____(std::vector<std::string > *self,int i){
862	+	int size = int(self->size());
863	+	if (i<0) i += size;
864	+	if (i>=0 && i<size)
865	+	return (*self)[i];
866	+	else
867	+	throw std::out_of_range("vector index out of range");
868	+	}
869	+	std::vector<std::string > std_vectorlstd_string_g___getslice_____(std::vector<std::string > *self,int i,int j){
870	+	int size = int(self->size());
871	+	if (i<0) i = size+i;
872	+	if (j<0) j = size+j;
873	+	if (i<0) i = 0;
874	+	if (j>size) j = size;
875	+	std::vector<std::string > tmp(j-i);
876	+	std::copy(self->begin()+i,self->begin()+j,tmp.begin());
877	+	return tmp;
878	+	}
879	+	void std_vectorlstd_string_g___setitem_____(std::vector<std::string > *self,int i,std::string x){
880	+	int size = int(self->size());
881	+	if (i<0) i+= size;
882	+	if (i>=0 && i<size)
883	+	(*self)[i] = x;
884	+	else
885	+	throw std::out_of_range("vector index out of range");
886	+	}
887	+	void std_vectorlstd_string_g___setslice_____(std::vector<std::string > *self,int i,int j,std::vector<std::string > const &v){
888	+	int size = int(self->size());
889	+	if (i<0) i = size+i;
890	+	if (j<0) j = size+j;
891	+	if (i<0) i = 0;
892	+	if (j>size) j = size;
893	+	if (int(v.size()) == j-i) {
894	+	std::copy(v.begin(),v.end(),self->begin()+i);
895	+	} else {
896	+	self->erase(self->begin()+i,self->begin()+j);
897	+	if (i+1 <= int(self->size()))
898	+	self->insert(self->begin()+i,v.begin(),v.end());
899	+	else
900	+	self->insert(self->end(),v.begin(),v.end());
901	+	}
902	+	}
903	+	void std_vectorlstd_string_g___delitem_____(std::vector<std::string > *self,int i){
904	+	int size = int(self->size());
905	+	if (i<0) i+= size;
906	+	if (i>=0 && i<size)
907	+	self->erase(self->begin()+i);
908	+	else
909	+	throw std::out_of_range("vector index out of range");
910	+	}
911	+	void std_vectorlstd_string_g___delslice_____(std::vector<std::string > *self,int i,int j){
912	+	int size = int(self->size());
913	+	if (i<0) i = size+i;
914	+	if (j<0) j = size+j;
915	+	if (i<0) i = 0;
916	+	if (j>size) j = size;
917	+	self->erase(self->begin()+i,self->begin()+j);
918	+	}
919
920		#include "BossSession.h"
921		#include "BossAdministratorSession.h"
#	Line 861 | Line 927 | PyObject *std_maplstd_stringcstd_string_
927		#include "BossProgram.h"
928		#include "BossProgramExec.h"
929		#include "BossDatabase.h"
930	+	#include "BossScheduler.h"
931
932		PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
933		PyObject *  my_list = PyList_New( my_vec.size());
#	Line 871 | Line 938 | PyObject *BossSession_show(BossSession *
938		}
939		return my_list;
940		}
941	<	PyObject *BossSession_showCHTools__SWIG_1(BossSession *self){
941	>	PyObject *BossSession_CHTools(BossSession *self){
942		std::vector<std::string> my_vec = self->showCHTools();
943		return BossSession_show( self, my_vec );
944		}
945	<	PyObject *BossSession_showProgramTypes__SWIG_1(BossSession *self){
945	>	PyObject *BossSession_ProgramTypes(BossSession *self){
946		std::vector<std::string> my_vec = self->showProgramTypes();
947		return BossSession_show( self, my_vec );
948		}
949	<	PyObject *BossSession_showRTMon__SWIG_1(BossSession *self){
949	>	PyObject *BossSession_RTMons(BossSession *self){
950		std::vector<std::string> my_vec = self->showRTMon();
951		return BossSession_show( self, my_vec );
952		}
953	<	PyObject *BossSession_showSchedulers__SWIG_1(BossSession *self){
953	>	PyObject *BossSession_schedulers(BossSession *self){
954		std::vector<std::string> my_vec = self->showSchedulers();
955		return BossSession_show( self, my_vec );
956		}
957	+	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
958	+	std::vector<std::string> my_vec = self->listMatch( scheduler,
959	+	schclassad,
960	+	keepfile,
961	+	taskid,
962	+	jobid);
963	+	return BossSession_show( self, my_vec );
964	+	}
965		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){
966		if ( !avoidCheck ) {
967		self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
#	Line 899 | Line 974 | PyObject *BossSession_queryTasks(BossSes
974		it!= taskList.end(); ++it ) {
975		PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
976		}
902	–
903	–	//       int size = taskList.size();
904	–	//       PyObject * job_dict = PyList_New(0);
905	–	//       for ( unsigned int i = 0; i < size; ++i ) {
906	–	//      PyList_SetItem(job_dict,i, );
907	–	//      self->makeBossTask( *it );
908	–	//       }
977		return  job_dict;
978		}
979		PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
#	Line 945 | Line 1013 | PyObject *BossTask_jobDict(BossTask cons
1013		}
1014		return job_dict;
1015		}
1016	<	PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
1016	>	PyObject *BossTask_jobsDict(BossTask *self){
1017
1018		PyObject * job_dict = PyDict_New();
1019	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1020		for (BossTask::job_iterator jit = self->job_begin ();
1021		jit != self->job_end (); ++jit) {
1022		std::string id = (*jit)->chainId();
#	Line 1016 | Line 1085 | static PyObject *_wrap_new_objectMap__SW
1085		try {
1086		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1087
1088	+	}catch (const BossSchedFailure & e) {
1089	+	SWIG_exception(SWIG_ValueError, e.what());
1090		}catch (const std::exception& e) {
1091		SWIG_exception(SWIG_RuntimeError, e.what());
1092		}
#	Line 1075 | Line 1146 | static PyObject *_wrap_new_objectMap__SW
1146		try {
1147		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1148
1149	+	}catch (const BossSchedFailure & e) {
1150	+	SWIG_exception(SWIG_ValueError, e.what());
1151		}catch (const std::exception& e) {
1152		SWIG_exception(SWIG_RuntimeError, e.what());
1153		}
#	Line 1190 | Line 1263 | static PyObject *_wrap_objectMap___len__
1263		try {
1264		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1265
1266	+	}catch (const BossSchedFailure & e) {
1267	+	SWIG_exception(SWIG_ValueError, e.what());
1268		}catch (const std::exception& e) {
1269		SWIG_exception(SWIG_RuntimeError, e.what());
1270		}
#	Line 1212 | Line 1287 | static PyObject *_wrap_objectMap_clear(P
1287		try {
1288		(arg1)->clear();
1289
1290	+	}catch (const BossSchedFailure & e) {
1291	+	SWIG_exception(SWIG_ValueError, e.what());
1292		}catch (const std::exception& e) {
1293		SWIG_exception(SWIG_RuntimeError, e.what());
1294		}
#	Line 1235 | Line 1312 | static PyObject *_wrap_objectMap___nonze
1312		try {
1313		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1314
1315	+	}catch (const BossSchedFailure & e) {
1316	+	SWIG_exception(SWIG_ValueError, e.what());
1317		}catch (const std::exception& e) {
1318		SWIG_exception(SWIG_RuntimeError, e.what());
1319		}
#	Line 1307 | Line 1386 | static PyObject *_wrap_objectMap___setit
1386		try {
1387		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1388
1389	+	}catch (const BossSchedFailure & e) {
1390	+	SWIG_exception(SWIG_ValueError, e.what());
1391		}catch (const std::exception& e) {
1392		SWIG_exception(SWIG_RuntimeError, e.what());
1393		}
#	Line 1369 | Line 1450 | static PyObject *_wrap_objectMap_has_key
1450		try {
1451		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1452
1453	+	}catch (const BossSchedFailure & e) {
1454	+	SWIG_exception(SWIG_ValueError, e.what());
1455		}catch (const std::exception& e) {
1456		SWIG_exception(SWIG_RuntimeError, e.what());
1457		}
#	Line 1392 | Line 1475 | static PyObject *_wrap_objectMap_keys(Py
1475		try {
1476		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1477
1478	+	}catch (const BossSchedFailure & e) {
1479	+	SWIG_exception(SWIG_ValueError, e.what());
1480		}catch (const std::exception& e) {
1481		SWIG_exception(SWIG_RuntimeError, e.what());
1482		}
#	Line 1415 | Line 1500 | static PyObject *_wrap_objectMap_values(
1500		try {
1501		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1502
1503	+	}catch (const BossSchedFailure & e) {
1504	+	SWIG_exception(SWIG_ValueError, e.what());
1505		}catch (const std::exception& e) {
1506		SWIG_exception(SWIG_RuntimeError, e.what());
1507		}
#	Line 1438 | Line 1525 | static PyObject *_wrap_objectMap_items(P
1525		try {
1526		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1527
1528	+	}catch (const BossSchedFailure & e) {
1529	+	SWIG_exception(SWIG_ValueError, e.what());
1530		}catch (const std::exception& e) {
1531		SWIG_exception(SWIG_RuntimeError, e.what());
1532		}
#	Line 1469 | Line 1558 | static PyObject *_wrap_objectMap___conta
1558		try {
1559		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1560
1561	+	}catch (const BossSchedFailure & e) {
1562	+	SWIG_exception(SWIG_ValueError, e.what());
1563		}catch (const std::exception& e) {
1564		SWIG_exception(SWIG_RuntimeError, e.what());
1565		}
#	Line 1515 | Line 1606 | static PyObject *_wrap_delete_objectMap(
1606		try {
1607		delete arg1;
1608
1609	+	}catch (const BossSchedFailure & e) {
1610	+	SWIG_exception(SWIG_ValueError, e.what());
1611		}catch (const std::exception& e) {
1612		SWIG_exception(SWIG_RuntimeError, e.what());
1613		}
#	Line 1533 | Line 1626 | static PyObject * objectMap_swigregister
1626		Py_INCREF(obj);
1627		return Py_BuildValue((char *)"");
1628		}
1629	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
1629	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1630		PyObject *resultobj;
1631	<	BossSession *arg1 = (BossSession *) 0 ;
1632	<	std::vector<std::string > *arg2 = 0 ;
1633	<	PyObject *result;
1631	>	unsigned int arg1 = (unsigned int) 0 ;
1632	>	std::vector<std::string > *result;
1633	>	PyObject * obj0 = 0 ;
1634	>
1635	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1636	>	if (obj0) {
1637	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1638	>	if (PyErr_Occurred()) SWIG_fail;
1639	>	}
1640	>	{
1641	>	try {
1642	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1643	>
1644	>	}catch (const BossSchedFailure & e) {
1645	>	SWIG_exception(SWIG_ValueError, e.what());
1646	>	}catch (const std::exception& e) {
1647	>	SWIG_exception(SWIG_RuntimeError, e.what());
1648	>	}
1649	>	}
1650	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1651	>	return resultobj;
1652	>	fail:
1653	>	return NULL;
1654	>	}
1655	>
1656	>
1657	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1658	>	PyObject *resultobj;
1659	>	unsigned int arg1 ;
1660	>	std::string *arg2 = 0 ;
1661	>	std::vector<std::string > *result;
1662	>	std::string temp2 ;
1663		PyObject * obj0 = 0 ;
1664		PyObject * obj1 = 0 ;
1665
1666	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
1667	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1668	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1669	<	if (arg2 == NULL) {
1670	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
1666	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1667	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1668	>	if (PyErr_Occurred()) SWIG_fail;
1669	>	{
1670	>	if (PyString_Check(obj1)) {
1671	>	temp2 = std::string(PyString_AsString(obj1));
1672	>	arg2 = &temp2;
1673	>	}else {
1674	>	SWIG_exception(SWIG_TypeError, "string expected");
1675	>	}
1676		}
1677		{
1678		try {
1679	<	result = (PyObject *)BossSession_show(arg1,*arg2);
1679	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1680
1681	+	}catch (const BossSchedFailure & e) {
1682	+	SWIG_exception(SWIG_ValueError, e.what());
1683		}catch (const std::exception& e) {
1684		SWIG_exception(SWIG_RuntimeError, e.what());
1685		}
1686		}
1687	<	resultobj = result;
1687	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1688		return resultobj;
1689		fail:
1690		return NULL;
1691		}
1692
1693
1694	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_1(PyObject *self, PyObject *args) {
1694	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1695		PyObject *resultobj;
1696	<	BossSession *arg1 = (BossSession *) 0 ;
1697	<	PyObject *result;
1696	>	std::vector<std::string > *arg1 = 0 ;
1697	>	std::vector<std::string > *result;
1698	>	std::vector<std::string > temp1 ;
1699	>	std::vector<std::string > *v1 ;
1700		PyObject * obj0 = 0 ;
1701
1702	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
1703	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1702	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1703	>	{
1704	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1705	>	unsigned int size = (PyTuple_Check(obj0) ?
1706	>	PyTuple_Size(obj0) :
1707	>	PyList_Size(obj0));
1708	>	temp1 = std::vector<std::string >(size);
1709	>	arg1 = &temp1;
1710	>	for (unsigned int i=0; i<size; i++) {
1711	>	PyObject* o = PySequence_GetItem(obj0,i);
1712	>	if (PyString_Check(o)) {
1713	>	temp1[i] = (std::string)(\
1714	>	SwigString_AsString(o));
1715	>	Py_DECREF(o);
1716	>	}else {
1717	>	Py_DECREF(o);
1718	>	PyErr_SetString(PyExc_TypeError,
1719	>	"vector<""std::string""> expected");
1720	>	SWIG_fail;
1721	>	}
1722	>	}
1723	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1724	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1725	>	arg1 = v1;
1726	>	}else {
1727	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1728	>	SWIG_fail;
1729	>	}
1730	>	}
1731		{
1732		try {
1733	<	result = (PyObject *)BossSession_showCHTools__SWIG_1(arg1);
1733	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1734
1735	+	}catch (const BossSchedFailure & e) {
1736	+	SWIG_exception(SWIG_ValueError, e.what());
1737		}catch (const std::exception& e) {
1738		SWIG_exception(SWIG_RuntimeError, e.what());
1739		}
1740		}
1741	<	resultobj = result;
1741	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1742		return resultobj;
1743		fail:
1744		return NULL;
1745		}
1746
1747
1748	<	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
1748	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1749		int argc;
1750	<	PyObject *argv[2];
1750	>	PyObject *argv[3];
1751		int ii;
1752
1753		argc = PyObject_Length(args);
1754	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1754	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1755		argv[ii] = PyTuple_GetItem(args,ii);
1756		}
1757	+	if ((argc >= 0) && (argc <= 1)) {
1758	+	int _v;
1759	+	if (argc <= 0) {
1760	+	return _wrap_new_vector_string__SWIG_0(self,args);
1761	+	}
1762	+	{
1763	+	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1764	+	}
1765	+	if (_v) {
1766	+	return _wrap_new_vector_string__SWIG_0(self,args);
1767	+	}
1768	+	}
1769		if (argc == 1) {
1770		int _v;
1771		{
1772	<	void *ptr;
1773	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1774	<	_v = 0;
1775	<	PyErr_Clear();
1772	>	/* native sequence? */
1773	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1774	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1775	>	PyTuple_Size(argv[0]) :
1776	>	PyList_Size(argv[0]));
1777	>	if (size == 0) {
1778	>	/* an empty sequence can be of any type */
1779	>	_v = 1;
1780	>	}else {
1781	>	/* check the first element only */
1782	>	PyObject* o = PySequence_GetItem(argv[0],0);
1783	>	if (PyString_Check(o))
1784	>	_v = 1;
1785	>	else
1786	>	_v = 0;
1787	>	Py_DECREF(o);
1788	>	}
1789		}else {
1790	+	/* wrapped vector? */
1791	+	std::vector<std::string >* v;
1792	+	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1793	+	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1794		_v = 1;
1795	+	else
1796	+	_v = 0;
1797		}
1798		}
1799		if (_v) {
1800	<	return _wrap_BossSession_showCHTools__SWIG_1(self,args);
1800	>	return _wrap_new_vector_string__SWIG_2(self,args);
1801	>	}
1802	>	}
1803	>	if (argc == 2) {
1804	>	int _v;
1805	>	{
1806	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1807	>	}
1808	>	if (_v) {
1809	>	{
1810	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1811	>	}
1812	>	if (_v) {
1813	>	return _wrap_new_vector_string__SWIG_1(self,args);
1814	>	}
1815		}
1816		}
1817
1818	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showCHTools'");
1818	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1819		return NULL;
1820		}
1821
1822
1823	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_1(PyObject *self, PyObject *args) {
1823	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1824		PyObject *resultobj;
1825	<	BossSession *arg1 = (BossSession *) 0 ;
1826	<	PyObject *result;
1825	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1826	>	unsigned int result;
1827	>	std::vector<std::string > temp1 ;
1828	>	std::vector<std::string > *v1 ;
1829		PyObject * obj0 = 0 ;
1830
1831	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
1832	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1831	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1832	>	{
1833	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1834	>	unsigned int size = (PyTuple_Check(obj0) ?
1835	>	PyTuple_Size(obj0) :
1836	>	PyList_Size(obj0));
1837	>	temp1 = std::vector<std::string >(size);
1838	>	arg1 = &temp1;
1839	>	for (unsigned int i=0; i<size; i++) {
1840	>	PyObject* o = PySequence_GetItem(obj0,i);
1841	>	if (PyString_Check(o)) {
1842	>	temp1[i] = (std::string)(\
1843	>	SwigString_AsString(o));
1844	>	Py_DECREF(o);
1845	>	}else {
1846	>	Py_DECREF(o);
1847	>	PyErr_SetString(PyExc_TypeError,
1848	>	"vector<""std::string""> expected");
1849	>	SWIG_fail;
1850	>	}
1851	>	}
1852	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1853	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1854	>	arg1 = v1;
1855	>	}else {
1856	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1857	>	SWIG_fail;
1858	>	}
1859	>	}
1860		{
1861		try {
1862	<	result = (PyObject *)BossSession_showProgramTypes__SWIG_1(arg1);
1862	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1863
1864	+	}catch (const BossSchedFailure & e) {
1865	+	SWIG_exception(SWIG_ValueError, e.what());
1866		}catch (const std::exception& e) {
1867		SWIG_exception(SWIG_RuntimeError, e.what());
1868		}
1869		}
1870	<	resultobj = result;
1870	>	resultobj = PyInt_FromLong((long)result);
1871		return resultobj;
1872		fail:
1873		return NULL;
1874		}
1875
1876
1877	<	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
1878	<	int argc;
1879	<	PyObject *argv[2];
1880	<	int ii;
1877	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1878	>	PyObject *resultobj;
1879	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1880	>	bool result;
1881	>	std::vector<std::string > temp1 ;
1882	>	std::vector<std::string > *v1 ;
1883	>	PyObject * obj0 = 0 ;
1884
1885	<	argc = PyObject_Length(args);
1886	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1887	<	argv[ii] = PyTuple_GetItem(args,ii);
1885	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1886	>	{
1887	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1888	>	unsigned int size = (PyTuple_Check(obj0) ?
1889	>	PyTuple_Size(obj0) :
1890	>	PyList_Size(obj0));
1891	>	temp1 = std::vector<std::string >(size);
1892	>	arg1 = &temp1;
1893	>	for (unsigned int i=0; i<size; i++) {
1894	>	PyObject* o = PySequence_GetItem(obj0,i);
1895	>	if (PyString_Check(o)) {
1896	>	temp1[i] = (std::string)(\
1897	>	SwigString_AsString(o));
1898	>	Py_DECREF(o);
1899	>	}else {
1900	>	Py_DECREF(o);
1901	>	PyErr_SetString(PyExc_TypeError,
1902	>	"vector<""std::string""> expected");
1903	>	SWIG_fail;
1904	>	}
1905	>	}
1906	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1907	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1908	>	arg1 = v1;
1909	>	}else {
1910	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1911	>	SWIG_fail;
1912	>	}
1913		}
1914	<	if (argc == 1) {
1915	<	int _v;
1916	<	{
1917	<	void *ptr;
1918	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1919	<	_v = 0;
1920	<	PyErr_Clear();
1921	<	}else {
1922	<	_v = 1;
1914	>	{
1915	>	try {
1916	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1917	>
1918	>	}catch (const BossSchedFailure & e) {
1919	>	SWIG_exception(SWIG_ValueError, e.what());
1920	>	}catch (const std::exception& e) {
1921	>	SWIG_exception(SWIG_RuntimeError, e.what());
1922	>	}
1923	>	}
1924	>	resultobj = PyInt_FromLong((long)result);
1925	>	return resultobj;
1926	>	fail:
1927	>	return NULL;
1928	>	}
1929	>
1930	>
1931	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1932	>	PyObject *resultobj;
1933	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1934	>	PyObject * obj0 = 0 ;
1935	>
1936	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1937	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1938	>	{
1939	>	try {
1940	>	(arg1)->clear();
1941	>
1942	>	}catch (const BossSchedFailure & e) {
1943	>	SWIG_exception(SWIG_ValueError, e.what());
1944	>	}catch (const std::exception& e) {
1945	>	SWIG_exception(SWIG_RuntimeError, e.what());
1946	>	}
1947	>	}
1948	>	Py_INCREF(Py_None); resultobj = Py_None;
1949	>	return resultobj;
1950	>	fail:
1951	>	return NULL;
1952	>	}
1953	>
1954	>
1955	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1956	>	PyObject *resultobj;
1957	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1958	>	std::string arg2 ;
1959	>	PyObject * obj0 = 0 ;
1960	>	PyObject * obj1 = 0 ;
1961	>
1962	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
1963	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1964	>	{
1965	>	if (PyString_Check(obj1))
1966	>	arg2 = std::string(PyString_AsString(obj1));
1967	>	else
1968	>	SWIG_exception(SWIG_TypeError, "string expected");
1969	>	}
1970	>	{
1971	>	try {
1972	>	(arg1)->push_back(arg2);
1973	>
1974	>	}catch (const BossSchedFailure & e) {
1975	>	SWIG_exception(SWIG_ValueError, e.what());
1976	>	}catch (const std::exception& e) {
1977	>	SWIG_exception(SWIG_RuntimeError, e.what());
1978	>	}
1979	>	}
1980	>	Py_INCREF(Py_None); resultobj = Py_None;
1981	>	return resultobj;
1982	>	fail:
1983	>	return NULL;
1984	>	}
1985	>
1986	>
1987	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
1988	>	PyObject *resultobj;
1989	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1990	>	std::string result;
1991	>	PyObject * obj0 = 0 ;
1992	>
1993	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
1994	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1995	>	{
1996	>	try {
1997	>	result = std_vectorlstd_string_g_pop___(arg1);
1998	>
1999	>	}catch (std::out_of_range& e) {
2000	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2001	>	}
2002	>	}
2003	>	{
2004	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2005	>	}
2006	>	return resultobj;
2007	>	fail:
2008	>	return NULL;
2009	>	}
2010	>
2011	>
2012	>	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
2013	>	PyObject *resultobj;
2014	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2015	>	int arg2 ;
2016	>	std::string result;
2017	>	PyObject * obj0 = 0 ;
2018	>
2019	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2020	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2021	>	{
2022	>	try {
2023	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2024	>
2025	>	}catch (std::out_of_range& e) {
2026	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2027	>	}
2028	>	}
2029	>	{
2030	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2031	>	}
2032	>	return resultobj;
2033	>	fail:
2034	>	return NULL;
2035	>	}
2036	>
2037	>
2038	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2039	>	PyObject *resultobj;
2040	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2041	>	int arg2 ;
2042	>	int arg3 ;
2043	>	std::vector<std::string > result;
2044	>	PyObject * obj0 = 0 ;
2045	>
2046	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2047	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2048	>	{
2049	>	try {
2050	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2051	>
2052	>	}catch (const BossSchedFailure & e) {
2053	>	SWIG_exception(SWIG_ValueError, e.what());
2054	>	}catch (const std::exception& e) {
2055	>	SWIG_exception(SWIG_RuntimeError, e.what());
2056	>	}
2057	>	}
2058	>	{
2059	>	resultobj = PyTuple_New((&result)->size());
2060	>	for (unsigned int i=0; i<(&result)->size(); i++)
2061	>	PyTuple_SetItem(resultobj,i,
2062	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2063	>	}
2064	>	return resultobj;
2065	>	fail:
2066	>	return NULL;
2067	>	}
2068	>
2069	>
2070	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2071	>	PyObject *resultobj;
2072	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2073	>	int arg2 ;
2074	>	std::string arg3 ;
2075	>	PyObject * obj0 = 0 ;
2076	>	PyObject * obj2 = 0 ;
2077	>
2078	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2079	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2080	>	{
2081	>	if (PyString_Check(obj2))
2082	>	arg3 = std::string(PyString_AsString(obj2));
2083	>	else
2084	>	SWIG_exception(SWIG_TypeError, "string expected");
2085	>	}
2086	>	{
2087	>	try {
2088	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2089	>
2090	>	}catch (std::out_of_range& e) {
2091	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2092	>	}
2093	>	}
2094	>	Py_INCREF(Py_None); resultobj = Py_None;
2095	>	return resultobj;
2096	>	fail:
2097	>	return NULL;
2098	>	}
2099	>
2100	>
2101	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2102	>	PyObject *resultobj;
2103	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2104	>	int arg2 ;
2105	>	int arg3 ;
2106	>	std::vector<std::string > *arg4 = 0 ;
2107	>	std::vector<std::string > temp4 ;
2108	>	std::vector<std::string > *v4 ;
2109	>	PyObject * obj0 = 0 ;
2110	>	PyObject * obj3 = 0 ;
2111	>
2112	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2113	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2114	>	{
2115	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2116	>	unsigned int size = (PyTuple_Check(obj3) ?
2117	>	PyTuple_Size(obj3) :
2118	>	PyList_Size(obj3));
2119	>	temp4 = std::vector<std::string >(size);
2120	>	arg4 = &temp4;
2121	>	for (unsigned int i=0; i<size; i++) {
2122	>	PyObject* o = PySequence_GetItem(obj3,i);
2123	>	if (PyString_Check(o)) {
2124	>	temp4[i] = (std::string)(\
2125	>	SwigString_AsString(o));
2126	>	Py_DECREF(o);
2127	>	}else {
2128	>	Py_DECREF(o);
2129	>	PyErr_SetString(PyExc_TypeError,
2130	>	"vector<""std::string""> expected");
2131	>	SWIG_fail;
2132	>	}
2133		}
2134	+	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2135	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2136	+	arg4 = v4;
2137	+	}else {
2138	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2139	+	SWIG_fail;
2140		}
2141	<	if (_v) {
2142	<	return _wrap_BossSession_showProgramTypes__SWIG_1(self,args);
2141	>	}
2142	>	{
2143	>	try {
2144	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2145	>
2146	>	}catch (const BossSchedFailure & e) {
2147	>	SWIG_exception(SWIG_ValueError, e.what());
2148	>	}catch (const std::exception& e) {
2149	>	SWIG_exception(SWIG_RuntimeError, e.what());
2150	>	}
2151	>	}
2152	>	Py_INCREF(Py_None); resultobj = Py_None;
2153	>	return resultobj;
2154	>	fail:
2155	>	return NULL;
2156	>	}
2157	>
2158	>
2159	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2160	>	PyObject *resultobj;
2161	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2162	>	int arg2 ;
2163	>	PyObject * obj0 = 0 ;
2164	>
2165	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2166	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2167	>	{
2168	>	try {
2169	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2170	>
2171	>	}catch (std::out_of_range& e) {
2172	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2173		}
2174		}
2175	+	Py_INCREF(Py_None); resultobj = Py_None;
2176	+	return resultobj;
2177	+	fail:
2178	+	return NULL;
2179	+	}
2180	+
2181	+
2182	+	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2183	+	PyObject *resultobj;
2184	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2185	+	int arg2 ;
2186	+	int arg3 ;
2187	+	PyObject * obj0 = 0 ;
2188
2189	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showProgramTypes'");
2189	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2190	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2191	>	{
2192	>	try {
2193	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2194	>
2195	>	}catch (const BossSchedFailure & e) {
2196	>	SWIG_exception(SWIG_ValueError, e.what());
2197	>	}catch (const std::exception& e) {
2198	>	SWIG_exception(SWIG_RuntimeError, e.what());
2199	>	}
2200	>	}
2201	>	Py_INCREF(Py_None); resultobj = Py_None;
2202	>	return resultobj;
2203	>	fail:
2204		return NULL;
2205		}
2206
2207
2208	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_1(PyObject *self, PyObject *args) {
2208	>	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2209	>	PyObject *resultobj;
2210	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2211	>	PyObject * obj0 = 0 ;
2212	>
2213	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2214	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2215	>	{
2216	>	try {
2217	>	delete arg1;
2218	>
2219	>	}catch (const BossSchedFailure & e) {
2220	>	SWIG_exception(SWIG_ValueError, e.what());
2221	>	}catch (const std::exception& e) {
2222	>	SWIG_exception(SWIG_RuntimeError, e.what());
2223	>	}
2224	>	}
2225	>	Py_INCREF(Py_None); resultobj = Py_None;
2226	>	return resultobj;
2227	>	fail:
2228	>	return NULL;
2229	>	}
2230	>
2231	>
2232	>	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2233	>	PyObject *obj;
2234	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2235	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2236	>	Py_INCREF(obj);
2237	>	return Py_BuildValue((char *)"");
2238	>	}
2239	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
2240		PyObject *resultobj;
2241		BossSession *arg1 = (BossSession *) 0 ;
2242	+	std::vector<std::string > *arg2 = 0 ;
2243		PyObject *result;
2244		PyObject * obj0 = 0 ;
2245	+	PyObject * obj1 = 0 ;
2246
2247	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2247	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2248		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2249	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2250	+	if (arg2 == NULL) {
2251	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2252	+	}
2253		{
2254		try {
2255	<	result = (PyObject *)BossSession_showRTMon__SWIG_1(arg1);
2255	>	result = (PyObject *)BossSession_show(arg1,*arg2);
2256
2257	+	}catch (const BossSchedFailure & e) {
2258	+	SWIG_exception(SWIG_ValueError, e.what());
2259		}catch (const std::exception& e) {
2260		SWIG_exception(SWIG_RuntimeError, e.what());
2261		}
#	Line 1691 | Line 2267 | static PyObject *_wrap_BossSession_showR
2267		}
2268
2269
2270	<	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2271	<	int argc;
2272	<	PyObject *argv[2];
2273	<	int ii;
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	<	argc = PyObject_Length(args);
2277	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2278	<	argv[ii] = PyTuple_GetItem(args,ii);
2279	<	}
2280	<	if (argc == 1) {
2281	<	int _v;
2282	<	{
2283	<	void *ptr;
2284	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2285	<	_v = 0;
1709	<	PyErr_Clear();
1710	<	}else {
1711	<	_v = 1;
1712	<	}
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;
2278	>	{
2279	>	try {
2280	>	result = (PyObject *)BossSession_CHTools(arg1);
2281	>
2282	>	}catch (const BossSchedFailure & e) {
2283	>	SWIG_exception(SWIG_ValueError, e.what());
2284	>	}catch (const std::exception& e) {
2285	>	SWIG_exception(SWIG_RuntimeError, e.what());
2286		}
2287	<	if (_v) {
2288	<	return _wrap_BossSession_showRTMon__SWIG_1(self,args);
2287	>	}
2288	>	resultobj = result;
2289	>	return resultobj;
2290	>	fail:
2291	>	return NULL;
2292	>	}
2293	>
2294	>
2295	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
2296	>	PyObject *resultobj;
2297	>	BossSession *arg1 = (BossSession *) 0 ;
2298	>	PyObject *result;
2299	>	PyObject * obj0 = 0 ;
2300	>
2301	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2302	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2303	>	{
2304	>	try {
2305	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
2306	>
2307	>	}catch (const BossSchedFailure & e) {
2308	>	SWIG_exception(SWIG_ValueError, e.what());
2309	>	}catch (const std::exception& e) {
2310	>	SWIG_exception(SWIG_RuntimeError, e.what());
2311		}
2312		}
2313	+	resultobj = result;
2314	+	return resultobj;
2315	+	fail:
2316	+	return NULL;
2317	+	}
2318	+
2319	+
2320	+	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
2321	+	PyObject *resultobj;
2322	+	BossSession *arg1 = (BossSession *) 0 ;
2323	+	PyObject *result;
2324	+	PyObject * obj0 = 0 ;
2325
2326	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showRTMon'");
2326	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2327	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2328	>	{
2329	>	try {
2330	>	result = (PyObject *)BossSession_RTMons(arg1);
2331	>
2332	>	}catch (const BossSchedFailure & e) {
2333	>	SWIG_exception(SWIG_ValueError, e.what());
2334	>	}catch (const std::exception& e) {
2335	>	SWIG_exception(SWIG_RuntimeError, e.what());
2336	>	}
2337	>	}
2338	>	resultobj = result;
2339	>	return resultobj;
2340	>	fail:
2341		return NULL;
2342		}
2343
2344
2345	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_1(PyObject *self, PyObject *args) {
2345	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
2346		PyObject *resultobj;
2347		BossSession *arg1 = (BossSession *) 0 ;
2348		PyObject *result;
2349		PyObject * obj0 = 0 ;
2350
2351	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2351	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2352		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2353		{
2354		try {
2355	<	result = (PyObject *)BossSession_showSchedulers__SWIG_1(arg1);
2355	>	result = (PyObject *)BossSession_schedulers(arg1);
2356
2357	+	}catch (const BossSchedFailure & e) {
2358	+	SWIG_exception(SWIG_ValueError, e.what());
2359		}catch (const std::exception& e) {
2360		SWIG_exception(SWIG_RuntimeError, e.what());
2361		}
#	Line 1744 | Line 2367 | static PyObject *_wrap_BossSession_showS
2367		}
2368
2369
2370	<	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2371	<	int argc;
2372	<	PyObject *argv[2];
2373	<	int ii;
2370	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
2371	>	PyObject *resultobj;
2372	>	BossSession *arg1 = (BossSession *) 0 ;
2373	>	std::string *arg2 = 0 ;
2374	>	std::string *arg3 = 0 ;
2375	>	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;
2381	>	std::string temp2 ;
2382	>	std::string temp3 ;
2383	>	std::string temp4 ;
2384	>	std::string temp5 ;
2385	>	PyObject * obj0 = 0 ;
2386	>	PyObject * obj1 = 0 ;
2387	>	PyObject * obj2 = 0 ;
2388	>	PyObject * obj3 = 0 ;
2389	>	PyObject * obj4 = 0 ;
2390	>	PyObject * obj5 = 0 ;
2391
2392	<	argc = PyObject_Length(args);
2393	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2394	<	argv[ii] = PyTuple_GetItem(args,ii);
2392	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2393	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2394	>	{
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	<	if (argc == 1) {
2403	<	int _v;
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	<	void *ptr;
2413	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2414	<	_v = 0;
1762	<	PyErr_Clear();
2412	>	if (PyString_Check(obj3)) {
2413	>	temp4 = std::string(PyString_AsString(obj3));
2414	>	arg4 = &temp4;
2415		}else {
2416	<	_v = 1;
2416	>	SWIG_exception(SWIG_TypeError, "string expected");
2417		}
2418		}
2419	<	if (_v) {
2420	<	return _wrap_BossSession_showSchedulers__SWIG_1(self,args);
2419	>	}
2420	>	if (obj4) {
2421	>	{
2422	>	if (PyString_Check(obj4)) {
2423	>	temp5 = std::string(PyString_AsString(obj4));
2424	>	arg5 = &temp5;
2425	>	}else {
2426	>	SWIG_exception(SWIG_TypeError, "string expected");
2427	>	}
2428		}
2429		}
2430	<
2431	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showSchedulers'");
2430	>	if (obj5) {
2431	>	arg6 = PyInt_AsLong(obj5) ? true : false;
2432	>	if (PyErr_Occurred()) SWIG_fail;
2433	>	}
2434	>	{
2435	>	try {
2436	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
2437	>
2438	>	}catch (const BossSchedFailure & e) {
2439	>	SWIG_exception(SWIG_ValueError, e.what());
2440	>	}catch (const std::exception& e) {
2441	>	SWIG_exception(SWIG_RuntimeError, e.what());
2442	>	}
2443	>	}
2444	>	resultobj = result;
2445	>	return resultobj;
2446	>	fail:
2447		return NULL;
2448		}
2449
#	Line 1875 | Line 2549 | static PyObject *_wrap_BossSession_query
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		}
#	Line 1889 | Line 2565 | static PyObject *_wrap_BossSession_query
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;
2572		PyObject * obj0 = 0 ;
2573	+	PyObject * obj1 = 0 ;
2574	+	PyObject * obj2 = 0 ;
2575	+	PyObject * obj3 = 0 ;
2576
2577	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2577	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2578		if (obj0) {
2579		{
2580		if (PyString_Check(obj0))
#	Line 1901 | Line 2583 | static PyObject *_wrap_new_BossSession(P
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);
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		}
#	Line 1927 | Line 2635 | static PyObject *_wrap_delete_BossSessio
2635		try {
2636		delete arg1;
2637
2638	+	}catch (const BossSchedFailure & e) {
2639	+	SWIG_exception(SWIG_ValueError, e.what());
2640	+	}catch (const std::exception& e) {
2641	+	SWIG_exception(SWIG_RuntimeError, e.what());
2642	+	}
2643	+	}
2644	+	Py_INCREF(Py_None); resultobj = Py_None;
2645	+	return resultobj;
2646	+	fail:
2647	+	return NULL;
2648	+	}
2649	+
2650	+
2651	+	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2652	+	PyObject *resultobj;
2653	+	BossSession *arg1 = (BossSession *) 0 ;
2654	+	PyObject * obj0 = 0 ;
2655	+
2656	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2657	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2658	+	{
2659	+	try {
2660	+	(arg1)->resetDB();
2661	+
2662	+	}catch (const BossSchedFailure & e) {
2663	+	SWIG_exception(SWIG_ValueError, e.what());
2664		}catch (const std::exception& e) {
2665		SWIG_exception(SWIG_RuntimeError, e.what());
2666		}
#	Line 1949 | Line 2683 | static PyObject *_wrap_BossSession_clear
2683		try {
2684		(arg1)->clear();
2685
2686	+	}catch (const BossSchedFailure & e) {
2687	+	SWIG_exception(SWIG_ValueError, e.what());
2688		}catch (const std::exception& e) {
2689		SWIG_exception(SWIG_RuntimeError, e.what());
2690		}
#	Line 1986 | Line 2722 | static PyObject *_wrap_BossSession_makeB
2722		try {
2723		result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2724
2725	+	}catch (const BossSchedFailure & e) {
2726	+	SWIG_exception(SWIG_ValueError, e.what());
2727		}catch (const std::exception& e) {
2728		SWIG_exception(SWIG_RuntimeError, e.what());
2729		}
#	Line 2011 | Line 2749 | static PyObject *_wrap_BossSession_destr
2749		try {
2750		(arg1)->destroyBossTask(arg2);
2751
2752	+	}catch (const BossSchedFailure & e) {
2753	+	SWIG_exception(SWIG_ValueError, e.what());
2754		}catch (const std::exception& e) {
2755		SWIG_exception(SWIG_RuntimeError, e.what());
2756		}
#	Line 2022 | Line 2762 | static PyObject *_wrap_BossSession_destr
2762		}
2763
2764
2025	–	static PyObject *_wrap_BossSession_showCHTools__SWIG_0(PyObject *self, PyObject *args) {
2026	–	PyObject *resultobj;
2027	–	BossSession *arg1 = (BossSession *) 0 ;
2028	–	SwigValueWrapper< std::vector<std::string > > result;
2029	–	PyObject * obj0 = 0 ;
2030	–
2031	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2032	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2033	–	{
2034	–	try {
2035	–	result = (arg1)->showCHTools();
2036	–
2037	–	}catch (const std::exception& e) {
2038	–	SWIG_exception(SWIG_RuntimeError, e.what());
2039	–	}
2040	–	}
2041	–	{
2042	–	std::vector<std::string > * resultptr;
2043	–	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2044	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2045	–	}
2046	–	return resultobj;
2047	–	fail:
2048	–	return NULL;
2049	–	}
2050	–
2051	–
2052	–	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_0(PyObject *self, PyObject *args) {
2053	–	PyObject *resultobj;
2054	–	BossSession *arg1 = (BossSession *) 0 ;
2055	–	SwigValueWrapper< std::vector<std::string > > result;
2056	–	PyObject * obj0 = 0 ;
2057	–
2058	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2059	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2060	–	{
2061	–	try {
2062	–	result = (arg1)->showProgramTypes();
2063	–
2064	–	}catch (const std::exception& e) {
2065	–	SWIG_exception(SWIG_RuntimeError, e.what());
2066	–	}
2067	–	}
2068	–	{
2069	–	std::vector<std::string > * resultptr;
2070	–	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2071	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2072	–	}
2073	–	return resultobj;
2074	–	fail:
2075	–	return NULL;
2076	–	}
2077	–
2078	–
2079	–	static PyObject *_wrap_BossSession_showRTMon__SWIG_0(PyObject *self, PyObject *args) {
2080	–	PyObject *resultobj;
2081	–	BossSession *arg1 = (BossSession *) 0 ;
2082	–	SwigValueWrapper< std::vector<std::string > > result;
2083	–	PyObject * obj0 = 0 ;
2084	–
2085	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2086	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2087	–	{
2088	–	try {
2089	–	result = (arg1)->showRTMon();
2090	–
2091	–	}catch (const std::exception& e) {
2092	–	SWIG_exception(SWIG_RuntimeError, e.what());
2093	–	}
2094	–	}
2095	–	{
2096	–	std::vector<std::string > * resultptr;
2097	–	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2098	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2099	–	}
2100	–	return resultobj;
2101	–	fail:
2102	–	return NULL;
2103	–	}
2104	–
2105	–
2106	–	static PyObject *_wrap_BossSession_showSchedulers__SWIG_0(PyObject *self, PyObject *args) {
2107	–	PyObject *resultobj;
2108	–	BossSession *arg1 = (BossSession *) 0 ;
2109	–	SwigValueWrapper< std::vector<std::string > > result;
2110	–	PyObject * obj0 = 0 ;
2111	–
2112	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2113	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2114	–	{
2115	–	try {
2116	–	result = (arg1)->showSchedulers();
2117	–
2118	–	}catch (const std::exception& e) {
2119	–	SWIG_exception(SWIG_RuntimeError, e.what());
2120	–	}
2121	–	}
2122	–	{
2123	–	std::vector<std::string > * resultptr;
2124	–	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2125	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2126	–	}
2127	–	return resultobj;
2128	–	fail:
2129	–	return NULL;
2130	–	}
2131	–
2132	–
2765		static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
2766		PyObject *resultobj;
2767		BossSession *arg1 = (BossSession *) 0 ;
#	Line 2142 | Line 2774 | static PyObject *_wrap_BossSession_defau
2774		try {
2775		result = (arg1)->defaultCHTool();
2776
2777	+	}catch (const BossSchedFailure & e) {
2778	+	SWIG_exception(SWIG_ValueError, e.what());
2779		}catch (const std::exception& e) {
2780		SWIG_exception(SWIG_RuntimeError, e.what());
2781		}
#	Line 2167 | Line 2801 | static PyObject *_wrap_BossSession_defau
2801		try {
2802		result = (arg1)->defaultProgramType();
2803
2804	+	}catch (const BossSchedFailure & e) {
2805	+	SWIG_exception(SWIG_ValueError, e.what());
2806		}catch (const std::exception& e) {
2807		SWIG_exception(SWIG_RuntimeError, e.what());
2808		}
#	Line 2192 | Line 2828 | static PyObject *_wrap_BossSession_defau
2828		try {
2829		result = (arg1)->defaultRTMon();
2830
2831	+	}catch (const BossSchedFailure & e) {
2832	+	SWIG_exception(SWIG_ValueError, e.what());
2833		}catch (const std::exception& e) {
2834		SWIG_exception(SWIG_RuntimeError, e.what());
2835		}
#	Line 2217 | Line 2855 | static PyObject *_wrap_BossSession_defau
2855		try {
2856		result = (arg1)->defaultScheduler();
2857
2858	+	}catch (const BossSchedFailure & e) {
2859	+	SWIG_exception(SWIG_ValueError, e.what());
2860		}catch (const std::exception& e) {
2861		SWIG_exception(SWIG_RuntimeError, e.what());
2862		}
#	Line 2242 | Line 2882 | static PyObject *_wrap_BossSession_versi
2882		try {
2883		result = (arg1)->version();
2884
2885	+	}catch (const BossSchedFailure & e) {
2886	+	SWIG_exception(SWIG_ValueError, e.what());
2887		}catch (const std::exception& e) {
2888		SWIG_exception(SWIG_RuntimeError, e.what());
2889		}
#	Line 2267 | Line 2909 | static PyObject *_wrap_BossSession_clien
2909		try {
2910		result = (arg1)->clientID();
2911
2912	+	}catch (const BossSchedFailure & e) {
2913	+	SWIG_exception(SWIG_ValueError, e.what());
2914		}catch (const std::exception& e) {
2915		SWIG_exception(SWIG_RuntimeError, e.what());
2916		}
#	Line 2298 | Line 2942 | static PyObject *_wrap_BossSession_showC
2942		try {
2943		result = (int)(arg1)->showConfigs(arg2);
2944
2945	+	}catch (const BossSchedFailure & e) {
2946	+	SWIG_exception(SWIG_ValueError, e.what());
2947		}catch (const std::exception& e) {
2948		SWIG_exception(SWIG_RuntimeError, e.what());
2949		}
#	Line 2351 | Line 2997 | static PyObject *_wrap_BossSession_RTupd
2997		try {
2998		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2999
3000	+	}catch (const BossSchedFailure & e) {
3001	+	SWIG_exception(SWIG_ValueError, e.what());
3002		}catch (const std::exception& e) {
3003		SWIG_exception(SWIG_RuntimeError, e.what());
3004		}
#	Line 2372 | Line 3020 | static PyObject *_wrap_BossSession_listM
3020		std::string *arg5 = (std::string *) &arg5_defvalue ;
3021		std::string const &arg6_defvalue = "" ;
3022		std::string *arg6 = (std::string *) &arg6_defvalue ;
3023	<	std::string result;
3023	>	std::vector<std::string > result;
3024		std::string temp2 ;
3025		std::string temp3 ;
3026		std::string temp5 ;
#	Line 2430 | Line 3078 | static PyObject *_wrap_BossSession_listM
3078		try {
3079		result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
3080
3081	+	}catch (const BossSchedFailure & e) {
3082	+	SWIG_exception(SWIG_ValueError, e.what());
3083		}catch (const std::exception& e) {
3084		SWIG_exception(SWIG_RuntimeError, e.what());
3085		}
3086		}
3087		{
3088	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3088	>	resultobj = PyTuple_New((&result)->size());
3089	>	for (unsigned int i=0; i<(&result)->size(); i++)
3090	>	PyTuple_SetItem(resultobj,i,
3091	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3092		}
3093		return resultobj;
3094		fail:
#	Line 2537 | Line 3190 | static PyObject *_wrap_BossSession_sched
3190		try {
3191		(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3192
3193	+	}catch (const BossSchedFailure & e) {
3194	+	SWIG_exception(SWIG_ValueError, e.what());
3195		}catch (const std::exception& e) {
3196		SWIG_exception(SWIG_RuntimeError, e.what());
3197		}
#	Line 2559 | Line 3214 | static PyObject *_wrap_BossSession_selec
3214		std::string *arg4 = (std::string *) &arg4_defvalue ;
3215		std::string const &arg5_defvalue = "" ;
3216		std::string *arg5 = (std::string *) &arg5_defvalue ;
3217	<	SwigValueWrapper< std::vector<std::string > > result;
3217	>	std::vector<std::string > result;
3218		std::string temp2 ;
3219		std::string temp3 ;
3220		std::string temp4 ;
#	Line 2616 | Line 3271 | static PyObject *_wrap_BossSession_selec
3271		try {
3272		result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3273
3274	+	}catch (const BossSchedFailure & e) {
3275	+	SWIG_exception(SWIG_ValueError, e.what());
3276		}catch (const std::exception& e) {
3277		SWIG_exception(SWIG_RuntimeError, e.what());
3278		}
3279		}
3280		{
3281	<	std::vector<std::string > * resultptr;
3282	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3283	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3281	>	resultobj = PyTuple_New((&result)->size());
3282	>	for (unsigned int i=0; i<(&result)->size(); i++)
3283	>	PyTuple_SetItem(resultobj,i,
3284	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3285	>	}
3286	>	return resultobj;
3287	>	fail:
3288	>	return NULL;
3289	>	}
3290	>
3291	>
3292	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3293	>	PyObject *resultobj;
3294	>	BossSession *arg1 = (BossSession *) 0 ;
3295	>	int arg2 = (int) SCHEDULED ;
3296	>	std::string const &arg3_defvalue = "all" ;
3297	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3298	>	std::string const &arg4_defvalue = "all" ;
3299	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3300	>	std::string const &arg5_defvalue = "" ;
3301	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3302	>	std::string arg6 = (std::string) "" ;
3303	>	std::string arg7 = (std::string) "" ;
3304	>	std::string arg8 = (std::string) "" ;
3305	>	std::string arg9 = (std::string) "" ;
3306	>	bool arg10 = (bool) false ;
3307	>	SwigValueWrapper< std::vector<BossTask * > > result;
3308	>	std::string temp3 ;
3309	>	std::string temp4 ;
3310	>	std::string temp5 ;
3311	>	PyObject * obj0 = 0 ;
3312	>	PyObject * obj2 = 0 ;
3313	>	PyObject * obj3 = 0 ;
3314	>	PyObject * obj4 = 0 ;
3315	>	PyObject * obj5 = 0 ;
3316	>	PyObject * obj6 = 0 ;
3317	>	PyObject * obj7 = 0 ;
3318	>	PyObject * obj8 = 0 ;
3319	>	PyObject * obj9 = 0 ;
3320	>
3321	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3322	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3323	>	if (obj2) {
3324	>	{
3325	>	if (PyString_Check(obj2)) {
3326	>	temp3 = std::string(PyString_AsString(obj2));
3327	>	arg3 = &temp3;
3328	>	}else {
3329	>	SWIG_exception(SWIG_TypeError, "string expected");
3330	>	}
3331	>	}
3332	>	}
3333	>	if (obj3) {
3334	>	{
3335	>	if (PyString_Check(obj3)) {
3336	>	temp4 = std::string(PyString_AsString(obj3));
3337	>	arg4 = &temp4;
3338	>	}else {
3339	>	SWIG_exception(SWIG_TypeError, "string expected");
3340	>	}
3341	>	}
3342	>	}
3343	>	if (obj4) {
3344	>	{
3345	>	if (PyString_Check(obj4)) {
3346	>	temp5 = std::string(PyString_AsString(obj4));
3347	>	arg5 = &temp5;
3348	>	}else {
3349	>	SWIG_exception(SWIG_TypeError, "string expected");
3350	>	}
3351	>	}
3352	>	}
3353	>	if (obj5) {
3354	>	{
3355	>	if (PyString_Check(obj5))
3356	>	arg6 = std::string(PyString_AsString(obj5));
3357	>	else
3358	>	SWIG_exception(SWIG_TypeError, "string expected");
3359	>	}
3360	>	}
3361	>	if (obj6) {
3362	>	{
3363	>	if (PyString_Check(obj6))
3364	>	arg7 = std::string(PyString_AsString(obj6));
3365	>	else
3366	>	SWIG_exception(SWIG_TypeError, "string expected");
3367	>	}
3368	>	}
3369	>	if (obj7) {
3370	>	{
3371	>	if (PyString_Check(obj7))
3372	>	arg8 = std::string(PyString_AsString(obj7));
3373	>	else
3374	>	SWIG_exception(SWIG_TypeError, "string expected");
3375	>	}
3376	>	}
3377	>	if (obj8) {
3378	>	{
3379	>	if (PyString_Check(obj8))
3380	>	arg9 = std::string(PyString_AsString(obj8));
3381	>	else
3382	>	SWIG_exception(SWIG_TypeError, "string expected");
3383	>	}
3384	>	}
3385	>	if (obj9) {
3386	>	arg10 = PyInt_AsLong(obj9) ? true : false;
3387	>	if (PyErr_Occurred()) SWIG_fail;
3388	>	}
3389	>	{
3390	>	try {
3391	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3392	>
3393	>	}catch (const BossSchedFailure & e) {
3394	>	SWIG_exception(SWIG_ValueError, e.what());
3395	>	}catch (const std::exception& e) {
3396	>	SWIG_exception(SWIG_RuntimeError, e.what());
3397	>	}
3398	>	}
3399	>	{
3400	>	std::vector<BossTask * > * resultptr;
3401	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3402	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3403		}
3404		return resultobj;
3405		fail:
#	Line 2688 | Line 3464 | static PyObject *_wrap_new_BossTaskExcep
3464		try {
3465		result = (BossTaskException *)new BossTaskException((char const *)arg1);
3466
3467	+	}catch (const BossSchedFailure & e) {
3468	+	SWIG_exception(SWIG_ValueError, e.what());
3469		}catch (const std::exception& e) {
3470		SWIG_exception(SWIG_RuntimeError, e.what());
3471		}
#	Line 2711 | Line 3489 | static PyObject *_wrap_BossTaskException
3489		try {
3490		result = (char *)((BossTaskException const *)arg1)->what();
3491
3492	+	}catch (const BossSchedFailure & e) {
3493	+	SWIG_exception(SWIG_ValueError, e.what());
3494		}catch (const std::exception& e) {
3495		SWIG_exception(SWIG_RuntimeError, e.what());
3496		}
#	Line 2733 | Line 3513 | static PyObject *_wrap_delete_BossTaskEx
3513		try {
3514		delete arg1;
3515
3516	+	}catch (const BossSchedFailure & e) {
3517	+	SWIG_exception(SWIG_ValueError, e.what());
3518		}catch (const std::exception& e) {
3519		SWIG_exception(SWIG_RuntimeError, e.what());
3520		}
#	Line 2772 | Line 3554 | static PyObject *_wrap_BossTask_appendTo
3554		try {
3555		result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3556
3557	+	}catch (const BossSchedFailure & e) {
3558	+	SWIG_exception(SWIG_ValueError, e.what());
3559		}catch (const std::exception& e) {
3560		SWIG_exception(SWIG_RuntimeError, e.what());
3561		}
#	Line 2801 | Line 3585 | static PyObject *_wrap_BossTask_jobDict(
3585		try {
3586		result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3587
3588	+	}catch (const BossSchedFailure & e) {
3589	+	SWIG_exception(SWIG_ValueError, e.what());
3590		}catch (const std::exception& e) {
3591		SWIG_exception(SWIG_RuntimeError, e.what());
3592		}
#	Line 2812 | Line 3598 | static PyObject *_wrap_BossTask_jobDict(
3598		}
3599
3600
3601	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3601	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
3602		PyObject *resultobj;
3603		BossTask *arg1 = (BossTask *) 0 ;
3604		PyObject *result;
3605		PyObject * obj0 = 0 ;
3606
3607	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3607	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3608		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3609		{
3610		try {
3611	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3611	>	result = (PyObject *)BossTask_jobsDict(arg1);
3612
3613	+	}catch (const BossSchedFailure & e) {
3614	+	SWIG_exception(SWIG_ValueError, e.what());
3615		}catch (const std::exception& e) {
3616		SWIG_exception(SWIG_RuntimeError, e.what());
3617		}
#	Line 2835 | Line 3623 | static PyObject *_wrap_BossTask_jobsMap_
3623		}
3624
3625
2838	–	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
2839	–	int argc;
2840	–	PyObject *argv[2];
2841	–	int ii;
2842	–
2843	–	argc = PyObject_Length(args);
2844	–	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2845	–	argv[ii] = PyTuple_GetItem(args,ii);
2846	–	}
2847	–	if (argc == 1) {
2848	–	int _v;
2849	–	{
2850	–	void *ptr;
2851	–	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
2852	–	_v = 0;
2853	–	PyErr_Clear();
2854	–	}else {
2855	–	_v = 1;
2856	–	}
2857	–	}
2858	–	if (_v) {
2859	–	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
2860	–	}
2861	–	}
2862	–
2863	–	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
2864	–	return NULL;
2865	–	}
2866	–
2867	–
3626		static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3627		PyObject *resultobj;
3628		BossTask *arg1 = (BossTask *) 0 ;
#	Line 2883 | Line 3641 | static PyObject *_wrap_BossTask_progDict
3641		try {
3642		result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3643
3644	+	}catch (const BossSchedFailure & e) {
3645	+	SWIG_exception(SWIG_ValueError, e.what());
3646		}catch (const std::exception& e) {
3647		SWIG_exception(SWIG_RuntimeError, e.what());
3648		}
#	Line 2917 | Line 3677 | static PyObject *_wrap_BossTask_jobProgr
3677		try {
3678		result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3679
3680	+	}catch (const BossSchedFailure & e) {
3681	+	SWIG_exception(SWIG_ValueError, e.what());
3682		}catch (const std::exception& e) {
3683		SWIG_exception(SWIG_RuntimeError, e.what());
3684		}
#	Line 2940 | Line 3702 | static PyObject *_wrap_new_BossTask__SWI
3702		try {
3703		result = (BossTask *)new BossTask(arg1);
3704
3705	+	}catch (const BossSchedFailure & e) {
3706	+	SWIG_exception(SWIG_ValueError, e.what());
3707		}catch (const std::exception& e) {
3708		SWIG_exception(SWIG_RuntimeError, e.what());
3709		}
#	Line 2974 | Line 3738 | static PyObject *_wrap_new_BossTask__SWI
3738		try {
3739		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3740
3741	+	}catch (const BossSchedFailure & e) {
3742	+	SWIG_exception(SWIG_ValueError, e.what());
3743		}catch (const std::exception& e) {
3744		SWIG_exception(SWIG_RuntimeError, e.what());
3745		}
#	Line 2996 | Line 3762 | static PyObject *_wrap_delete_BossTask(P
3762		try {
3763		delete arg1;
3764
3765	+	}catch (const BossSchedFailure & e) {
3766	+	SWIG_exception(SWIG_ValueError, e.what());
3767		}catch (const std::exception& e) {
3768		SWIG_exception(SWIG_RuntimeError, e.what());
3769		}
#	Line 3022 | Line 3790 | static PyObject *_wrap_new_BossTask__SWI
3790		try {
3791		result = (BossTask *)new BossTask((BossTask const &)*arg1);
3792
3793	+	}catch (const BossSchedFailure & e) {
3794	+	SWIG_exception(SWIG_ValueError, e.what());
3795		}catch (const std::exception& e) {
3796		SWIG_exception(SWIG_RuntimeError, e.what());
3797		}
#	Line 3113 | Line 3883 | static PyObject *_wrap_BossTask_id(PyObj
3883		result = (std::string *) &_result_ref;
3884		}
3885
3886	+	}catch (const BossSchedFailure & e) {
3887	+	SWIG_exception(SWIG_ValueError, e.what());
3888		}catch (const std::exception& e) {
3889		SWIG_exception(SWIG_RuntimeError, e.what());
3890		}
#	Line 3141 | Line 3913 | static PyObject *_wrap_BossTask_name(PyO
3913		result = (std::string *) &_result_ref;
3914		}
3915
3916	+	}catch (const BossSchedFailure & e) {
3917	+	SWIG_exception(SWIG_ValueError, e.what());
3918		}catch (const std::exception& e) {
3919		SWIG_exception(SWIG_RuntimeError, e.what());
3920		}
#	Line 3166 | Line 3940 | static PyObject *_wrap_BossTask_taskMap(
3940		try {
3941		result = ((BossTask const *)arg1)->taskMap();
3942
3943	+	}catch (const BossSchedFailure & e) {
3944	+	SWIG_exception(SWIG_ValueError, e.what());
3945		}catch (const std::exception& e) {
3946		SWIG_exception(SWIG_RuntimeError, e.what());
3947		}
#	Line 3196 | Line 3972 | static PyObject *_wrap_BossTask_job_begi
3972		try {
3973		result = ((BossTask const *)arg1)->job_begin();
3974
3975	+	}catch (const BossSchedFailure & e) {
3976	+	SWIG_exception(SWIG_ValueError, e.what());
3977		}catch (const std::exception& e) {
3978		SWIG_exception(SWIG_RuntimeError, e.what());
3979		}
#	Line 3223 | Line 4001 | static PyObject *_wrap_BossTask_job_end(
4001		try {
4002		result = ((BossTask const *)arg1)->job_end();
4003
4004	+	}catch (const BossSchedFailure & e) {
4005	+	SWIG_exception(SWIG_ValueError, e.what());
4006		}catch (const std::exception& e) {
4007		SWIG_exception(SWIG_RuntimeError, e.what());
4008		}
#	Line 3238 | Line 4018 | static PyObject *_wrap_BossTask_job_end(
4018		}
4019
4020
4021	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
4021	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4022		PyObject *resultobj;
4023		BossTask *arg1 = (BossTask *) 0 ;
4024		SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
#	Line 3250 | Line 4030 | static PyObject *_wrap_BossTask_jobsMap_
4030		try {
4031		result = ((BossTask const *)arg1)->jobsMap();
4032
4033	+	}catch (const BossSchedFailure & e) {
4034	+	SWIG_exception(SWIG_ValueError, e.what());
4035		}catch (const std::exception& e) {
4036		SWIG_exception(SWIG_RuntimeError, e.what());
4037		}
#	Line 3288 | Line 4070 | static PyObject *_wrap_BossTask_jobMap__
4070		try {
4071		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4072
4073	+	}catch (const BossSchedFailure & e) {
4074	+	SWIG_exception(SWIG_ValueError, e.what());
4075		}catch (const std::exception& e) {
4076		SWIG_exception(SWIG_RuntimeError, e.what());
4077		}
#	Line 3317 | Line 4101 | static PyObject *_wrap_BossTask_jobMap__
4101		try {
4102		result = ((BossTask const *)arg1)->jobMap(arg2);
4103
4104	+	}catch (const BossSchedFailure & e) {
4105	+	SWIG_exception(SWIG_ValueError, e.what());
4106		}catch (const std::exception& e) {
4107		SWIG_exception(SWIG_RuntimeError, e.what());
4108		}
#	Line 3422 | Line 4208 | static PyObject *_wrap_BossTask_programs
4208		try {
4209		result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4210
4211	+	}catch (const BossSchedFailure & e) {
4212	+	SWIG_exception(SWIG_ValueError, e.what());
4213		}catch (const std::exception& e) {
4214		SWIG_exception(SWIG_RuntimeError, e.what());
4215		}
#	Line 3452 | Line 4240 | static PyObject *_wrap_BossTask_queryJob
4240		try {
4241		result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4242
4243	+	}catch (const BossSchedFailure & e) {
4244	+	SWIG_exception(SWIG_ValueError, e.what());
4245		}catch (const std::exception& e) {
4246		SWIG_exception(SWIG_RuntimeError, e.what());
4247		}
#	Line 3503 | Line 4293 | static PyObject *_wrap_BossTask_declare_
4293		try {
4294		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4295
4296	+	}catch (const BossSchedFailure & e) {
4297	+	SWIG_exception(SWIG_ValueError, e.what());
4298		}catch (const std::exception& e) {
4299		SWIG_exception(SWIG_RuntimeError, e.what());
4300		}
#	Line 3542 | Line 4334 | static PyObject *_wrap_BossTask_declare_
4334		try {
4335		(arg1)->declare(arg2,(std::string const &)*arg3);
4336
4337	+	}catch (const BossSchedFailure & e) {
4338	+	SWIG_exception(SWIG_ValueError, e.what());
4339		}catch (const std::exception& e) {
4340		SWIG_exception(SWIG_RuntimeError, e.what());
4341		}
#	Line 3641 | Line 4435 | static PyObject *_wrap_BossTask_remove(P
4435		try {
4436		(arg1)->remove();
4437
4438	+	}catch (const BossSchedFailure & e) {
4439	+	SWIG_exception(SWIG_ValueError, e.what());
4440		}catch (const std::exception& e) {
4441		SWIG_exception(SWIG_RuntimeError, e.what());
4442		}
#	Line 3677 | Line 4473 | static PyObject *_wrap_BossTask_archive(
4473		try {
4474		(arg1)->archive((std::string const &)*arg2);
4475
4476	+	}catch (const BossSchedFailure & e) {
4477	+	SWIG_exception(SWIG_ValueError, e.what());
4478		}catch (const std::exception& e) {
4479		SWIG_exception(SWIG_RuntimeError, e.what());
4480		}
#	Line 3776 | Line 4574 | static PyObject *_wrap_BossTask_submit(P
4574		try {
4575		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);
4576
4577	+	}catch (const BossSchedFailure & e) {
4578	+	SWIG_exception(SWIG_ValueError, e.what());
4579		}catch (const std::exception& e) {
4580		SWIG_exception(SWIG_RuntimeError, e.what());
4581		}
#	Line 3816 | Line 4616 | static PyObject *_wrap_BossTask_reSubmit
4616		try {
4617		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4618
4619	+	}catch (const BossSchedFailure & e) {
4620	+	SWIG_exception(SWIG_ValueError, e.what());
4621		}catch (const std::exception& e) {
4622		SWIG_exception(SWIG_RuntimeError, e.what());
4623		}
#	Line 3856 | Line 4658 | static PyObject *_wrap_BossTask_kill(PyO
4658		try {
4659		result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4660
4661	+	}catch (const BossSchedFailure & e) {
4662	+	SWIG_exception(SWIG_ValueError, e.what());
4663		}catch (const std::exception& e) {
4664		SWIG_exception(SWIG_RuntimeError, e.what());
4665		}
#	Line 3867 | Line 4671 | static PyObject *_wrap_BossTask_kill(PyO
4671		}
4672
4673
4674	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
4674	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4675		PyObject *resultobj;
4676		BossTask *arg1 = (BossTask *) 0 ;
4677		std::string const &arg2_defvalue = "all" ;
#	Line 3919 | Line 4723 | static PyObject *_wrap_BossTask_getOutpu
4723		try {
4724		result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4725
4726	+	}catch (const BossSchedFailure & e) {
4727	+	SWIG_exception(SWIG_ValueError, e.what());
4728		}catch (const std::exception& e) {
4729		SWIG_exception(SWIG_RuntimeError, e.what());
4730		}
#	Line 3930 | Line 4736 | static PyObject *_wrap_BossTask_getOutpu
4736		}
4737
4738
4739	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
4739	>	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4740		PyObject *resultobj;
4741		BossTask *arg1 = (BossTask *) 0 ;
4742	<	std::string const &arg2_defvalue = "" ;
4743	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
4744	<	bool arg3 = (bool) false ;
4745	<	bool arg4 = (bool) false ;
4742	>	int arg2 = (int) SCHEDULED ;
4743	>	std::string const &arg3_defvalue = "all" ;
4744	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4745	>	std::string const &arg4_defvalue = "" ;
4746	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4747	>	std::string arg5 = (std::string) "" ;
4748	>	std::string arg6 = (std::string) "" ;
4749	>	std::string arg7 = (std::string) "" ;
4750	>	std::string arg8 = (std::string) "" ;
4751		int result;
4752	<	std::string temp2 ;
4752	>	std::string temp3 ;
4753	>	std::string temp4 ;
4754		PyObject * obj0 = 0 ;
3943	–	PyObject * obj1 = 0 ;
4755		PyObject * obj2 = 0 ;
4756		PyObject * obj3 = 0 ;
4757	+	PyObject * obj4 = 0 ;
4758	+	PyObject * obj5 = 0 ;
4759	+	PyObject * obj6 = 0 ;
4760	+	PyObject * obj7 = 0 ;
4761
4762	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4762	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4763		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4764	<	if (obj1) {
4764	>	if (obj2) {
4765		{
4766	<	if (PyString_Check(obj1)) {
4767	<	temp2 = std::string(PyString_AsString(obj1));
4768	<	arg2 = &temp2;
4766	>	if (PyString_Check(obj2)) {
4767	>	temp3 = std::string(PyString_AsString(obj2));
4768	>	arg3 = &temp3;
4769		}else {
4770		SWIG_exception(SWIG_TypeError, "string expected");
4771		}
4772		}
4773		}
3959	–	if (obj2) {
3960	–	arg3 = PyInt_AsLong(obj2) ? true : false;
3961	–	if (PyErr_Occurred()) SWIG_fail;
3962	–	}
4774		if (obj3) {
4775	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4776	<	if (PyErr_Occurred()) SWIG_fail;
4777	<	}
4778	<	{
4779	<	try {
4780	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
4781	<
3971	<	}catch (const std::exception& e) {
3972	<	SWIG_exception(SWIG_RuntimeError, e.what());
4775	>	{
4776	>	if (PyString_Check(obj3)) {
4777	>	temp4 = std::string(PyString_AsString(obj3));
4778	>	arg4 = &temp4;
4779	>	}else {
4780	>	SWIG_exception(SWIG_TypeError, "string expected");
4781	>	}
4782		}
4783		}
4784	<	resultobj = PyInt_FromLong((long)result);
4785	<	return resultobj;
4786	<	fail:
4787	<	return NULL;
4788	<	}
4789	<
4790	<
3982	<	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
3983	<	int argc;
3984	<	PyObject *argv[6];
3985	<	int ii;
3986	<
3987	<	argc = PyObject_Length(args);
3988	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
3989	<	argv[ii] = PyTuple_GetItem(args,ii);
4784	>	if (obj4) {
4785	>	{
4786	>	if (PyString_Check(obj4))
4787	>	arg5 = std::string(PyString_AsString(obj4));
4788	>	else
4789	>	SWIG_exception(SWIG_TypeError, "string expected");
4790	>	}
4791		}
4792	<	if ((argc >= 1) && (argc <= 5)) {
3992	<	int _v;
4792	>	if (obj5) {
4793		{
4794	<	void *ptr;
4795	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4796	<	_v = 0;
4797	<	PyErr_Clear();
3998	<	}else {
3999	<	_v = 1;
4000	<	}
4794	>	if (PyString_Check(obj5))
4795	>	arg6 = std::string(PyString_AsString(obj5));
4796	>	else
4797	>	SWIG_exception(SWIG_TypeError, "string expected");
4798		}
4799	<	if (_v) {
4800	<	if (argc <= 1) {
4801	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4802	<	}
4803	<	{
4804	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4805	<	}
4009	<	if (_v) {
4010	<	if (argc <= 2) {
4011	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4012	<	}
4013	<	{
4014	<	_v = PyString_Check(argv[2]) ? 1 : 0;
4015	<	}
4016	<	if (_v) {
4017	<	if (argc <= 3) {
4018	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4019	<	}
4020	<	{
4021	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4022	<	}
4023	<	if (_v) {
4024	<	if (argc <= 4) {
4025	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4026	<	}
4027	<	{
4028	<	_v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
4029	<	}
4030	<	if (_v) {
4031	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4032	<	}
4033	<	}
4034	<	}
4035	<	}
4799	>	}
4800	>	if (obj6) {
4801	>	{
4802	>	if (PyString_Check(obj6))
4803	>	arg7 = std::string(PyString_AsString(obj6));
4804	>	else
4805	>	SWIG_exception(SWIG_TypeError, "string expected");
4806		}
4807		}
4808	<	if ((argc >= 1) && (argc <= 4)) {
4039	<	int _v;
4808	>	if (obj7) {
4809		{
4810	<	void *ptr;
4811	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4812	<	_v = 0;
4813	<	PyErr_Clear();
4045	<	}else {
4046	<	_v = 1;
4047	<	}
4810	>	if (PyString_Check(obj7))
4811	>	arg8 = std::string(PyString_AsString(obj7));
4812	>	else
4813	>	SWIG_exception(SWIG_TypeError, "string expected");
4814		}
4815	<	if (_v) {
4816	<	if (argc <= 1) {
4817	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4818	<	}
4819	<	{
4820	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4821	<	}
4822	<	if (_v) {
4823	<	if (argc <= 2) {
4058	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4059	<	}
4060	<	{
4061	<	_v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
4062	<	}
4063	<	if (_v) {
4064	<	if (argc <= 3) {
4065	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4066	<	}
4067	<	{
4068	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4069	<	}
4070	<	if (_v) {
4071	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4072	<	}
4073	<	}
4074	<	}
4815	>	}
4816	>	{
4817	>	try {
4818	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4819	>
4820	>	}catch (const BossSchedFailure & e) {
4821	>	SWIG_exception(SWIG_ValueError, e.what());
4822	>	}catch (const std::exception& e) {
4823	>	SWIG_exception(SWIG_RuntimeError, e.what());
4824		}
4825		}
4826	<
4827	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
4826	>	resultobj = PyInt_FromLong((long)result);
4827	>	return resultobj;
4828	>	fail:
4829		return NULL;
4830		}
4831
#	Line 4167 | Line 4917 | static PyObject *_wrap_BossTask_query(Py
4917		try {
4918		result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
4919
4920	+	}catch (const BossSchedFailure & e) {
4921	+	SWIG_exception(SWIG_ValueError, e.what());
4922		}catch (const std::exception& e) {
4923		SWIG_exception(SWIG_RuntimeError, e.what());
4924		}
#	Line 4226 | Line 4978 | static PyObject *_wrap_BossTask_query_ou
4978		try {
4979		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
4980
4981	+	}catch (const BossSchedFailure & e) {
4982	+	SWIG_exception(SWIG_ValueError, e.what());
4983		}catch (const std::exception& e) {
4984		SWIG_exception(SWIG_RuntimeError, e.what());
4985		}
#	Line 4248 | Line 5002 | static PyObject *_wrap_BossTask_clear(Py
5002		try {
5003		(arg1)->clear();
5004
5005	+	}catch (const BossSchedFailure & e) {
5006	+	SWIG_exception(SWIG_ValueError, e.what());
5007		}catch (const std::exception& e) {
5008		SWIG_exception(SWIG_RuntimeError, e.what());
5009		}
#	Line 4266 | Line 5022 | static PyObject * BossTask_swigregister(
5022		Py_INCREF(obj);
5023		return Py_BuildValue((char *)"");
5024		}
4269	–	static PyObject *_wrap_prompt(PyObject *self, PyObject *args) {
4270	–	PyObject *resultobj;
4271	–	std::string *arg1 = 0 ;
4272	–	bool result;
4273	–	std::string temp1 ;
4274	–	PyObject * obj0 = 0 ;
4275	–
4276	–	if(!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) goto fail;
4277	–	{
4278	–	if (PyString_Check(obj0)) {
4279	–	temp1 = std::string(PyString_AsString(obj0));
4280	–	arg1 = &temp1;
4281	–	}else {
4282	–	SWIG_exception(SWIG_TypeError, "string expected");
4283	–	}
4284	–	}
4285	–	{
4286	–	try {
4287	–	result = (bool)prompt((std::string const &)*arg1);
4288	–
4289	–	}catch (const std::exception& e) {
4290	–	SWIG_exception(SWIG_RuntimeError, e.what());
4291	–	}
4292	–	}
4293	–	resultobj = PyInt_FromLong((long)result);
4294	–	return resultobj;
4295	–	fail:
4296	–	return NULL;
4297	–	}
4298	–
4299	–
5025		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5026		PyObject *resultobj;
5027		std::string arg1 = (std::string) "" ;
5028	<	bool arg2 = (bool) false ;
5028	>	std::string arg2 = (std::string) "2" ;
5029	>	std::string arg3 = (std::string) "" ;
5030	>	std::string arg4 = (std::string) "" ;
5031	>	bool arg5 = (bool) false ;
5032		BossAdministratorSession *result;
5033		PyObject * obj0 = 0 ;
5034		PyObject * obj1 = 0 ;
5035	+	PyObject * obj2 = 0 ;
5036	+	PyObject * obj3 = 0 ;
5037	+	PyObject * obj4 = 0 ;
5038
5039	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
5039	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5040		if (obj0) {
5041		{
5042		if (PyString_Check(obj0))
#	Line 4315 | Line 5046 | static PyObject *_wrap_new_BossAdministr
5046		}
5047		}
5048		if (obj1) {
5049	<	arg2 = PyInt_AsLong(obj1) ? true : false;
5049	>	{
5050	>	if (PyString_Check(obj1))
5051	>	arg2 = std::string(PyString_AsString(obj1));
5052	>	else
5053	>	SWIG_exception(SWIG_TypeError, "string expected");
5054	>	}
5055	>	}
5056	>	if (obj2) {
5057	>	{
5058	>	if (PyString_Check(obj2))
5059	>	arg3 = std::string(PyString_AsString(obj2));
5060	>	else
5061	>	SWIG_exception(SWIG_TypeError, "string expected");
5062	>	}
5063	>	}
5064	>	if (obj3) {
5065	>	{
5066	>	if (PyString_Check(obj3))
5067	>	arg4 = std::string(PyString_AsString(obj3));
5068	>	else
5069	>	SWIG_exception(SWIG_TypeError, "string expected");
5070	>	}
5071	>	}
5072	>	if (obj4) {
5073	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5074		if (PyErr_Occurred()) SWIG_fail;
5075		}
5076		{
5077		try {
5078	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
5078	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5079
5080	+	}catch (const BossSchedFailure & e) {
5081	+	SWIG_exception(SWIG_ValueError, e.what());
5082		}catch (const std::exception& e) {
5083		SWIG_exception(SWIG_RuntimeError, e.what());
5084		}
#	Line 4344 | Line 5101 | static PyObject *_wrap_delete_BossAdmini
5101		try {
5102		delete arg1;
5103
5104	+	}catch (const BossSchedFailure & e) {
5105	+	SWIG_exception(SWIG_ValueError, e.what());
5106		}catch (const std::exception& e) {
5107		SWIG_exception(SWIG_RuntimeError, e.what());
5108		}
#	Line 4367 | Line 5126 | static PyObject *_wrap_BossAdministrator
5126		try {
5127		result = (int)(arg1)->configureDB();
5128
5129	+	}catch (const BossSchedFailure & e) {
5130	+	SWIG_exception(SWIG_ValueError, e.what());
5131		}catch (const std::exception& e) {
5132		SWIG_exception(SWIG_RuntimeError, e.what());
5133		}
#	Line 4401 | Line 5162 | static PyObject *_wrap_BossAdministrator
5162		try {
5163		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5164
5165	+	}catch (const BossSchedFailure & e) {
5166	+	SWIG_exception(SWIG_ValueError, e.what());
5167		}catch (const std::exception& e) {
5168		SWIG_exception(SWIG_RuntimeError, e.what());
5169		}
#	Line 4435 | Line 5198 | static PyObject *_wrap_BossAdministrator
5198		try {
5199		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5200
5201	+	}catch (const BossSchedFailure & e) {
5202	+	SWIG_exception(SWIG_ValueError, e.what());
5203		}catch (const std::exception& e) {
5204		SWIG_exception(SWIG_RuntimeError, e.what());
5205		}
#	Line 4469 | Line 5234 | static PyObject *_wrap_BossAdministrator
5234		try {
5235		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5236
5237	+	}catch (const BossSchedFailure & e) {
5238	+	SWIG_exception(SWIG_ValueError, e.what());
5239		}catch (const std::exception& e) {
5240		SWIG_exception(SWIG_RuntimeError, e.what());
5241		}
#	Line 4503 | Line 5270 | static PyObject *_wrap_BossAdministrator
5270		try {
5271		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5272
5273	+	}catch (const BossSchedFailure & e) {
5274	+	SWIG_exception(SWIG_ValueError, e.what());
5275		}catch (const std::exception& e) {
5276		SWIG_exception(SWIG_RuntimeError, e.what());
5277		}
#	Line 4537 | Line 5306 | static PyObject *_wrap_BossAdministrator
5306		try {
5307		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5308
5309	+	}catch (const BossSchedFailure & e) {
5310	+	SWIG_exception(SWIG_ValueError, e.what());
5311		}catch (const std::exception& e) {
5312		SWIG_exception(SWIG_RuntimeError, e.what());
5313		}
#	Line 4603 | Line 5374 | static PyObject *_wrap_BossAdministrator
5374		try {
5375		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5376
5377	+	}catch (const BossSchedFailure & e) {
5378	+	SWIG_exception(SWIG_ValueError, e.what());
5379		}catch (const std::exception& e) {
5380		SWIG_exception(SWIG_RuntimeError, e.what());
5381		}
#	Line 4693 | Line 5466 | static PyObject *_wrap_BossAdministrator
5466		try {
5467		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5468
5469	+	}catch (const BossSchedFailure & e) {
5470	+	SWIG_exception(SWIG_ValueError, e.what());
5471		}catch (const std::exception& e) {
5472		SWIG_exception(SWIG_RuntimeError, e.what());
5473		}
#	Line 4769 | Line 5544 | static PyObject *_wrap_BossAdministrator
5544		try {
5545		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5546
5547	+	}catch (const BossSchedFailure & e) {
5548	+	SWIG_exception(SWIG_ValueError, e.what());
5549		}catch (const std::exception& e) {
5550		SWIG_exception(SWIG_RuntimeError, e.what());
5551		}
#	Line 4798 | Line 5575 | static PyObject *_wrap_BossAdministrator
5575		std::string arg13 = (std::string) "" ;
5576		bool arg14 = (bool) false ;
5577		bool arg15 = (bool) false ;
5578	+	bool arg16 = (bool) false ;
5579	+	bool arg17 = (bool) false ;
5580		int result;
5581		std::string temp2 ;
5582		std::string temp11 ;
#	Line 4816 | Line 5595 | static PyObject *_wrap_BossAdministrator
5595		PyObject * obj12 = 0 ;
5596		PyObject * obj13 = 0 ;
5597		PyObject * obj14 = 0 ;
5598	+	PyObject * obj15 = 0 ;
5599	+	PyObject * obj16 = 0 ;
5600
5601	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) goto fail;
5601	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) goto fail;
5602		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5603		{
5604		if (PyString_Check(obj1)) {
#	Line 4925 | Line 5706 | static PyObject *_wrap_BossAdministrator
5706		arg15 = PyInt_AsLong(obj14) ? true : false;
5707		if (PyErr_Occurred()) SWIG_fail;
5708		}
5709	+	if (obj15) {
5710	+	arg16 = PyInt_AsLong(obj15) ? true : false;
5711	+	if (PyErr_Occurred()) SWIG_fail;
5712	+	}
5713	+	if (obj16) {
5714	+	arg17 = PyInt_AsLong(obj16) ? true : false;
5715	+	if (PyErr_Occurred()) SWIG_fail;
5716	+	}
5717		{
5718		try {
5719	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
5719	>	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);
5720
5721	+	}catch (const BossSchedFailure & e) {
5722	+	SWIG_exception(SWIG_ValueError, e.what());
5723		}catch (const std::exception& e) {
5724		SWIG_exception(SWIG_RuntimeError, e.what());
5725		}
#	Line 4952 | Line 5743 | static PyObject *_wrap_BossAdministrator
5743		try {
5744		result = (arg1)->help();
5745
5746	+	}catch (const BossSchedFailure & e) {
5747	+	SWIG_exception(SWIG_ValueError, e.what());
5748		}catch (const std::exception& e) {
5749		SWIG_exception(SWIG_RuntimeError, e.what());
5750		}
#	Line 4991 | Line 5784 | static PyObject *_wrap_BossAdministrator
5784		try {
5785		result = (arg1)->SQL(arg2,arg3);
5786
5787	+	}catch (const BossSchedFailure & e) {
5788	+	SWIG_exception(SWIG_ValueError, e.what());
5789		}catch (const std::exception& e) {
5790		SWIG_exception(SWIG_RuntimeError, e.what());
5791		}
#	Line 5063 | Line 5858 | static PyObject *_wrap_BossAdministrator
5858		try {
5859		result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
5860
5861	+	}catch (const BossSchedFailure & e) {
5862	+	SWIG_exception(SWIG_ValueError, e.what());
5863	+	}catch (const std::exception& e) {
5864	+	SWIG_exception(SWIG_RuntimeError, e.what());
5865	+	}
5866	+	}
5867	+	resultobj = PyInt_FromLong((long)result);
5868	+	return resultobj;
5869	+	fail:
5870	+	return NULL;
5871	+	}
5872	+
5873	+
5874	+	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
5875	+	PyObject *resultobj;
5876	+	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5877	+	std::string arg2 ;
5878	+	int result;
5879	+	PyObject * obj0 = 0 ;
5880	+	PyObject * obj1 = 0 ;
5881	+
5882	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
5883	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5884	+	{
5885	+	if (PyString_Check(obj1))
5886	+	arg2 = std::string(PyString_AsString(obj1));
5887	+	else
5888	+	SWIG_exception(SWIG_TypeError, "string expected");
5889	+	}
5890	+	{
5891	+	try {
5892	+	result = (int)(arg1)->registerPlugins(arg2);
5893	+
5894	+	}catch (const BossSchedFailure & e) {
5895	+	SWIG_exception(SWIG_ValueError, e.what());
5896		}catch (const std::exception& e) {
5897		SWIG_exception(SWIG_RuntimeError, e.what());
5898		}
#	Line 5097 | Line 5927 | static PyMethodDef SwigMethods[] = {
5927		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
5928		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
5929		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
5930	+	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
5931	+	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
5932	+	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
5933	+	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
5934	+	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
5935	+	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
5936	+	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
5937	+	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
5938	+	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
5939	+	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
5940	+	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
5941	+	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
5942	+	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
5943	+	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5944		{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5945	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
5946	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
5947	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
5948	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, 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 },
5951		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
5952		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
5953	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
5954		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
5955		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
5956		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
#	Line 5119 | Line 5965 | static PyMethodDef SwigMethods[] = {
5965		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
5966		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
5967		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
5968	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
5969		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5970		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5971		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5128 | Line 5975 | static PyMethodDef SwigMethods[] = {
5975		{ (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_jobsMap", _wrap_BossTask_jobsMap, 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 },
5981		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
#	Line 5138 | Line 5985 | static PyMethodDef SwigMethods[] = {
5985		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5986		{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5987		{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
5988	+	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5989		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5990		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
5991		{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
#	Line 5148 | Line 5996 | static PyMethodDef SwigMethods[] = {
5996		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
5997		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
5998		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
5999	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6000		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6001		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6002		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6003		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5155	–	{ (char *)"prompt", _wrap_prompt, METH_VARARGS },
6004		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6005		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
6006		{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
#	Line 5168 | Line 6016 | static PyMethodDef SwigMethods[] = {
6016		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
6017		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
6018		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
6019	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
6020		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
6021		{ NULL, NULL }
6022		};
#	Line 5175 | Line 6024 | static PyMethodDef SwigMethods[] = {
6024
6025		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6026
5178	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6027		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}};
6028		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}};
6030	+	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}};
6031		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}};
6032		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6033		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
#	Line 5195 | Line 6045 | static swig_type_info _swigt__p_std__vec
6045		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6046
6047		static swig_type_info *swig_types_initial[] = {
5198	–	_swigt__p_XMLDoc,
6048		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6049		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6050	+	_swigt__p_XMLDoc,
6051	+	_swigt__p_std__vectorTBossTask_p_t,
6052		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6053		_swigt__p_BossTask,
6054		_swigt__p_BossTaskException,

Diff Legend

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