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.5 by gcodispo, Thu Oct 26 13:43:42 2006 UTC vs.
Revision 1.11 by gcodispo, Mon Oct 30 14:00:27 2006 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t swig_types[0]
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_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[2]
660	<	#define  SWIGTYPE_p_XMLDoc swig_types[3]
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_std__ostream swig_types[5]
663	<	#define  SWIGTYPE_p_BossTask swig_types[6]
664	<	#define  SWIGTYPE_p_BossTaskException swig_types[7]
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_BossDatabase swig_types[10]
668	<	#define  SWIGTYPE_p_BossJob swig_types[11]
667	>	#define  SWIGTYPE_p_BossJob swig_types[10]
668	>	#define  SWIGTYPE_p_BossDatabase swig_types[11]
669		#define  SWIGTYPE_p_BossSession swig_types[12]
670		#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671		#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672		#define  SWIGTYPE_p_BossAdministratorSession swig_types[15]
673	<	#define  SWIGTYPE_p_jobStates swig_types[16]
673	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[16]
674		#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[17]
675	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[18]
675	>	#define  SWIGTYPE_p_jobStates swig_types[18]
676		static swig_type_info *swig_types[20];
677
678		/* -------- TYPES TABLE (END) -------- */
#	Line 851 | Line 851 | PyObject *std_maplstd_stringcstd_string_
851		" for iterator support");
852		#endif
853		}
854	+	std::string std_vectorlstd_string_g_pop___(std::vector<std::string > *self){
855	+	if (self->size() == 0)
856	+	throw std::out_of_range("pop from empty vector");
857	+	std::string x = self->back();
858	+	self->pop_back();
859	+	return x;
860	+	}
861	+	std::string std_vectorlstd_string_g___getitem_____(std::vector<std::string > *self,int i){
862	+	int size = int(self->size());
863	+	if (i<0) i += size;
864	+	if (i>=0 && i<size)
865	+	return (*self)[i];
866	+	else
867	+	throw std::out_of_range("vector index out of range");
868	+	}
869	+	std::vector<std::string > std_vectorlstd_string_g___getslice_____(std::vector<std::string > *self,int i,int j){
870	+	int size = int(self->size());
871	+	if (i<0) i = size+i;
872	+	if (j<0) j = size+j;
873	+	if (i<0) i = 0;
874	+	if (j>size) j = size;
875	+	std::vector<std::string > tmp(j-i);
876	+	std::copy(self->begin()+i,self->begin()+j,tmp.begin());
877	+	return tmp;
878	+	}
879	+	void std_vectorlstd_string_g___setitem_____(std::vector<std::string > *self,int i,std::string x){
880	+	int size = int(self->size());
881	+	if (i<0) i+= size;
882	+	if (i>=0 && i<size)
883	+	(*self)[i] = x;
884	+	else
885	+	throw std::out_of_range("vector index out of range");
886	+	}
887	+	void std_vectorlstd_string_g___setslice_____(std::vector<std::string > *self,int i,int j,std::vector<std::string > const &v){
888	+	int size = int(self->size());
889	+	if (i<0) i = size+i;
890	+	if (j<0) j = size+j;
891	+	if (i<0) i = 0;
892	+	if (j>size) j = size;
893	+	if (int(v.size()) == j-i) {
894	+	std::copy(v.begin(),v.end(),self->begin()+i);
895	+	} else {
896	+	self->erase(self->begin()+i,self->begin()+j);
897	+	if (i+1 <= int(self->size()))
898	+	self->insert(self->begin()+i,v.begin(),v.end());
899	+	else
900	+	self->insert(self->end(),v.begin(),v.end());
901	+	}
902	+	}
903	+	void std_vectorlstd_string_g___delitem_____(std::vector<std::string > *self,int i){
904	+	int size = int(self->size());
905	+	if (i<0) i+= size;
906	+	if (i>=0 && i<size)
907	+	self->erase(self->begin()+i);
908	+	else
909	+	throw std::out_of_range("vector index out of range");
910	+	}
911	+	void std_vectorlstd_string_g___delslice_____(std::vector<std::string > *self,int i,int j){
912	+	int size = int(self->size());
913	+	if (i<0) i = size+i;
914	+	if (j<0) j = size+j;
915	+	if (i<0) i = 0;
916	+	if (j>size) j = size;
917	+	self->erase(self->begin()+i,self->begin()+j);
918	+	}
919
920		#include "BossSession.h"
921		#include "BossAdministratorSession.h"
#	Line 872 | Line 937 | PyObject *BossSession_show(BossSession *
937		}
938		return my_list;
939		}
940	<	PyObject *BossSession_showCHTools__SWIG_1(BossSession *self){
940	>	PyObject *BossSession_CHTools(BossSession *self){
941		std::vector<std::string> my_vec = self->showCHTools();
942		return BossSession_show( self, my_vec );
943		}
944	<	PyObject *BossSession_showProgramTypes__SWIG_1(BossSession *self){
944	>	PyObject *BossSession_ProgramTypes(BossSession *self){
945		std::vector<std::string> my_vec = self->showProgramTypes();
946		return BossSession_show( self, my_vec );
947		}
948	<	PyObject *BossSession_showRTMon__SWIG_1(BossSession *self){
948	>	PyObject *BossSession_RTMons(BossSession *self){
949		std::vector<std::string> my_vec = self->showRTMon();
950		return BossSession_show( self, my_vec );
951		}
952	<	PyObject *BossSession_showSchedulers__SWIG_1(BossSession *self){
952	>	PyObject *BossSession_schedulers(BossSession *self){
953		std::vector<std::string> my_vec = self->showSchedulers();
954		return BossSession_show( self, my_vec );
955		}
956	+	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
957	+	std::vector<std::string> my_vec = self->listMatch( scheduler,
958	+	schclassad,
959	+	keepfile,
960	+	taskid,
961	+	jobid);
962	+	return BossSession_show( self, my_vec );
963	+	}
964		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){
965	<	self->jobQuery ( filter_opt, taskRange, jobRange, subn,
966	<	type, user, after, before, avoidCheck);
965	>	if ( !avoidCheck ) {
966	>	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
967	>	type, user, after, before);
968	>	}
969		PyObject * job_dict = PyList_New(0);
970		std::vector <std::string>
971		taskList = self->selectTasks( taskRange, before, after, user);
#	Line 944 | Line 1019 | PyObject *BossTask_jobDict(BossTask cons
1019		}
1020		return job_dict;
1021		}
1022	<	PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
1022	>	PyObject *BossTask_jobsDict(BossTask const *self){
1023
1024		PyObject * job_dict = PyDict_New();
1025		for (BossTask::job_iterator jit = self->job_begin ();
#	Line 1532 | Line 1607 | static PyObject * objectMap_swigregister
1607		Py_INCREF(obj);
1608		return Py_BuildValue((char *)"");
1609		}
1610	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
1610	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1611		PyObject *resultobj;
1612	<	BossSession *arg1 = (BossSession *) 0 ;
1613	<	std::vector<std::string > *arg2 = 0 ;
1614	<	PyObject *result;
1612	>	unsigned int arg1 = (unsigned int) 0 ;
1613	>	std::vector<std::string > *result;
1614	>	PyObject * obj0 = 0 ;
1615	>
1616	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1617	>	if (obj0) {
1618	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1619	>	if (PyErr_Occurred()) SWIG_fail;
1620	>	}
1621	>	{
1622	>	try {
1623	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1624	>
1625	>	}catch (const std::exception& e) {
1626	>	SWIG_exception(SWIG_RuntimeError, e.what());
1627	>	}
1628	>	}
1629	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1630	>	return resultobj;
1631	>	fail:
1632	>	return NULL;
1633	>	}
1634	>
1635	>
1636	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1637	>	PyObject *resultobj;
1638	>	unsigned int arg1 ;
1639	>	std::string *arg2 = 0 ;
1640	>	std::vector<std::string > *result;
1641	>	std::string temp2 ;
1642		PyObject * obj0 = 0 ;
1643		PyObject * obj1 = 0 ;
1644
1645	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
1646	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1647	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1648	<	if (arg2 == NULL) {
1649	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
1645	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1646	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1647	>	if (PyErr_Occurred()) SWIG_fail;
1648	>	{
1649	>	if (PyString_Check(obj1)) {
1650	>	temp2 = std::string(PyString_AsString(obj1));
1651	>	arg2 = &temp2;
1652	>	}else {
1653	>	SWIG_exception(SWIG_TypeError, "string expected");
1654	>	}
1655		}
1656		{
1657		try {
1658	<	result = (PyObject *)BossSession_show(arg1,*arg2);
1658	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1659
1660		}catch (const std::exception& e) {
1661		SWIG_exception(SWIG_RuntimeError, e.what());
1662		}
1663		}
1664	<	resultobj = result;
1664	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1665		return resultobj;
1666		fail:
1667		return NULL;
1668		}
1669
1670
1671	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_1(PyObject *self, PyObject *args) {
1671	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1672		PyObject *resultobj;
1673	<	BossSession *arg1 = (BossSession *) 0 ;
1674	<	PyObject *result;
1673	>	std::vector<std::string > *arg1 = 0 ;
1674	>	std::vector<std::string > *result;
1675	>	std::vector<std::string > temp1 ;
1676	>	std::vector<std::string > *v1 ;
1677		PyObject * obj0 = 0 ;
1678
1679	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
1680	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1679	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1680	>	{
1681	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1682	>	unsigned int size = (PyTuple_Check(obj0) ?
1683	>	PyTuple_Size(obj0) :
1684	>	PyList_Size(obj0));
1685	>	temp1 = std::vector<std::string >(size);
1686	>	arg1 = &temp1;
1687	>	for (unsigned int i=0; i<size; i++) {
1688	>	PyObject* o = PySequence_GetItem(obj0,i);
1689	>	if (PyString_Check(o)) {
1690	>	temp1[i] = (std::string)(\
1691	>	SwigString_AsString(o));
1692	>	Py_DECREF(o);
1693	>	}else {
1694	>	Py_DECREF(o);
1695	>	PyErr_SetString(PyExc_TypeError,
1696	>	"vector<""std::string""> expected");
1697	>	SWIG_fail;
1698	>	}
1699	>	}
1700	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1701	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1702	>	arg1 = v1;
1703	>	}else {
1704	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1705	>	SWIG_fail;
1706	>	}
1707	>	}
1708		{
1709		try {
1710	<	result = (PyObject *)BossSession_showCHTools__SWIG_1(arg1);
1710	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1711
1712		}catch (const std::exception& e) {
1713		SWIG_exception(SWIG_RuntimeError, e.what());
1714		}
1715		}
1716	<	resultobj = result;
1716	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1717		return resultobj;
1718		fail:
1719		return NULL;
1720		}
1721
1722
1723	<	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
1723	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1724		int argc;
1725	<	PyObject *argv[2];
1725	>	PyObject *argv[3];
1726		int ii;
1727
1728		argc = PyObject_Length(args);
1729	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1729	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1730		argv[ii] = PyTuple_GetItem(args,ii);
1731		}
1732	+	if ((argc >= 0) && (argc <= 1)) {
1733	+	int _v;
1734	+	if (argc <= 0) {
1735	+	return _wrap_new_vector_string__SWIG_0(self,args);
1736	+	}
1737	+	{
1738	+	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1739	+	}
1740	+	if (_v) {
1741	+	return _wrap_new_vector_string__SWIG_0(self,args);
1742	+	}
1743	+	}
1744		if (argc == 1) {
1745		int _v;
1746		{
1747	<	void *ptr;
1748	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1749	<	_v = 0;
1750	<	PyErr_Clear();
1747	>	/* native sequence? */
1748	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1749	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1750	>	PyTuple_Size(argv[0]) :
1751	>	PyList_Size(argv[0]));
1752	>	if (size == 0) {
1753	>	/* an empty sequence can be of any type */
1754	>	_v = 1;
1755	>	}else {
1756	>	/* check the first element only */
1757	>	PyObject* o = PySequence_GetItem(argv[0],0);
1758	>	if (PyString_Check(o))
1759	>	_v = 1;
1760	>	else
1761	>	_v = 0;
1762	>	Py_DECREF(o);
1763	>	}
1764		}else {
1765	+	/* wrapped vector? */
1766	+	std::vector<std::string >* v;
1767	+	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1768	+	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1769		_v = 1;
1770	+	else
1771	+	_v = 0;
1772		}
1773		}
1774		if (_v) {
1775	<	return _wrap_BossSession_showCHTools__SWIG_1(self,args);
1775	>	return _wrap_new_vector_string__SWIG_2(self,args);
1776	>	}
1777	>	}
1778	>	if (argc == 2) {
1779	>	int _v;
1780	>	{
1781	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1782	>	}
1783	>	if (_v) {
1784	>	{
1785	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1786	>	}
1787	>	if (_v) {
1788	>	return _wrap_new_vector_string__SWIG_1(self,args);
1789	>	}
1790		}
1791		}
1792
1793	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showCHTools'");
1793	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1794		return NULL;
1795		}
1796
1797
1798	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_1(PyObject *self, PyObject *args) {
1798	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1799		PyObject *resultobj;
1800	<	BossSession *arg1 = (BossSession *) 0 ;
1801	<	PyObject *result;
1800	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1801	>	unsigned int result;
1802	>	std::vector<std::string > temp1 ;
1803	>	std::vector<std::string > *v1 ;
1804		PyObject * obj0 = 0 ;
1805
1806	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
1807	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1806	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1807	>	{
1808	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1809	>	unsigned int size = (PyTuple_Check(obj0) ?
1810	>	PyTuple_Size(obj0) :
1811	>	PyList_Size(obj0));
1812	>	temp1 = std::vector<std::string >(size);
1813	>	arg1 = &temp1;
1814	>	for (unsigned int i=0; i<size; i++) {
1815	>	PyObject* o = PySequence_GetItem(obj0,i);
1816	>	if (PyString_Check(o)) {
1817	>	temp1[i] = (std::string)(\
1818	>	SwigString_AsString(o));
1819	>	Py_DECREF(o);
1820	>	}else {
1821	>	Py_DECREF(o);
1822	>	PyErr_SetString(PyExc_TypeError,
1823	>	"vector<""std::string""> expected");
1824	>	SWIG_fail;
1825	>	}
1826	>	}
1827	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1828	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1829	>	arg1 = v1;
1830	>	}else {
1831	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1832	>	SWIG_fail;
1833	>	}
1834	>	}
1835		{
1836		try {
1837	<	result = (PyObject *)BossSession_showProgramTypes__SWIG_1(arg1);
1837	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1838
1839		}catch (const std::exception& e) {
1840		SWIG_exception(SWIG_RuntimeError, e.what());
1841		}
1842		}
1843	<	resultobj = result;
1843	>	resultobj = PyInt_FromLong((long)result);
1844		return resultobj;
1845		fail:
1846		return NULL;
1847		}
1848
1849
1850	<	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
1851	<	int argc;
1852	<	PyObject *argv[2];
1853	<	int ii;
1850	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1851	>	PyObject *resultobj;
1852	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1853	>	bool result;
1854	>	std::vector<std::string > temp1 ;
1855	>	std::vector<std::string > *v1 ;
1856	>	PyObject * obj0 = 0 ;
1857
1858	<	argc = PyObject_Length(args);
1859	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1860	<	argv[ii] = PyTuple_GetItem(args,ii);
1858	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1859	>	{
1860	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1861	>	unsigned int size = (PyTuple_Check(obj0) ?
1862	>	PyTuple_Size(obj0) :
1863	>	PyList_Size(obj0));
1864	>	temp1 = std::vector<std::string >(size);
1865	>	arg1 = &temp1;
1866	>	for (unsigned int i=0; i<size; i++) {
1867	>	PyObject* o = PySequence_GetItem(obj0,i);
1868	>	if (PyString_Check(o)) {
1869	>	temp1[i] = (std::string)(\
1870	>	SwigString_AsString(o));
1871	>	Py_DECREF(o);
1872	>	}else {
1873	>	Py_DECREF(o);
1874	>	PyErr_SetString(PyExc_TypeError,
1875	>	"vector<""std::string""> expected");
1876	>	SWIG_fail;
1877	>	}
1878	>	}
1879	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1880	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1881	>	arg1 = v1;
1882	>	}else {
1883	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1884	>	SWIG_fail;
1885	>	}
1886		}
1887	<	if (argc == 1) {
1888	<	int _v;
1889	<	{
1890	<	void *ptr;
1891	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1892	<	_v = 0;
1893	<	PyErr_Clear();
1894	<	}else {
1895	<	_v = 1;
1887	>	{
1888	>	try {
1889	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1890	>
1891	>	}catch (const std::exception& e) {
1892	>	SWIG_exception(SWIG_RuntimeError, e.what());
1893	>	}
1894	>	}
1895	>	resultobj = PyInt_FromLong((long)result);
1896	>	return resultobj;
1897	>	fail:
1898	>	return NULL;
1899	>	}
1900	>
1901	>
1902	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1903	>	PyObject *resultobj;
1904	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1905	>	PyObject * obj0 = 0 ;
1906	>
1907	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1908	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1909	>	{
1910	>	try {
1911	>	(arg1)->clear();
1912	>
1913	>	}catch (const std::exception& e) {
1914	>	SWIG_exception(SWIG_RuntimeError, e.what());
1915	>	}
1916	>	}
1917	>	Py_INCREF(Py_None); resultobj = Py_None;
1918	>	return resultobj;
1919	>	fail:
1920	>	return NULL;
1921	>	}
1922	>
1923	>
1924	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1925	>	PyObject *resultobj;
1926	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1927	>	std::string arg2 ;
1928	>	PyObject * obj0 = 0 ;
1929	>	PyObject * obj1 = 0 ;
1930	>
1931	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
1932	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1933	>	{
1934	>	if (PyString_Check(obj1))
1935	>	arg2 = std::string(PyString_AsString(obj1));
1936	>	else
1937	>	SWIG_exception(SWIG_TypeError, "string expected");
1938	>	}
1939	>	{
1940	>	try {
1941	>	(arg1)->push_back(arg2);
1942	>
1943	>	}catch (const std::exception& e) {
1944	>	SWIG_exception(SWIG_RuntimeError, e.what());
1945	>	}
1946	>	}
1947	>	Py_INCREF(Py_None); resultobj = Py_None;
1948	>	return resultobj;
1949	>	fail:
1950	>	return NULL;
1951	>	}
1952	>
1953	>
1954	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
1955	>	PyObject *resultobj;
1956	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1957	>	std::string result;
1958	>	PyObject * obj0 = 0 ;
1959	>
1960	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
1961	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1962	>	{
1963	>	try {
1964	>	result = std_vectorlstd_string_g_pop___(arg1);
1965	>
1966	>	}catch (std::out_of_range& e) {
1967	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1968	>	}
1969	>	}
1970	>	{
1971	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1972	>	}
1973	>	return resultobj;
1974	>	fail:
1975	>	return NULL;
1976	>	}
1977	>
1978	>
1979	>	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
1980	>	PyObject *resultobj;
1981	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1982	>	int arg2 ;
1983	>	std::string result;
1984	>	PyObject * obj0 = 0 ;
1985	>
1986	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
1987	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1988	>	{
1989	>	try {
1990	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
1991	>
1992	>	}catch (std::out_of_range& e) {
1993	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1994	>	}
1995	>	}
1996	>	{
1997	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1998	>	}
1999	>	return resultobj;
2000	>	fail:
2001	>	return NULL;
2002	>	}
2003	>
2004	>
2005	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2006	>	PyObject *resultobj;
2007	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2008	>	int arg2 ;
2009	>	int arg3 ;
2010	>	std::vector<std::string > result;
2011	>	PyObject * obj0 = 0 ;
2012	>
2013	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2014	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2015	>	{
2016	>	try {
2017	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2018	>
2019	>	}catch (const std::exception& e) {
2020	>	SWIG_exception(SWIG_RuntimeError, e.what());
2021	>	}
2022	>	}
2023	>	{
2024	>	resultobj = PyTuple_New((&result)->size());
2025	>	for (unsigned int i=0; i<(&result)->size(); i++)
2026	>	PyTuple_SetItem(resultobj,i,
2027	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2028	>	}
2029	>	return resultobj;
2030	>	fail:
2031	>	return NULL;
2032	>	}
2033	>
2034	>
2035	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2036	>	PyObject *resultobj;
2037	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2038	>	int arg2 ;
2039	>	std::string arg3 ;
2040	>	PyObject * obj0 = 0 ;
2041	>	PyObject * obj2 = 0 ;
2042	>
2043	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2044	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2045	>	{
2046	>	if (PyString_Check(obj2))
2047	>	arg3 = std::string(PyString_AsString(obj2));
2048	>	else
2049	>	SWIG_exception(SWIG_TypeError, "string expected");
2050	>	}
2051	>	{
2052	>	try {
2053	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2054	>
2055	>	}catch (std::out_of_range& e) {
2056	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2057	>	}
2058	>	}
2059	>	Py_INCREF(Py_None); resultobj = Py_None;
2060	>	return resultobj;
2061	>	fail:
2062	>	return NULL;
2063	>	}
2064	>
2065	>
2066	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2067	>	PyObject *resultobj;
2068	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2069	>	int arg2 ;
2070	>	int arg3 ;
2071	>	std::vector<std::string > *arg4 = 0 ;
2072	>	std::vector<std::string > temp4 ;
2073	>	std::vector<std::string > *v4 ;
2074	>	PyObject * obj0 = 0 ;
2075	>	PyObject * obj3 = 0 ;
2076	>
2077	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2078	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2079	>	{
2080	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2081	>	unsigned int size = (PyTuple_Check(obj3) ?
2082	>	PyTuple_Size(obj3) :
2083	>	PyList_Size(obj3));
2084	>	temp4 = std::vector<std::string >(size);
2085	>	arg4 = &temp4;
2086	>	for (unsigned int i=0; i<size; i++) {
2087	>	PyObject* o = PySequence_GetItem(obj3,i);
2088	>	if (PyString_Check(o)) {
2089	>	temp4[i] = (std::string)(\
2090	>	SwigString_AsString(o));
2091	>	Py_DECREF(o);
2092	>	}else {
2093	>	Py_DECREF(o);
2094	>	PyErr_SetString(PyExc_TypeError,
2095	>	"vector<""std::string""> expected");
2096	>	SWIG_fail;
2097	>	}
2098		}
2099	+	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2100	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2101	+	arg4 = v4;
2102	+	}else {
2103	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2104	+	SWIG_fail;
2105		}
2106	<	if (_v) {
2107	<	return _wrap_BossSession_showProgramTypes__SWIG_1(self,args);
2106	>	}
2107	>	{
2108	>	try {
2109	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2110	>
2111	>	}catch (const std::exception& e) {
2112	>	SWIG_exception(SWIG_RuntimeError, e.what());
2113	>	}
2114	>	}
2115	>	Py_INCREF(Py_None); resultobj = Py_None;
2116	>	return resultobj;
2117	>	fail:
2118	>	return NULL;
2119	>	}
2120	>
2121	>
2122	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2123	>	PyObject *resultobj;
2124	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2125	>	int arg2 ;
2126	>	PyObject * obj0 = 0 ;
2127	>
2128	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2129	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2130	>	{
2131	>	try {
2132	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2133	>
2134	>	}catch (std::out_of_range& e) {
2135	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2136	>	}
2137	>	}
2138	>	Py_INCREF(Py_None); resultobj = Py_None;
2139	>	return resultobj;
2140	>	fail:
2141	>	return NULL;
2142	>	}
2143	>
2144	>
2145	>	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2146	>	PyObject *resultobj;
2147	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2148	>	int arg2 ;
2149	>	int arg3 ;
2150	>	PyObject * obj0 = 0 ;
2151	>
2152	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2153	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2154	>	{
2155	>	try {
2156	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2157	>
2158	>	}catch (const std::exception& e) {
2159	>	SWIG_exception(SWIG_RuntimeError, e.what());
2160		}
2161		}
2162	+	Py_INCREF(Py_None); resultobj = Py_None;
2163	+	return resultobj;
2164	+	fail:
2165	+	return NULL;
2166	+	}
2167	+
2168	+
2169	+	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2170	+	PyObject *resultobj;
2171	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2172	+	PyObject * obj0 = 0 ;
2173
2174	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showProgramTypes'");
2174	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2175	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2176	>	{
2177	>	try {
2178	>	delete arg1;
2179	>
2180	>	}catch (const std::exception& e) {
2181	>	SWIG_exception(SWIG_RuntimeError, e.what());
2182	>	}
2183	>	}
2184	>	Py_INCREF(Py_None); resultobj = Py_None;
2185	>	return resultobj;
2186	>	fail:
2187		return NULL;
2188		}
2189
2190
2191	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_1(PyObject *self, PyObject *args) {
2191	>	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2192	>	PyObject *obj;
2193	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2194	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2195	>	Py_INCREF(obj);
2196	>	return Py_BuildValue((char *)"");
2197	>	}
2198	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
2199		PyObject *resultobj;
2200		BossSession *arg1 = (BossSession *) 0 ;
2201	+	std::vector<std::string > *arg2 = 0 ;
2202		PyObject *result;
2203		PyObject * obj0 = 0 ;
2204	+	PyObject * obj1 = 0 ;
2205
2206	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2206	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2207		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2208	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2209	+	if (arg2 == NULL) {
2210	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2211	+	}
2212		{
2213		try {
2214	<	result = (PyObject *)BossSession_showRTMon__SWIG_1(arg1);
2214	>	result = (PyObject *)BossSession_show(arg1,*arg2);
2215
2216		}catch (const std::exception& e) {
2217		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1690 | Line 2224 | static PyObject *_wrap_BossSession_showR
2224		}
2225
2226
2227	<	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2228	<	int argc;
2229	<	PyObject *argv[2];
2230	<	int ii;
2227	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
2228	>	PyObject *resultobj;
2229	>	BossSession *arg1 = (BossSession *) 0 ;
2230	>	PyObject *result;
2231	>	PyObject * obj0 = 0 ;
2232
2233	<	argc = PyObject_Length(args);
2234	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2235	<	argv[ii] = PyTuple_GetItem(args,ii);
2236	<	}
2237	<	if (argc == 1) {
2238	<	int _v;
2239	<	{
2240	<	void *ptr;
1706	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1707	<	_v = 0;
1708	<	PyErr_Clear();
1709	<	}else {
1710	<	_v = 1;
1711	<	}
2233	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2234	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2235	>	{
2236	>	try {
2237	>	result = (PyObject *)BossSession_CHTools(arg1);
2238	>
2239	>	}catch (const std::exception& e) {
2240	>	SWIG_exception(SWIG_RuntimeError, e.what());
2241		}
2242	<	if (_v) {
2243	<	return _wrap_BossSession_showRTMon__SWIG_1(self,args);
2242	>	}
2243	>	resultobj = result;
2244	>	return resultobj;
2245	>	fail:
2246	>	return NULL;
2247	>	}
2248	>
2249	>
2250	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
2251	>	PyObject *resultobj;
2252	>	BossSession *arg1 = (BossSession *) 0 ;
2253	>	PyObject *result;
2254	>	PyObject * obj0 = 0 ;
2255	>
2256	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2257	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2258	>	{
2259	>	try {
2260	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
2261	>
2262	>	}catch (const std::exception& e) {
2263	>	SWIG_exception(SWIG_RuntimeError, e.what());
2264		}
2265		}
2266	+	resultobj = result;
2267	+	return resultobj;
2268	+	fail:
2269	+	return NULL;
2270	+	}
2271	+
2272	+
2273	+	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
2274	+	PyObject *resultobj;
2275	+	BossSession *arg1 = (BossSession *) 0 ;
2276	+	PyObject *result;
2277	+	PyObject * obj0 = 0 ;
2278
2279	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showRTMon'");
2279	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2280	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2281	>	{
2282	>	try {
2283	>	result = (PyObject *)BossSession_RTMons(arg1);
2284	>
2285	>	}catch (const std::exception& e) {
2286	>	SWIG_exception(SWIG_RuntimeError, e.what());
2287	>	}
2288	>	}
2289	>	resultobj = result;
2290	>	return resultobj;
2291	>	fail:
2292		return NULL;
2293		}
2294
2295
2296	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_1(PyObject *self, PyObject *args) {
2296	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
2297		PyObject *resultobj;
2298		BossSession *arg1 = (BossSession *) 0 ;
2299		PyObject *result;
2300		PyObject * obj0 = 0 ;
2301
2302	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2302	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2303		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2304		{
2305		try {
2306	<	result = (PyObject *)BossSession_showSchedulers__SWIG_1(arg1);
2306	>	result = (PyObject *)BossSession_schedulers(arg1);
2307
2308		}catch (const std::exception& e) {
2309		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1743 | Line 2316 | static PyObject *_wrap_BossSession_showS
2316		}
2317
2318
2319	<	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2320	<	int argc;
2321	<	PyObject *argv[2];
2322	<	int ii;
2319	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
2320	>	PyObject *resultobj;
2321	>	BossSession *arg1 = (BossSession *) 0 ;
2322	>	std::string *arg2 = 0 ;
2323	>	std::string *arg3 = 0 ;
2324	>	std::string const &arg4_defvalue = "" ;
2325	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
2326	>	std::string const &arg5_defvalue = "" ;
2327	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2328	>	bool arg6 = (bool) false ;
2329	>	PyObject *result;
2330	>	std::string temp2 ;
2331	>	std::string temp3 ;
2332	>	std::string temp4 ;
2333	>	std::string temp5 ;
2334	>	PyObject * obj0 = 0 ;
2335	>	PyObject * obj1 = 0 ;
2336	>	PyObject * obj2 = 0 ;
2337	>	PyObject * obj3 = 0 ;
2338	>	PyObject * obj4 = 0 ;
2339	>	PyObject * obj5 = 0 ;
2340
2341	<	argc = PyObject_Length(args);
2342	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2343	<	argv[ii] = PyTuple_GetItem(args,ii);
2341	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2342	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2343	>	{
2344	>	if (PyString_Check(obj1)) {
2345	>	temp2 = std::string(PyString_AsString(obj1));
2346	>	arg2 = &temp2;
2347	>	}else {
2348	>	SWIG_exception(SWIG_TypeError, "string expected");
2349	>	}
2350		}
2351	<	if (argc == 1) {
2352	<	int _v;
2351	>	{
2352	>	if (PyString_Check(obj2)) {
2353	>	temp3 = std::string(PyString_AsString(obj2));
2354	>	arg3 = &temp3;
2355	>	}else {
2356	>	SWIG_exception(SWIG_TypeError, "string expected");
2357	>	}
2358	>	}
2359	>	if (obj3) {
2360		{
2361	<	void *ptr;
2362	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
2363	<	_v = 0;
1761	<	PyErr_Clear();
2361	>	if (PyString_Check(obj3)) {
2362	>	temp4 = std::string(PyString_AsString(obj3));
2363	>	arg4 = &temp4;
2364		}else {
2365	<	_v = 1;
2365	>	SWIG_exception(SWIG_TypeError, "string expected");
2366		}
2367		}
2368	<	if (_v) {
2369	<	return _wrap_BossSession_showSchedulers__SWIG_1(self,args);
2368	>	}
2369	>	if (obj4) {
2370	>	{
2371	>	if (PyString_Check(obj4)) {
2372	>	temp5 = std::string(PyString_AsString(obj4));
2373	>	arg5 = &temp5;
2374	>	}else {
2375	>	SWIG_exception(SWIG_TypeError, "string expected");
2376	>	}
2377		}
2378		}
2379	<
2380	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showSchedulers'");
2379	>	if (obj5) {
2380	>	arg6 = PyInt_AsLong(obj5) ? true : false;
2381	>	if (PyErr_Occurred()) SWIG_fail;
2382	>	}
2383	>	{
2384	>	try {
2385	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
2386	>
2387	>	}catch (const std::exception& e) {
2388	>	SWIG_exception(SWIG_RuntimeError, e.what());
2389	>	}
2390	>	}
2391	>	resultobj = result;
2392	>	return resultobj;
2393	>	fail:
2394		return NULL;
2395		}
2396
#	Line 1937 | Line 2559 | static PyObject *_wrap_delete_BossSessio
2559		}
2560
2561
2562	+	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2563	+	PyObject *resultobj;
2564	+	BossSession *arg1 = (BossSession *) 0 ;
2565	+	PyObject * obj0 = 0 ;
2566	+
2567	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2568	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2569	+	{
2570	+	try {
2571	+	(arg1)->clear();
2572	+
2573	+	}catch (const std::exception& e) {
2574	+	SWIG_exception(SWIG_RuntimeError, e.what());
2575	+	}
2576	+	}
2577	+	Py_INCREF(Py_None); resultobj = Py_None;
2578	+	return resultobj;
2579	+	fail:
2580	+	return NULL;
2581	+	}
2582	+
2583	+
2584		static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2585		PyObject *resultobj;
2586		BossSession *arg1 = (BossSession *) 0 ;
#	Line 1999 | Line 2643 | static PyObject *_wrap_BossSession_destr
2643		}
2644
2645
2002	–	static PyObject *_wrap_BossSession_showCHTools__SWIG_0(PyObject *self, PyObject *args) {
2003	–	PyObject *resultobj;
2004	–	BossSession *arg1 = (BossSession *) 0 ;
2005	–	SwigValueWrapper< std::vector<std::string > > result;
2006	–	PyObject * obj0 = 0 ;
2007	–
2008	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2009	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2010	–	{
2011	–	try {
2012	–	result = (arg1)->showCHTools();
2013	–
2014	–	}catch (const std::exception& e) {
2015	–	SWIG_exception(SWIG_RuntimeError, e.what());
2016	–	}
2017	–	}
2018	–	{
2019	–	std::vector<std::string > * resultptr;
2020	–	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2021	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2022	–	}
2023	–	return resultobj;
2024	–	fail:
2025	–	return NULL;
2026	–	}
2027	–
2028	–
2029	–	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_0(PyObject *self, PyObject *args) {
2030	–	PyObject *resultobj;
2031	–	BossSession *arg1 = (BossSession *) 0 ;
2032	–	SwigValueWrapper< std::vector<std::string > > result;
2033	–	PyObject * obj0 = 0 ;
2034	–
2035	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2036	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2037	–	{
2038	–	try {
2039	–	result = (arg1)->showProgramTypes();
2040	–
2041	–	}catch (const std::exception& e) {
2042	–	SWIG_exception(SWIG_RuntimeError, e.what());
2043	–	}
2044	–	}
2045	–	{
2046	–	std::vector<std::string > * resultptr;
2047	–	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2048	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2049	–	}
2050	–	return resultobj;
2051	–	fail:
2052	–	return NULL;
2053	–	}
2054	–
2055	–
2056	–	static PyObject *_wrap_BossSession_showRTMon__SWIG_0(PyObject *self, PyObject *args) {
2057	–	PyObject *resultobj;
2058	–	BossSession *arg1 = (BossSession *) 0 ;
2059	–	SwigValueWrapper< std::vector<std::string > > result;
2060	–	PyObject * obj0 = 0 ;
2061	–
2062	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2063	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2064	–	{
2065	–	try {
2066	–	result = (arg1)->showRTMon();
2067	–
2068	–	}catch (const std::exception& e) {
2069	–	SWIG_exception(SWIG_RuntimeError, e.what());
2070	–	}
2071	–	}
2072	–	{
2073	–	std::vector<std::string > * resultptr;
2074	–	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2075	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2076	–	}
2077	–	return resultobj;
2078	–	fail:
2079	–	return NULL;
2080	–	}
2081	–
2082	–
2083	–	static PyObject *_wrap_BossSession_showSchedulers__SWIG_0(PyObject *self, PyObject *args) {
2084	–	PyObject *resultobj;
2085	–	BossSession *arg1 = (BossSession *) 0 ;
2086	–	SwigValueWrapper< std::vector<std::string > > result;
2087	–	PyObject * obj0 = 0 ;
2088	–
2089	–	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2090	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2091	–	{
2092	–	try {
2093	–	result = (arg1)->showSchedulers();
2094	–
2095	–	}catch (const std::exception& e) {
2096	–	SWIG_exception(SWIG_RuntimeError, e.what());
2097	–	}
2098	–	}
2099	–	{
2100	–	std::vector<std::string > * resultptr;
2101	–	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2102	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
2103	–	}
2104	–	return resultobj;
2105	–	fail:
2106	–	return NULL;
2107	–	}
2108	–
2109	–
2646		static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
2647		PyObject *resultobj;
2648		BossSession *arg1 = (BossSession *) 0 ;
#	Line 2286 | Line 2822 | static PyObject *_wrap_BossSession_showC
2822		}
2823
2824
2289	–	static PyObject *_wrap_BossSession_purgeTasks(PyObject *self, PyObject *args) {
2290	–	PyObject *resultobj;
2291	–	BossSession *arg1 = (BossSession *) 0 ;
2292	–	std::string *arg2 = 0 ;
2293	–	std::string *arg3 = 0 ;
2294	–	std::string *arg4 = 0 ;
2295	–	std::string const &arg5_defvalue = "0" ;
2296	–	std::string *arg5 = (std::string *) &arg5_defvalue ;
2297	–	int result;
2298	–	std::string temp2 ;
2299	–	std::string temp3 ;
2300	–	std::string temp4 ;
2301	–	std::string temp5 ;
2302	–	PyObject * obj0 = 0 ;
2303	–	PyObject * obj1 = 0 ;
2304	–	PyObject * obj2 = 0 ;
2305	–	PyObject * obj3 = 0 ;
2306	–	PyObject * obj4 = 0 ;
2307	–
2308	–	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossSession_purgeTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
2309	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2310	–	{
2311	–	if (PyString_Check(obj1)) {
2312	–	temp2 = std::string(PyString_AsString(obj1));
2313	–	arg2 = &temp2;
2314	–	}else {
2315	–	SWIG_exception(SWIG_TypeError, "string expected");
2316	–	}
2317	–	}
2318	–	{
2319	–	if (PyString_Check(obj2)) {
2320	–	temp3 = std::string(PyString_AsString(obj2));
2321	–	arg3 = &temp3;
2322	–	}else {
2323	–	SWIG_exception(SWIG_TypeError, "string expected");
2324	–	}
2325	–	}
2326	–	{
2327	–	if (PyString_Check(obj3)) {
2328	–	temp4 = std::string(PyString_AsString(obj3));
2329	–	arg4 = &temp4;
2330	–	}else {
2331	–	SWIG_exception(SWIG_TypeError, "string expected");
2332	–	}
2333	–	}
2334	–	if (obj4) {
2335	–	{
2336	–	if (PyString_Check(obj4)) {
2337	–	temp5 = std::string(PyString_AsString(obj4));
2338	–	arg5 = &temp5;
2339	–	}else {
2340	–	SWIG_exception(SWIG_TypeError, "string expected");
2341	–	}
2342	–	}
2343	–	}
2344	–	{
2345	–	try {
2346	–	result = (int)(arg1)->purgeTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
2347	–
2348	–	}catch (const std::exception& e) {
2349	–	SWIG_exception(SWIG_RuntimeError, e.what());
2350	–	}
2351	–	}
2352	–	resultobj = PyInt_FromLong((long)result);
2353	–	return resultobj;
2354	–	fail:
2355	–	return NULL;
2356	–	}
2357	–
2358	–
2825		static PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2826		PyObject *resultobj;
2827		BossSession *arg1 = (BossSession *) 0 ;
#	Line 2419 | Line 2885 | static PyObject *_wrap_BossSession_listM
2885		std::string *arg5 = (std::string *) &arg5_defvalue ;
2886		std::string const &arg6_defvalue = "" ;
2887		std::string *arg6 = (std::string *) &arg6_defvalue ;
2888	<	std::string result;
2888	>	std::vector<std::string > result;
2889		std::string temp2 ;
2890		std::string temp3 ;
2891		std::string temp5 ;
#	Line 2482 | Line 2948 | static PyObject *_wrap_BossSession_listM
2948		}
2949		}
2950		{
2951	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2951	>	resultobj = PyTuple_New((&result)->size());
2952	>	for (unsigned int i=0; i<(&result)->size(); i++)
2953	>	PyTuple_SetItem(resultobj,i,
2954	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2955		}
2956		return resultobj;
2957		fail:
#	Line 2490 | Line 2959 | static PyObject *_wrap_BossSession_listM
2959		}
2960
2961
2962	<	static PyObject *_wrap_BossSession_jobQuery(PyObject *self, PyObject *args) {
2962	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
2963		PyObject *resultobj;
2964		BossSession *arg1 = (BossSession *) 0 ;
2965		int arg2 = (int) SCHEDULED ;
#	Line 2504 | Line 2973 | static PyObject *_wrap_BossSession_jobQu
2973		std::string arg7 = (std::string) "" ;
2974		std::string arg8 = (std::string) "" ;
2975		std::string arg9 = (std::string) "" ;
2507	–	bool arg10 = (bool) false ;
2508	–	SwigValueWrapper< std::vector<BossJob * > > result;
2976		std::string temp3 ;
2977		std::string temp4 ;
2978		std::string temp5 ;
#	Line 2517 | Line 2984 | static PyObject *_wrap_BossSession_jobQu
2984		PyObject * obj6 = 0 ;
2985		PyObject * obj7 = 0 ;
2986		PyObject * obj8 = 0 ;
2520	–	PyObject * obj9 = 0 ;
2987
2988	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_jobQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2988	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
2989		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2990		if (obj2) {
2991		{
#	Line 2583 | Line 3049 | static PyObject *_wrap_BossSession_jobQu
3049		SWIG_exception(SWIG_TypeError, "string expected");
3050		}
3051		}
2586	–	if (obj9) {
2587	–	arg10 = PyInt_AsLong(obj9) ? true : false;
2588	–	if (PyErr_Occurred()) SWIG_fail;
2589	–	}
3052		{
3053		try {
3054	<	result = (arg1)->jobQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3054	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3055
3056		}catch (const std::exception& e) {
3057		SWIG_exception(SWIG_RuntimeError, e.what());
3058		}
3059		}
3060	<	{
2599	<	std::vector<BossJob * > * resultptr;
2600	<	resultptr = new std::vector<BossJob * >((std::vector<BossJob * > &) result);
2601	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossJob_p_t, 1);
2602	<	}
3060	>	Py_INCREF(Py_None); resultobj = Py_None;
3061		return resultobj;
3062		fail:
3063		return NULL;
3064		}
3065
3066
3067	<	static PyObject *_wrap_BossSession_queryPrint(PyObject *self, PyObject *args) {
3067	>	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3068		PyObject *resultobj;
3069		BossSession *arg1 = (BossSession *) 0 ;
3070	<	SwigValueWrapper< std::vector<BossJob * > > arg2 ;
3071	<	std::ostream &arg3_defvalue = std::cout ;
3072	<	std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
3073	<	jobStates const &arg4_defvalue = SCHEDULED ;
3074	<	jobStates *arg4 = (jobStates *) &arg4_defvalue ;
3075	<	printOption const &arg5_defvalue = NORMAL ;
3076	<	printOption *arg5 = (printOption *) &arg5_defvalue ;
3077	<	std::string const &arg6_defvalue = "" ;
3078	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
3079	<	std::vector<BossJob * > *argp2 ;
3080	<	std::string temp6 ;
3070	>	std::string const &arg2_defvalue = "all" ;
3071	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3072	>	std::string const &arg3_defvalue = "" ;
3073	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3074	>	std::string const &arg4_defvalue = "" ;
3075	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3076	>	std::string const &arg5_defvalue = "" ;
3077	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3078	>	std::vector<std::string > result;
3079	>	std::string temp2 ;
3080	>	std::string temp3 ;
3081	>	std::string temp4 ;
3082	>	std::string temp5 ;
3083		PyObject * obj0 = 0 ;
3084		PyObject * obj1 = 0 ;
3085		PyObject * obj2 = 0 ;
3086		PyObject * obj3 = 0 ;
3087		PyObject * obj4 = 0 ;
2628	–	PyObject * obj5 = 0 ;
3088
3089	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossSession_queryPrint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3089	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3090		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3091	<	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3092	<	arg2 = *argp2;
3091	>	if (obj1) {
3092	>	{
3093	>	if (PyString_Check(obj1)) {
3094	>	temp2 = std::string(PyString_AsString(obj1));
3095	>	arg2 = &temp2;
3096	>	}else {
3097	>	SWIG_exception(SWIG_TypeError, "string expected");
3098	>	}
3099	>	}
3100	>	}
3101		if (obj2) {
3102	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3103	<	if (arg3 == NULL) {
3104	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3102	>	{
3103	>	if (PyString_Check(obj2)) {
3104	>	temp3 = std::string(PyString_AsString(obj2));
3105	>	arg3 = &temp3;
3106	>	}else {
3107	>	SWIG_exception(SWIG_TypeError, "string expected");
3108	>	}
3109		}
3110		}
3111		if (obj3) {
3112	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3113	<	if (arg4 == NULL) {
3114	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3112	>	{
3113	>	if (PyString_Check(obj3)) {
3114	>	temp4 = std::string(PyString_AsString(obj3));
3115	>	arg4 = &temp4;
3116	>	}else {
3117	>	SWIG_exception(SWIG_TypeError, "string expected");
3118	>	}
3119		}
3120		}
3121		if (obj4) {
2647	–	if ((SWIG_ConvertPtr(obj4,(void **) &arg5, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2648	–	if (arg5 == NULL) {
2649	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2650	–	}
2651	–	}
2652	–	if (obj5) {
3122		{
3123	<	if (PyString_Check(obj5)) {
3124	<	temp6 = std::string(PyString_AsString(obj5));
3125	<	arg6 = &temp6;
3123	>	if (PyString_Check(obj4)) {
3124	>	temp5 = std::string(PyString_AsString(obj4));
3125	>	arg5 = &temp5;
3126		}else {
3127		SWIG_exception(SWIG_TypeError, "string expected");
3128		}
#	Line 2661 | Line 3130 | static PyObject *_wrap_BossSession_query
3130		}
3131		{
3132		try {
3133	<	(arg1)->queryPrint(arg2,*arg3,(jobStates const &)*arg4,(printOption const &)*arg5,(std::string const &)*arg6);
3133	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3134
3135		}catch (const std::exception& e) {
3136		SWIG_exception(SWIG_RuntimeError, e.what());
3137		}
3138		}
3139	<	Py_INCREF(Py_None); resultobj = Py_None;
3139	>	{
3140	>	resultobj = PyTuple_New((&result)->size());
3141	>	for (unsigned int i=0; i<(&result)->size(); i++)
3142	>	PyTuple_SetItem(resultobj,i,
3143	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3144	>	}
3145		return resultobj;
3146		fail:
3147		return NULL;
3148		}
3149
3150
3151	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3151	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3152		PyObject *resultobj;
3153		BossSession *arg1 = (BossSession *) 0 ;
3154	<	std::string const &arg2_defvalue = "all" ;
3155	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2682	<	std::string const &arg3_defvalue = "" ;
3154	>	int arg2 = (int) SCHEDULED ;
3155	>	std::string const &arg3_defvalue = "all" ;
3156		std::string *arg3 = (std::string *) &arg3_defvalue ;
3157	<	std::string const &arg4_defvalue = "" ;
3157	>	std::string const &arg4_defvalue = "all" ;
3158		std::string *arg4 = (std::string *) &arg4_defvalue ;
3159		std::string const &arg5_defvalue = "" ;
3160		std::string *arg5 = (std::string *) &arg5_defvalue ;
3161	<	SwigValueWrapper< std::vector<std::string > > result;
3162	<	std::string temp2 ;
3161	>	std::string arg6 = (std::string) "" ;
3162	>	std::string arg7 = (std::string) "" ;
3163	>	std::string arg8 = (std::string) "" ;
3164	>	std::string arg9 = (std::string) "" ;
3165	>	bool arg10 = (bool) false ;
3166	>	SwigValueWrapper< std::vector<BossTask * > > result;
3167		std::string temp3 ;
3168		std::string temp4 ;
3169		std::string temp5 ;
3170		PyObject * obj0 = 0 ;
2694	–	PyObject * obj1 = 0 ;
3171		PyObject * obj2 = 0 ;
3172		PyObject * obj3 = 0 ;
3173		PyObject * obj4 = 0 ;
3174	+	PyObject * obj5 = 0 ;
3175	+	PyObject * obj6 = 0 ;
3176	+	PyObject * obj7 = 0 ;
3177	+	PyObject * obj8 = 0 ;
3178	+	PyObject * obj9 = 0 ;
3179
3180	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3180	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3181		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2701	–	if (obj1) {
2702	–	{
2703	–	if (PyString_Check(obj1)) {
2704	–	temp2 = std::string(PyString_AsString(obj1));
2705	–	arg2 = &temp2;
2706	–	}else {
2707	–	SWIG_exception(SWIG_TypeError, "string expected");
2708	–	}
2709	–	}
2710	–	}
3182		if (obj2) {
3183		{
3184		if (PyString_Check(obj2)) {
#	Line 2738 | Line 3209 | static PyObject *_wrap_BossSession_selec
3209		}
3210		}
3211		}
3212	+	if (obj5) {
3213	+	{
3214	+	if (PyString_Check(obj5))
3215	+	arg6 = std::string(PyString_AsString(obj5));
3216	+	else
3217	+	SWIG_exception(SWIG_TypeError, "string expected");
3218	+	}
3219	+	}
3220	+	if (obj6) {
3221	+	{
3222	+	if (PyString_Check(obj6))
3223	+	arg7 = std::string(PyString_AsString(obj6));
3224	+	else
3225	+	SWIG_exception(SWIG_TypeError, "string expected");
3226	+	}
3227	+	}
3228	+	if (obj7) {
3229	+	{
3230	+	if (PyString_Check(obj7))
3231	+	arg8 = std::string(PyString_AsString(obj7));
3232	+	else
3233	+	SWIG_exception(SWIG_TypeError, "string expected");
3234	+	}
3235	+	}
3236	+	if (obj8) {
3237	+	{
3238	+	if (PyString_Check(obj8))
3239	+	arg9 = std::string(PyString_AsString(obj8));
3240	+	else
3241	+	SWIG_exception(SWIG_TypeError, "string expected");
3242	+	}
3243	+	}
3244	+	if (obj9) {
3245	+	arg10 = PyInt_AsLong(obj9) ? true : false;
3246	+	if (PyErr_Occurred()) SWIG_fail;
3247	+	}
3248		{
3249		try {
3250	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3250	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3251
3252		}catch (const std::exception& e) {
3253		SWIG_exception(SWIG_RuntimeError, e.what());
3254		}
3255		}
3256		{
3257	<	std::vector<std::string > * resultptr;
3258	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3259	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3257	>	std::vector<BossTask * > * resultptr;
3258	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3259	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3260		}
3261		return resultobj;
3262		fail:
#	Line 2938 | Line 3445 | static PyObject *_wrap_BossTask_jobDict(
3445		}
3446
3447
3448	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3448	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
3449		PyObject *resultobj;
3450		BossTask *arg1 = (BossTask *) 0 ;
3451		PyObject *result;
3452		PyObject * obj0 = 0 ;
3453
3454	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3454	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3455		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3456		{
3457		try {
3458	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3458	>	result = (PyObject *)BossTask_jobsDict((BossTask const *)arg1);
3459
3460		}catch (const std::exception& e) {
3461		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 2961 | Line 3468 | static PyObject *_wrap_BossTask_jobsMap_
3468		}
3469
3470
2964	–	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
2965	–	int argc;
2966	–	PyObject *argv[2];
2967	–	int ii;
2968	–
2969	–	argc = PyObject_Length(args);
2970	–	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2971	–	argv[ii] = PyTuple_GetItem(args,ii);
2972	–	}
2973	–	if (argc == 1) {
2974	–	int _v;
2975	–	{
2976	–	void *ptr;
2977	–	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
2978	–	_v = 0;
2979	–	PyErr_Clear();
2980	–	}else {
2981	–	_v = 1;
2982	–	}
2983	–	}
2984	–	if (_v) {
2985	–	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
2986	–	}
2987	–	}
2988	–
2989	–	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
2990	–	return NULL;
2991	–	}
2992	–
2993	–
3471		static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3472		PyObject *resultobj;
3473		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3280 | Line 3757 | static PyObject *_wrap_BossTask_name(PyO
3757		}
3758
3759
3760	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
3760	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3761		PyObject *resultobj;
3762		BossTask *arg1 = (BossTask *) 0 ;
3763	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3763	>	std::map<std::string,std::string > result;
3764		PyObject * obj0 = 0 ;
3765
3766	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3766	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3767		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3768		{
3769		try {
3770	<	result = ((BossTask const *)arg1)->jobsMap();
3770	>	result = ((BossTask const *)arg1)->taskMap();
3771
3772		}catch (const std::exception& e) {
3773		SWIG_exception(SWIG_RuntimeError, e.what());
3774		}
3775		}
3776		{
3777	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3778	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3779	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3777	>	resultobj = PyDict_New();
3778	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3779	>	PyDict_SetItem(resultobj,
3780	>	SwigString_FromString(i->first),
3781	>	SwigString_FromString(i->second));
3782	>	}
3783		}
3784		return resultobj;
3785		fail:
#	Line 3307 | Line 3787 | static PyObject *_wrap_BossTask_jobsMap_
3787		}
3788
3789
3790	<	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
3790	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3791		PyObject *resultobj;
3792		BossTask *arg1 = (BossTask *) 0 ;
3793	<	unsigned int arg2 ;
3314	<	std::map<std::string,std::string > result;
3793	>	BossTask::job_iterator result;
3794		PyObject * obj0 = 0 ;
3316	–	PyObject * obj1 = 0 ;
3795
3796	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
3796	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3797		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3320	–	arg2 = (unsigned int) PyInt_AsLong(obj1);
3321	–	if (PyErr_Occurred()) SWIG_fail;
3798		{
3799		try {
3800	<	result = ((BossTask const *)arg1)->jobMap(arg2);
3800	>	result = ((BossTask const *)arg1)->job_begin();
3801
3802		}catch (const std::exception& e) {
3803		SWIG_exception(SWIG_RuntimeError, e.what());
3804		}
3805		}
3806		{
3807	<	resultobj = PyDict_New();
3808	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3809	<	PyDict_SetItem(resultobj,
3810	<	SwigString_FromString(i->first),
3811	<	SwigString_FromString(i->second));
3807	>	BossTask::job_iterator * resultptr;
3808	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3809	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3810	>	}
3811	>	return resultobj;
3812	>	fail:
3813	>	return NULL;
3814	>	}
3815	>
3816	>
3817	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3818	>	PyObject *resultobj;
3819	>	BossTask *arg1 = (BossTask *) 0 ;
3820	>	BossTask::job_iterator result;
3821	>	PyObject * obj0 = 0 ;
3822	>
3823	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3824	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3825	>	{
3826	>	try {
3827	>	result = ((BossTask const *)arg1)->job_end();
3828	>
3829	>	}catch (const std::exception& e) {
3830	>	SWIG_exception(SWIG_RuntimeError, e.what());
3831		}
3832		}
3833	+	{
3834	+	BossTask::job_iterator * resultptr;
3835	+	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3836	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3837	+	}
3838		return resultobj;
3839		fail:
3840		return NULL;
3841		}
3842
3843
3844	<	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
3844	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3845	>	PyObject *resultobj;
3846	>	BossTask *arg1 = (BossTask *) 0 ;
3847	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3848	>	PyObject * obj0 = 0 ;
3849	>
3850	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3851	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3852	>	{
3853	>	try {
3854	>	result = ((BossTask const *)arg1)->jobsMap();
3855	>
3856	>	}catch (const std::exception& e) {
3857	>	SWIG_exception(SWIG_RuntimeError, e.what());
3858	>	}
3859	>	}
3860	>	{
3861	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3862	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3863	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3864	>	}
3865	>	return resultobj;
3866	>	fail:
3867	>	return NULL;
3868	>	}
3869	>
3870	>
3871	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
3872		PyObject *resultobj;
3873		BossTask *arg1 = (BossTask *) 0 ;
3874		SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
#	Line 3377 | Line 3904 | static PyObject *_wrap_BossTask_jobMap__
3904		}
3905
3906
3907	+	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
3908	+	PyObject *resultobj;
3909	+	BossTask *arg1 = (BossTask *) 0 ;
3910	+	unsigned int arg2 ;
3911	+	std::map<std::string,std::string > result;
3912	+	PyObject * obj0 = 0 ;
3913	+	PyObject * obj1 = 0 ;
3914	+
3915	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
3916	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3917	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
3918	+	if (PyErr_Occurred()) SWIG_fail;
3919	+	{
3920	+	try {
3921	+	result = ((BossTask const *)arg1)->jobMap(arg2);
3922	+
3923	+	}catch (const std::exception& e) {
3924	+	SWIG_exception(SWIG_RuntimeError, e.what());
3925	+	}
3926	+	}
3927	+	{
3928	+	resultobj = PyDict_New();
3929	+	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3930	+	PyDict_SetItem(resultobj,
3931	+	SwigString_FromString(i->first),
3932	+	SwigString_FromString(i->second));
3933	+	}
3934	+	}
3935	+	return resultobj;
3936	+	fail:
3937	+	return NULL;
3938	+	}
3939	+
3940	+
3941		static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
3942		int argc;
3943		PyObject *argv[4];
#	Line 3402 | Line 3963 | static PyObject *_wrap_BossTask_jobMap(P
3963		_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
3964		}
3965		if (_v) {
3966	<	return _wrap_BossTask_jobMap__SWIG_0(self,args);
3966	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
3967		}
3968		}
3969		}
#	Line 3438 | Line 3999 | static PyObject *_wrap_BossTask_jobMap(P
3999		}
4000		}
4001		if (_v) {
4002	<	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4002	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4003		}
4004		}
4005		}
#	Line 3449 | Line 4010 | static PyObject *_wrap_BossTask_jobMap(P
4010		}
4011
4012
4013	<	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3453	<	PyObject *resultobj;
3454	<	BossTask *arg1 = (BossTask *) 0 ;
3455	<	BossTask::job_iterator result;
3456	<	PyObject * obj0 = 0 ;
3457	<
3458	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3459	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3460	<	{
3461	<	try {
3462	<	result = ((BossTask const *)arg1)->job_begin();
3463	<
3464	<	}catch (const std::exception& e) {
3465	<	SWIG_exception(SWIG_RuntimeError, e.what());
3466	<	}
3467	<	}
3468	<	{
3469	<	BossTask::job_iterator * resultptr;
3470	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3471	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3472	<	}
3473	<	return resultobj;
3474	<	fail:
3475	<	return NULL;
3476	<	}
3477	<
3478	<
3479	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4013	>	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4014		PyObject *resultobj;
4015		BossTask *arg1 = (BossTask *) 0 ;
4016	<	BossTask::job_iterator result;
4016	>	BossJob *arg2 = (BossJob *) 0 ;
4017	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4018		PyObject * obj0 = 0 ;
4019	+	PyObject * obj1 = 0 ;
4020
4021	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4021	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4022		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4023	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4024		{
4025		try {
4026	<	result = ((BossTask const *)arg1)->job_end();
4026	>	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4027
4028		}catch (const std::exception& e) {
4029		SWIG_exception(SWIG_RuntimeError, e.what());
4030		}
4031		}
4032		{
4033	<	BossTask::job_iterator * resultptr;
4034	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4035	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4033	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4034	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4035	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4036		}
4037		return resultobj;
4038		fail:
#	Line 3533 | Line 4070 | static PyObject *_wrap_BossTask_queryJob
4070		}
4071
4072
3536	–	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
3537	–	PyObject *resultobj;
3538	–	BossTask *arg1 = (BossTask *) 0 ;
3539	–	BossJob *arg2 = (BossJob *) 0 ;
3540	–	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3541	–	PyObject * obj0 = 0 ;
3542	–	PyObject * obj1 = 0 ;
3543	–
3544	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
3545	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3546	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3547	–	{
3548	–	try {
3549	–	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
3550	–
3551	–	}catch (const std::exception& e) {
3552	–	SWIG_exception(SWIG_RuntimeError, e.what());
3553	–	}
3554	–	}
3555	–	{
3556	–	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3557	–	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3558	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3559	–	}
3560	–	return resultobj;
3561	–	fail:
3562	–	return NULL;
3563	–	}
3564	–
3565	–
4073		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4074		PyObject *resultobj;
4075		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3784 | Line 4291 | static PyObject *_wrap_BossTask_archive(
4291		}
4292
4293
3787	–	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3788	–	PyObject *resultobj;
3789	–	BossTask *arg1 = (BossTask *) 0 ;
3790	–	std::map<std::string,std::string > result;
3791	–	PyObject * obj0 = 0 ;
3792	–
3793	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3794	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3795	–	{
3796	–	try {
3797	–	result = ((BossTask const *)arg1)->taskMap();
3798	–
3799	–	}catch (const std::exception& e) {
3800	–	SWIG_exception(SWIG_RuntimeError, e.what());
3801	–	}
3802	–	}
3803	–	{
3804	–	resultobj = PyDict_New();
3805	–	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3806	–	PyDict_SetItem(resultobj,
3807	–	SwigString_FromString(i->first),
3808	–	SwigString_FromString(i->second));
3809	–	}
3810	–	}
3811	–	return resultobj;
3812	–	fail:
3813	–	return NULL;
3814	–	}
3815	–
3816	–
4294		static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4295		PyObject *resultobj;
4296		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3993 | Line 4470 | static PyObject *_wrap_BossTask_kill(PyO
4470		}
4471
4472
4473	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
4473	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4474		PyObject *resultobj;
4475		BossTask *arg1 = (BossTask *) 0 ;
4476		std::string const &arg2_defvalue = "all" ;
#	Line 4056 | Line 4533 | static PyObject *_wrap_BossTask_getOutpu
4533		}
4534
4535
4536	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
4536	>	static PyObject *_wrap_BossTask_getAllOutput(PyObject *self, PyObject *args) {
4537		PyObject *resultobj;
4538		BossTask *arg1 = (BossTask *) 0 ;
4539		std::string const &arg2_defvalue = "" ;
#	Line 4070 | Line 4547 | static PyObject *_wrap_BossTask_getOutpu
4547		PyObject * obj2 = 0 ;
4548		PyObject * obj3 = 0 ;
4549
4550	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4550	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4551		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4552		if (obj1) {
4553		{
#	Line 4092 | Line 4569 | static PyObject *_wrap_BossTask_getOutpu
4569		}
4570		{
4571		try {
4572	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
4572	>	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3,arg4);
4573
4574		}catch (const std::exception& e) {
4575		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 4105 | Line 4582 | static PyObject *_wrap_BossTask_getOutpu
4582		}
4583
4584
4108	–	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4109	–	int argc;
4110	–	PyObject *argv[6];
4111	–	int ii;
4112	–
4113	–	argc = PyObject_Length(args);
4114	–	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
4115	–	argv[ii] = PyTuple_GetItem(args,ii);
4116	–	}
4117	–	if ((argc >= 1) && (argc <= 5)) {
4118	–	int _v;
4119	–	{
4120	–	void *ptr;
4121	–	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4122	–	_v = 0;
4123	–	PyErr_Clear();
4124	–	}else {
4125	–	_v = 1;
4126	–	}
4127	–	}
4128	–	if (_v) {
4129	–	if (argc <= 1) {
4130	–	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4131	–	}
4132	–	{
4133	–	_v = PyString_Check(argv[1]) ? 1 : 0;
4134	–	}
4135	–	if (_v) {
4136	–	if (argc <= 2) {
4137	–	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4138	–	}
4139	–	{
4140	–	_v = PyString_Check(argv[2]) ? 1 : 0;
4141	–	}
4142	–	if (_v) {
4143	–	if (argc <= 3) {
4144	–	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4145	–	}
4146	–	{
4147	–	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4148	–	}
4149	–	if (_v) {
4150	–	if (argc <= 4) {
4151	–	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4152	–	}
4153	–	{
4154	–	_v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
4155	–	}
4156	–	if (_v) {
4157	–	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4158	–	}
4159	–	}
4160	–	}
4161	–	}
4162	–	}
4163	–	}
4164	–	if ((argc >= 1) && (argc <= 4)) {
4165	–	int _v;
4166	–	{
4167	–	void *ptr;
4168	–	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4169	–	_v = 0;
4170	–	PyErr_Clear();
4171	–	}else {
4172	–	_v = 1;
4173	–	}
4174	–	}
4175	–	if (_v) {
4176	–	if (argc <= 1) {
4177	–	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4178	–	}
4179	–	{
4180	–	_v = PyString_Check(argv[1]) ? 1 : 0;
4181	–	}
4182	–	if (_v) {
4183	–	if (argc <= 2) {
4184	–	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4185	–	}
4186	–	{
4187	–	_v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
4188	–	}
4189	–	if (_v) {
4190	–	if (argc <= 3) {
4191	–	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4192	–	}
4193	–	{
4194	–	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4195	–	}
4196	–	if (_v) {
4197	–	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4198	–	}
4199	–	}
4200	–	}
4201	–	}
4202	–	}
4203	–
4204	–	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
4205	–	return NULL;
4206	–	}
4207	–
4208	–
4585		static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
4586		PyObject *resultobj;
4587		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4385 | Line 4761 | static PyObject *_wrap_BossTask_clear(Py
4761		}
4762
4763
4764	<	static PyObject *_wrap_BossTask_prompt(PyObject *self, PyObject *args) {
4764	>	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
4765	>	PyObject *obj;
4766	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4767	>	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
4768	>	Py_INCREF(obj);
4769	>	return Py_BuildValue((char *)"");
4770	>	}
4771	>	static PyObject *_wrap_prompt(PyObject *self, PyObject *args) {
4772		PyObject *resultobj;
4773	<	BossTask *arg1 = (BossTask *) 0 ;
4391	<	std::string *arg2 = 0 ;
4773	>	std::string *arg1 = 0 ;
4774		bool result;
4775	<	std::string temp2 ;
4775	>	std::string temp1 ;
4776		PyObject * obj0 = 0 ;
4395	–	PyObject * obj1 = 0 ;
4777
4778	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_prompt",&obj0,&obj1)) goto fail;
4398	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4778	>	if(!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) goto fail;
4779		{
4780	<	if (PyString_Check(obj1)) {
4781	<	temp2 = std::string(PyString_AsString(obj1));
4782	<	arg2 = &temp2;
4780	>	if (PyString_Check(obj0)) {
4781	>	temp1 = std::string(PyString_AsString(obj0));
4782	>	arg1 = &temp1;
4783		}else {
4784		SWIG_exception(SWIG_TypeError, "string expected");
4785		}
4786		}
4787		{
4788		try {
4789	<	result = (bool)(arg1)->prompt((std::string const &)*arg2);
4789	>	result = (bool)prompt((std::string const &)*arg1);
4790
4791		}catch (const std::exception& e) {
4792		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 4419 | Line 4799 | static PyObject *_wrap_BossTask_prompt(P
4799		}
4800
4801
4422	–	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
4423	–	PyObject *obj;
4424	–	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4425	–	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
4426	–	Py_INCREF(obj);
4427	–	return Py_BuildValue((char *)"");
4428	–	}
4802		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
4803		PyObject *resultobj;
4804		std::string arg1 = (std::string) "" ;
#	Line 5203 | Line 5576 | static PyObject *_wrap_BossAdministrator
5576		}
5577
5578
5579	+	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
5580	+	PyObject *resultobj;
5581	+	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5582	+	std::string arg2 ;
5583	+	int result;
5584	+	PyObject * obj0 = 0 ;
5585	+	PyObject * obj1 = 0 ;
5586	+
5587	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
5588	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5589	+	{
5590	+	if (PyString_Check(obj1))
5591	+	arg2 = std::string(PyString_AsString(obj1));
5592	+	else
5593	+	SWIG_exception(SWIG_TypeError, "string expected");
5594	+	}
5595	+	{
5596	+	try {
5597	+	result = (int)(arg1)->registerPlugins(arg2);
5598	+
5599	+	}catch (const std::exception& e) {
5600	+	SWIG_exception(SWIG_RuntimeError, e.what());
5601	+	}
5602	+	}
5603	+	resultobj = PyInt_FromLong((long)result);
5604	+	return resultobj;
5605	+	fail:
5606	+	return NULL;
5607	+	}
5608	+
5609	+
5610		static PyObject * BossAdministratorSession_swigregister(PyObject *self, PyObject *args) {
5611		PyObject *obj;
5612		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 5226 | Line 5630 | static PyMethodDef SwigMethods[] = {
5630		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
5631		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
5632		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
5633	+	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
5634	+	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
5635	+	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
5636	+	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
5637	+	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
5638	+	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
5639	+	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
5640	+	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
5641	+	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
5642	+	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
5643	+	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
5644	+	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
5645	+	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
5646	+	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5647		{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5648	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
5649	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
5650	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
5651	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
5648	>	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5649	>	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5650	>	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5651	>	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5652	>	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5653		{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
5654		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
5655		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
5656	+	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
5657		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
5658		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
5659		{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
#	Line 5243 | Line 5663 | static PyMethodDef SwigMethods[] = {
5663		{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
5664		{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
5665		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5246	–	{ (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
5666		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
5667		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
5668	<	{ (char *)"BossSession_jobQuery", _wrap_BossSession_jobQuery, METH_VARARGS },
5250	<	{ (char *)"BossSession_queryPrint", _wrap_BossSession_queryPrint, METH_VARARGS },
5668	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
5669		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
5670	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
5671		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5672		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5673		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 5258 | Line 5677 | static PyMethodDef SwigMethods[] = {
5677		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5678		{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5679		{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5680	<	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5680	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
5681		{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5682		{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
5683		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
5684		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
5685		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
5686		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
5687	<	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5687	>	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5688		{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5689		{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
5690	<	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
5690	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5691	>	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5692		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
5693	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
5694		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
5695		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
5696		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
5276	–	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5697		{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
5698		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
5699		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
5700		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
5701	+	{ (char *)"BossTask_getAllOutput", _wrap_BossTask_getAllOutput, METH_VARARGS },
5702		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
5703		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
5704		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
5284	–	{ (char *)"BossTask_prompt", _wrap_BossTask_prompt, METH_VARARGS },
5705		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5706	+	{ (char *)"prompt", _wrap_prompt, METH_VARARGS },
5707		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
5708		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
5709		{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
#	Line 5298 | Line 5719 | static PyMethodDef SwigMethods[] = {
5719		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
5720		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
5721		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
5722	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
5723		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
5724		{ NULL, NULL }
5725		};
#	Line 5305 | Line 5727 | static PyMethodDef SwigMethods[] = {
5727
5728		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5729
5308	–	static swig_type_info _swigt__p_std__vectorTBossJob_p_t[] = {{"_p_std__vectorTBossJob_p_t", 0, "std::vector<BossJob * > *", 0},{"_p_std__vectorTBossJob_p_t"},{0}};
5309	–	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}};
5730		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}};
5731	+	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}};
5732		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
5733	+	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}};
5734		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}};
5313	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
5735		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
5736		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5737	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
5738		static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
5739		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
5318	–	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
5740		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
5741	+	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
5742		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
5743		static swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0},{"_p_std__vectorTstd__string_t"},{0}};
5744		static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
5745		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5324	–	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
5325	–	static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
5746		static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
5747	+	static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
5748	+	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
5749
5750		static swig_type_info *swig_types_initial[] = {
5329	–	_swigt__p_std__vectorTBossJob_p_t,
5330	–	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
5751		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
5752	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
5753		_swigt__p_XMLDoc,
5754	+	_swigt__p_std__vectorTBossTask_p_t,
5755		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
5334	–	_swigt__p_std__ostream,
5756		_swigt__p_BossTask,
5757		_swigt__p_BossTaskException,
5758	+	_swigt__p_std__ostream,
5759		_swigt__p_BossAttributeContainer,
5760		_swigt__p_printOption,
5339	–	_swigt__p_BossDatabase,
5761		_swigt__p_BossJob,
5762	+	_swigt__p_BossDatabase,
5763		_swigt__p_BossSession,
5764		_swigt__p_std__vectorTstd__string_t,
5765		_swigt__p_std__mapTstd__string_std__string_t,
5766		_swigt__p_BossAdministratorSession,
5345	–	_swigt__p_jobStates,
5346	–	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
5767		_swigt__p_BossTask__job_iterator,
5768	+	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
5769	+	_swigt__p_jobStates,
5770		0
5771		};
5772

Diff Legend

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