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.3 by gcodispo, Tue Oct 24 14:11:24 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]
665	<	#define  SWIGTYPE_p_std__string swig_types[8]
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]
674	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[17]
675	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[18]
673	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[16]
674	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[17]
675	>	#define  SWIGTYPE_p_jobStates swig_types[18]
676		static swig_type_info *swig_types[20];
677
678		/* -------- TYPES TABLE (END) -------- */
#	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 861 | Line 926 | PyObject *std_maplstd_stringcstd_string_
926		#include "BossDBObject.h"
927		#include "BossProgram.h"
928		#include "BossProgramExec.h"
929	+	#include "BossDatabase.h"
930
931	+	PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
932	+	PyObject *  my_list = PyList_New( my_vec.size());
933	+	unsigned int index = 0;
934	+	for ( std::vector<std::string>::const_iterator it = my_vec.begin ();
935	+	it != my_vec.end(); ++it, ++index) {
936	+	PyList_SetItem( my_list, index, PyString_FromString( it->c_str() ));
937	+	}
938	+	return my_list;
939	+	}
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_ProgramTypes(BossSession *self){
945	+	std::vector<std::string> my_vec = self->showProgramTypes();
946	+	return BossSession_show( self, my_vec );
947	+	}
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_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 881 | Line 982 | PyObject *BossSession_queryTasks(BossSes
982		//       }
983		return  job_dict;
984		}
985	+	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
986	+	std::string tmp;
987	+	BossAttributeContainer::const_iterator it_end = obj.end ();
988	+	for (BossAttributeContainer::const_iterator it = obj.begin ();
989	+	it != it_end; ++it) {
990	+	tmp = (*it).first.name ();
991	+	char * key = new char[ tmp.size() ];
992	+	key = strdup(tmp.c_str());
993	+	tmp = (*it).second.value ();
994	+	PyObject * val = PyString_FromString( tmp.c_str() );
995	+	PyDict_SetItemString( dict, key, val );
996	+	delete [] key;
997	+	}
998	+	return dict;
999	+	}
1000		PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
1001
1002		PyObject * job_dict = PyDict_New();
887	–
1003		std::string tmp;
1004
1005		BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1006	<	BossAttributeContainer::const_iterator it_end = obj.end ();
892	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
893	<	it != it_end; ++it) {
894	<	tmp = (*it).first.name ();
895	<	char * key = new char[ tmp.size() ];
896	<	key = strdup(tmp.c_str());
897	<	tmp = (*it).second.value ();
898	<	PyObject * val = PyString_FromString( tmp.c_str() );
899	<	PyDict_SetItemString( job_dict, key, val );
900	<	delete [] key;
901	<	}
1006	>	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1007
1008		std::set<std::string> sch = (*jit)->getSchedulerElements();
1009		std::set<std::string>::const_iterator sch_end =  sch.end();
#	Line 914 | 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 932 | Line 1037 | PyObject *BossTask_progDict(BossTask con
1037
1038		std::string tmp;
1039
935	–	BossAttributeContainer::const_iterator it;
936	–	BossAttributeContainer::const_iterator it_end;
937	–
1040		// PROGRAM
1041		BossAttributeContainer obj =
1042		(programs_it->first).getTableEntries("PROGRAM");
1043	<	it_end = obj.end ();
942	<	for ( it = obj.begin (); it != it_end; ++it) {
943	<	tmp = (*it).first.name ();
944	<	char * key = new char[ tmp.size() ];
945	<	key = strdup(tmp.c_str());
946	<	tmp = (*it).second.value ();
947	<	PyObject * val = PyString_FromString( tmp.c_str() );
948	<	PyDict_SetItemString( job_dict, key, val );
949	<	delete [] key;
950	<	}
1043	>	BossTask_appendToPyDict ( self, job_dict, obj );
1044
1045		// PROGRAM_EXEC
1046		obj.clear();
1047		obj = (programs_it->second).getTableEntries("PROGRAM_EXEC");
1048	<	it_end = obj.end ();
956	<	for ( it = obj.begin (); it != it_end; ++it) {
957	<	tmp = (*it).first.name ();
958	<	char * key = new char[ tmp.size() ];
959	<	key = strdup(tmp.c_str());
960	<	tmp = (*it).second.value ();
961	<	PyObject * val = PyString_FromString( tmp.c_str() );
962	<	PyDict_SetItemString( job_dict, key, val );
963	<	delete [] key;
964	<	}
965	<
1048	>	BossTask_appendToPyDict ( self, job_dict, obj );
1049
1050		// SPECIFICS
1051	<	std::vector < BossAttributeContainer >::const_iterator it2;
1052	<	std::vector < BossAttributeContainer >::const_iterator it2_end = (programs_it->second).specEnd ();
1053	<	for ( it2 = (programs_it->second).specBegin (); it2 != it2_end; ++it2) {
1054	<	it_end = it2->end ();
972	<	for ( it = it2->begin (); it != it_end; ++it) {
973	<	tmp = (*it).first.name ();
974	<	char * key = new char[ tmp.size() ];
975	<	key = strdup(tmp.c_str());
976	<	tmp = (*it).second.value ();
977	<	PyObject * val = PyString_FromString( tmp.c_str() );
978	<	PyDict_SetItemString( job_dict, key, val );
979	<	delete [] key;
980	<	}
1051	>	std::vector < BossAttributeContainer >::const_iterator it;
1052	>	std::vector < BossAttributeContainer >::const_iterator it_end = (programs_it->second).specEnd ();
1053	>	for ( it = (programs_it->second).specBegin (); it != it_end; ++it) {
1054	>	BossTask_appendToPyDict ( self, job_dict, *it );
1055		}
1056		return job_dict;
1057		}
#	Line 1533 | Line 1607 | static PyObject * objectMap_swigregister
1607		Py_INCREF(obj);
1608		return Py_BuildValue((char *)"");
1609		}
1610	+	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1611	+	PyObject *resultobj;
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: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 = (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 = 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_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1672	+	PyObject *resultobj;
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: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 = (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 = 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_new_vector_string(PyObject *self, PyObject *args) {
1724	+	int argc;
1725	+	PyObject *argv[3];
1726	+	int ii;
1727	+
1728	+	argc = PyObject_Length(args);
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	+	/* 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_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 'new_vector_string'");
1794	+	return NULL;
1795	+	}
1796	+
1797	+
1798	+	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1799	+	PyObject *resultobj;
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: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 = (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 = PyInt_FromLong((long)result);
1844	+	return resultobj;
1845	+	fail:
1846	+	return NULL;
1847	+	}
1848	+
1849	+
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	+	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	+	{
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	+	}
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	+	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 * 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 *)"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_show(arg1,*arg2);
2215	+
2216	+	}catch (const std::exception& e) {
2217	+	SWIG_exception(SWIG_RuntimeError, e.what());
2218	+	}
2219	+	}
2220	+	resultobj = result;
2221	+	return resultobj;
2222	+	fail:
2223	+	return NULL;
2224	+	}
2225	+
2226	+
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	+	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	+	}
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	+	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_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_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_schedulers(arg1);
2307	+
2308	+	}catch (const std::exception& e) {
2309	+	SWIG_exception(SWIG_RuntimeError, e.what());
2310	+	}
2311	+	}
2312	+	resultobj = result;
2313	+	return resultobj;
2314	+	fail:
2315	+	return NULL;
2316	+	}
2317	+
2318	+
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	+	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	+	{
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	+	if (PyString_Check(obj3)) {
2362	+	temp4 = std::string(PyString_AsString(obj3));
2363	+	arg4 = &temp4;
2364	+	}else {
2365	+	SWIG_exception(SWIG_TypeError, "string expected");
2366	+	}
2367	+	}
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	+	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	+
2397	+
2398		static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2399		PyObject *resultobj;
2400		BossSession *arg1 = (BossSession *) 0 ;
#	Line 1697 | 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 1759 | Line 2643 | static PyObject *_wrap_BossSession_destr
2643		}
2644
2645
2646	<	static PyObject *_wrap_BossSession_BossShowCHTools(PyObject *self, PyObject *args) {
1763	<	PyObject *resultobj;
1764	<	BossSession *arg1 = (BossSession *) 0 ;
1765	<	std::vector<std::string > result;
1766	<	PyObject * obj0 = 0 ;
1767	<
1768	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowCHTools",&obj0)) goto fail;
1769	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1770	<	{
1771	<	try {
1772	<	result = (arg1)->BossShowCHTools();
1773	<
1774	<	}catch (const std::exception& e) {
1775	<	SWIG_exception(SWIG_RuntimeError, e.what());
1776	<	}
1777	<	}
1778	<	{
1779	<	std::vector<std::string > * resultptr;
1780	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
1781	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1782	<	}
1783	<	return resultobj;
1784	<	fail:
1785	<	return NULL;
1786	<	}
1787	<
1788	<
1789	<	static PyObject *_wrap_BossSession_BossShowProgramTypes(PyObject *self, PyObject *args) {
1790	<	PyObject *resultobj;
1791	<	BossSession *arg1 = (BossSession *) 0 ;
1792	<	std::vector<std::string > result;
1793	<	PyObject * obj0 = 0 ;
1794	<
1795	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowProgramTypes",&obj0)) goto fail;
1796	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1797	<	{
1798	<	try {
1799	<	result = (arg1)->BossShowProgramTypes();
1800	<
1801	<	}catch (const std::exception& e) {
1802	<	SWIG_exception(SWIG_RuntimeError, e.what());
1803	<	}
1804	<	}
1805	<	{
1806	<	std::vector<std::string > * resultptr;
1807	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
1808	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1809	<	}
1810	<	return resultobj;
1811	<	fail:
1812	<	return NULL;
1813	<	}
1814	<
1815	<
1816	<	static PyObject *_wrap_BossSession_BossShowRTMon(PyObject *self, PyObject *args) {
1817	<	PyObject *resultobj;
1818	<	BossSession *arg1 = (BossSession *) 0 ;
1819	<	std::vector<std::string > result;
1820	<	PyObject * obj0 = 0 ;
1821	<
1822	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowRTMon",&obj0)) goto fail;
1823	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1824	<	{
1825	<	try {
1826	<	result = (arg1)->BossShowRTMon();
1827	<
1828	<	}catch (const std::exception& e) {
1829	<	SWIG_exception(SWIG_RuntimeError, e.what());
1830	<	}
1831	<	}
1832	<	{
1833	<	std::vector<std::string > * resultptr;
1834	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
1835	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1836	<	}
1837	<	return resultobj;
1838	<	fail:
1839	<	return NULL;
1840	<	}
1841	<
1842	<
1843	<	static PyObject *_wrap_BossSession_BossShowSchedulers(PyObject *self, PyObject *args) {
1844	<	PyObject *resultobj;
1845	<	BossSession *arg1 = (BossSession *) 0 ;
1846	<	std::vector<std::string > result;
1847	<	PyObject * obj0 = 0 ;
1848	<
1849	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowSchedulers",&obj0)) goto fail;
1850	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1851	<	{
1852	<	try {
1853	<	result = (arg1)->BossShowSchedulers();
1854	<
1855	<	}catch (const std::exception& e) {
1856	<	SWIG_exception(SWIG_RuntimeError, e.what());
1857	<	}
1858	<	}
1859	<	{
1860	<	std::vector<std::string > * resultptr;
1861	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
1862	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1863	<	}
1864	<	return resultobj;
1865	<	fail:
1866	<	return NULL;
1867	<	}
1868	<
1869	<
1870	<	static PyObject *_wrap_BossSession_BossDefaultCHTool(PyObject *self, PyObject *args) {
2646	>	static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
2647		PyObject *resultobj;
2648		BossSession *arg1 = (BossSession *) 0 ;
2649		std::string result;
2650		PyObject * obj0 = 0 ;
2651
2652	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultCHTool",&obj0)) goto fail;
2652	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) goto fail;
2653		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2654		{
2655		try {
2656	<	result = (arg1)->BossDefaultCHTool();
2656	>	result = (arg1)->defaultCHTool();
2657
2658		}catch (const std::exception& e) {
2659		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1892 | Line 2668 | static PyObject *_wrap_BossSession_BossD
2668		}
2669
2670
2671	<	static PyObject *_wrap_BossSession_BossDefaultProgramType(PyObject *self, PyObject *args) {
2671	>	static PyObject *_wrap_BossSession_defaultProgramType(PyObject *self, PyObject *args) {
2672		PyObject *resultobj;
2673		BossSession *arg1 = (BossSession *) 0 ;
2674		std::string result;
2675		PyObject * obj0 = 0 ;
2676
2677	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultProgramType",&obj0)) goto fail;
2677	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) goto fail;
2678		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2679		{
2680		try {
2681	<	result = (arg1)->BossDefaultProgramType();
2681	>	result = (arg1)->defaultProgramType();
2682
2683		}catch (const std::exception& e) {
2684		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1917 | Line 2693 | static PyObject *_wrap_BossSession_BossD
2693		}
2694
2695
2696	<	static PyObject *_wrap_BossSession_BossDefaultRTMon(PyObject *self, PyObject *args) {
2696	>	static PyObject *_wrap_BossSession_defaultRTMon(PyObject *self, PyObject *args) {
2697		PyObject *resultobj;
2698		BossSession *arg1 = (BossSession *) 0 ;
2699		std::string result;
2700		PyObject * obj0 = 0 ;
2701
2702	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultRTMon",&obj0)) goto fail;
2702	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) goto fail;
2703		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2704		{
2705		try {
2706	<	result = (arg1)->BossDefaultRTMon();
2706	>	result = (arg1)->defaultRTMon();
2707
2708		}catch (const std::exception& e) {
2709		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1942 | Line 2718 | static PyObject *_wrap_BossSession_BossD
2718		}
2719
2720
2721	<	static PyObject *_wrap_BossSession_BossDefaultScheduler(PyObject *self, PyObject *args) {
2721	>	static PyObject *_wrap_BossSession_defaultScheduler(PyObject *self, PyObject *args) {
2722		PyObject *resultobj;
2723		BossSession *arg1 = (BossSession *) 0 ;
2724		std::string result;
2725		PyObject * obj0 = 0 ;
2726
2727	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultScheduler",&obj0)) goto fail;
2727	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) goto fail;
2728		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2729		{
2730		try {
2731	<	result = (arg1)->BossDefaultScheduler();
2731	>	result = (arg1)->defaultScheduler();
2732
2733		}catch (const std::exception& e) {
2734		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1967 | Line 2743 | static PyObject *_wrap_BossSession_BossD
2743		}
2744
2745
2746	<	static PyObject *_wrap_BossSession_BossVersion(PyObject *self, PyObject *args) {
2746	>	static PyObject *_wrap_BossSession_version(PyObject *self, PyObject *args) {
2747		PyObject *resultobj;
2748		BossSession *arg1 = (BossSession *) 0 ;
2749		std::string result;
2750		PyObject * obj0 = 0 ;
2751
2752	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossVersion",&obj0)) goto fail;
2752	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) goto fail;
2753		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2754		{
2755		try {
2756	<	result = (arg1)->BossVersion();
2756	>	result = (arg1)->version();
2757
2758		}catch (const std::exception& e) {
2759		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1992 | Line 2768 | static PyObject *_wrap_BossSession_BossV
2768		}
2769
2770
2771	<	static PyObject *_wrap_BossSession_BossClientID(PyObject *self, PyObject *args) {
2771	>	static PyObject *_wrap_BossSession_clientID(PyObject *self, PyObject *args) {
2772		PyObject *resultobj;
2773		BossSession *arg1 = (BossSession *) 0 ;
2774		std::string result;
2775		PyObject * obj0 = 0 ;
2776
2777	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossClientID",&obj0)) goto fail;
2777	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) goto fail;
2778		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2779		{
2780		try {
2781	<	result = (arg1)->BossClientID();
2781	>	result = (arg1)->clientID();
2782
2783		}catch (const std::exception& e) {
2784		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 2046 | Line 2822 | static PyObject *_wrap_BossSession_showC
2822		}
2823
2824
2825	<	static PyObject *_wrap_BossSession_purgeTasks(PyObject *self, PyObject *args) {
2050	<	PyObject *resultobj;
2051	<	BossSession *arg1 = (BossSession *) 0 ;
2052	<	std::string *arg2 = 0 ;
2053	<	std::string *arg3 = 0 ;
2054	<	std::string *arg4 = 0 ;
2055	<	std::string const &arg5_defvalue = "0" ;
2056	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
2057	<	int result;
2058	<	std::string temp2 ;
2059	<	std::string temp3 ;
2060	<	std::string temp4 ;
2061	<	std::string temp5 ;
2062	<	PyObject * obj0 = 0 ;
2063	<	PyObject * obj1 = 0 ;
2064	<	PyObject * obj2 = 0 ;
2065	<	PyObject * obj3 = 0 ;
2066	<	PyObject * obj4 = 0 ;
2067	<
2068	<	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossSession_purgeTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
2069	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2070	<	{
2071	<	if (PyString_Check(obj1)) {
2072	<	temp2 = std::string(PyString_AsString(obj1));
2073	<	arg2 = &temp2;
2074	<	}else {
2075	<	SWIG_exception(SWIG_TypeError, "string expected");
2076	<	}
2077	<	}
2078	<	{
2079	<	if (PyString_Check(obj2)) {
2080	<	temp3 = std::string(PyString_AsString(obj2));
2081	<	arg3 = &temp3;
2082	<	}else {
2083	<	SWIG_exception(SWIG_TypeError, "string expected");
2084	<	}
2085	<	}
2086	<	{
2087	<	if (PyString_Check(obj3)) {
2088	<	temp4 = std::string(PyString_AsString(obj3));
2089	<	arg4 = &temp4;
2090	<	}else {
2091	<	SWIG_exception(SWIG_TypeError, "string expected");
2092	<	}
2093	<	}
2094	<	if (obj4) {
2095	<	{
2096	<	if (PyString_Check(obj4)) {
2097	<	temp5 = std::string(PyString_AsString(obj4));
2098	<	arg5 = &temp5;
2099	<	}else {
2100	<	SWIG_exception(SWIG_TypeError, "string expected");
2101	<	}
2102	<	}
2103	<	}
2104	<	{
2105	<	try {
2106	<	result = (int)(arg1)->purgeTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
2107	<
2108	<	}catch (const std::exception& e) {
2109	<	SWIG_exception(SWIG_RuntimeError, e.what());
2110	<	}
2111	<	}
2112	<	resultobj = PyInt_FromLong((long)result);
2113	<	return resultobj;
2114	<	fail:
2115	<	return NULL;
2116	<	}
2117	<
2118	<
2119	<	static PyObject *_wrap_BossSession_BossRTupdate(PyObject *self, PyObject *args) {
2825	>	static PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2826		PyObject *resultobj;
2827		BossSession *arg1 = (BossSession *) 0 ;
2828		std::string arg2 = (std::string) "all" ;
#	Line 2128 | Line 2834 | static PyObject *_wrap_BossSession_BossR
2834		PyObject * obj2 = 0 ;
2835		PyObject * obj3 = 0 ;
2836
2837	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_BossRTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
2837	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
2838		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2839		if (obj1) {
2840		{
#	Line 2156 | Line 2862 | static PyObject *_wrap_BossSession_BossR
2862		}
2863		{
2864		try {
2865	<	result = (int)(arg1)->BossRTupdate(arg2,arg3,arg4);
2865	>	result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2866
2867		}catch (const std::exception& e) {
2868		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 2169 | Line 2875 | static PyObject *_wrap_BossSession_BossR
2875		}
2876
2877
2878	<	static PyObject *_wrap_BossSession_BossListMatch(PyObject *self, PyObject *args) {
2878	>	static PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
2879		PyObject *resultobj;
2880		BossSession *arg1 = (BossSession *) 0 ;
2881		std::string *arg2 = 0 ;
2882		std::string *arg3 = 0 ;
2883	<	std::ostream &arg4_defvalue = std::cout ;
2884	<	std::ostream *arg4 = (std::ostream *) &arg4_defvalue ;
2885	<	bool arg5 = (bool) false ;
2883	>	bool arg4 = (bool) false ;
2884	>	std::string const &arg5_defvalue = "" ;
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 const &arg7_defvalue = "" ;
2183	<	std::string *arg7 = (std::string *) &arg7_defvalue ;
2184	<	int result;
2888	>	std::vector<std::string > result;
2889		std::string temp2 ;
2890		std::string temp3 ;
2891	+	std::string temp5 ;
2892		std::string temp6 ;
2188	–	std::string temp7 ;
2893		PyObject * obj0 = 0 ;
2894		PyObject * obj1 = 0 ;
2895		PyObject * obj2 = 0 ;
2896		PyObject * obj3 = 0 ;
2897		PyObject * obj4 = 0 ;
2898		PyObject * obj5 = 0 ;
2195	–	PyObject * obj6 = 0 ;
2899
2900	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_BossListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2900	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2901		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2902		{
2903		if (PyString_Check(obj1)) {
#	Line 2213 | Line 2916 | static PyObject *_wrap_BossSession_BossL
2916		}
2917		}
2918		if (obj3) {
2919	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2217	<	if (arg4 == NULL) {
2218	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2219	<	}
2220	<	}
2221	<	if (obj4) {
2222	<	arg5 = PyInt_AsLong(obj4) ? true : false;
2919	>	arg4 = PyInt_AsLong(obj3) ? true : false;
2920		if (PyErr_Occurred()) SWIG_fail;
2921		}
2922	<	if (obj5) {
2922	>	if (obj4) {
2923		{
2924	<	if (PyString_Check(obj5)) {
2925	<	temp6 = std::string(PyString_AsString(obj5));
2926	<	arg6 = &temp6;
2924	>	if (PyString_Check(obj4)) {
2925	>	temp5 = std::string(PyString_AsString(obj4));
2926	>	arg5 = &temp5;
2927		}else {
2928		SWIG_exception(SWIG_TypeError, "string expected");
2929		}
2930		}
2931		}
2932	<	if (obj6) {
2932	>	if (obj5) {
2933		{
2934	<	if (PyString_Check(obj6)) {
2935	<	temp7 = std::string(PyString_AsString(obj6));
2936	<	arg7 = &temp7;
2934	>	if (PyString_Check(obj5)) {
2935	>	temp6 = std::string(PyString_AsString(obj5));
2936	>	arg6 = &temp6;
2937		}else {
2938		SWIG_exception(SWIG_TypeError, "string expected");
2939		}
#	Line 2244 | Line 2941 | static PyObject *_wrap_BossSession_BossL
2941		}
2942		{
2943		try {
2944	<	result = (int)(arg1)->BossListMatch((std::string const &)*arg2,(std::string const &)*arg3,*arg4,arg5,(std::string const &)*arg6,(std::string const &)*arg7);
2944	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2945
2946		}catch (const std::exception& e) {
2947		SWIG_exception(SWIG_RuntimeError, e.what());
2948		}
2949		}
2950	<	resultobj = PyInt_FromLong((long)result);
2950	>	{
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:
2958		return NULL;
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 2271 | 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) "" ;
2274	–	bool arg10 = (bool) false ;
2275	–	SwigValueWrapper< std::vector<BossJob * > > result;
2976		std::string temp3 ;
2977		std::string temp4 ;
2978		std::string temp5 ;
#	Line 2284 | Line 2984 | static PyObject *_wrap_BossSession_jobQu
2984		PyObject * obj6 = 0 ;
2985		PyObject * obj7 = 0 ;
2986		PyObject * obj8 = 0 ;
2287	–	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 2350 | Line 3049 | static PyObject *_wrap_BossSession_jobQu
3049		SWIG_exception(SWIG_TypeError, "string expected");
3050		}
3051		}
2353	–	if (obj9) {
2354	–	arg10 = PyInt_AsLong(obj9) ? true : false;
2355	–	if (PyErr_Occurred()) SWIG_fail;
2356	–	}
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	<	{
2366	<	std::vector<BossJob * > * resultptr;
2367	<	resultptr = new std::vector<BossJob * >((std::vector<BossJob * > &) result);
2368	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossJob_p_t, 1);
2369	<	}
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 ;
2395	–	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) {
2414	–	if ((SWIG_ConvertPtr(obj4,(void **) &arg5, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2415	–	if (arg5 == NULL) {
2416	–	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2417	–	}
2418	–	}
2419	–	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 2428 | 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 ;
2449	<	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	<	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 ;
2461	–	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;
2468	–	if (obj1) {
2469	–	{
2470	–	if (PyString_Check(obj1)) {
2471	–	temp2 = std::string(PyString_AsString(obj1));
2472	–	arg2 = &temp2;
2473	–	}else {
2474	–	SWIG_exception(SWIG_TypeError, "string expected");
2475	–	}
2476	–	}
2477	–	}
3182		if (obj2) {
3183		{
3184		if (PyString_Check(obj2)) {
#	Line 2505 | 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 2644 | Line 3384 | static PyObject * BossTaskException_swig
3384		Py_INCREF(obj);
3385		return Py_BuildValue((char *)"");
3386		}
3387	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3387	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3388		PyObject *resultobj;
3389		BossTask *arg1 = (BossTask *) 0 ;
3390	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3390	>	PyObject *arg2 = (PyObject *) 0 ;
3391	>	BossAttributeContainer *arg3 = 0 ;
3392		PyObject *result;
3393		PyObject * obj0 = 0 ;
3394		PyObject * obj1 = 0 ;
3395	+	PyObject * obj2 = 0 ;
3396
3397	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3397	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3398		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3399	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3400	<	if (arg2 == NULL) {
3399	>	arg2 = obj1;
3400	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3401	>	if (arg3 == NULL) {
3402		PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3403		}
3404		{
3405		try {
3406	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3406	>	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3407
3408		}catch (const std::exception& e) {
3409		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 2673 | Line 3416 | static PyObject *_wrap_BossTask_jobDict(
3416		}
3417
3418
3419	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3419	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3420		PyObject *resultobj;
3421		BossTask *arg1 = (BossTask *) 0 ;
3422	+	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3423		PyObject *result;
3424		PyObject * obj0 = 0 ;
3425	+	PyObject * obj1 = 0 ;
3426
3427	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3427	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3428		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3429	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3430	+	if (arg2 == NULL) {
3431	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3432	+	}
3433		{
3434		try {
3435	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3435	>	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3436
3437		}catch (const std::exception& e) {
3438		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 2696 | Line 3445 | static PyObject *_wrap_BossTask_jobsMap_
3445		}
3446
3447
3448	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3449	<	int argc;
3450	<	PyObject *argv[2];
3451	<	int ii;
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	<	argc = PyObject_Length(args);
3455	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3456	<	argv[ii] = PyTuple_GetItem(args,ii);
3457	<	}
3458	<	if (argc == 1) {
3459	<	int _v;
3460	<	{
3461	<	void *ptr;
2712	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
2713	<	_v = 0;
2714	<	PyErr_Clear();
2715	<	}else {
2716	<	_v = 1;
2717	<	}
2718	<	}
2719	<	if (_v) {
2720	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
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_jobsDict((BossTask const *)arg1);
3459	>
3460	>	}catch (const std::exception& e) {
3461	>	SWIG_exception(SWIG_RuntimeError, e.what());
3462		}
3463		}
3464	<
3465	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3464	>	resultobj = result;
3465	>	return resultobj;
3466	>	fail:
3467		return NULL;
3468		}
3469
#	Line 3015 | 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 3042 | 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 ;
3049	<	std::map<std::string,std::string > result;
3793	>	BossTask::job_iterator result;
3794		PyObject * obj0 = 0 ;
3051	–	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;
3055	–	arg2 = (unsigned int) PyInt_AsLong(obj1);
3056	–	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 3112 | 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 3137 | 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 3173 | 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 3184 | Line 4010 | static PyObject *_wrap_BossTask_jobMap(P
4010		}
4011
4012
4013	<	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3188	<	PyObject *resultobj;
3189	<	BossTask *arg1 = (BossTask *) 0 ;
3190	<	BossTask::job_iterator result;
3191	<	PyObject * obj0 = 0 ;
3192	<
3193	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3194	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3195	<	{
3196	<	try {
3197	<	result = ((BossTask const *)arg1)->job_begin();
3198	<
3199	<	}catch (const std::exception& e) {
3200	<	SWIG_exception(SWIG_RuntimeError, e.what());
3201	<	}
3202	<	}
3203	<	{
3204	<	BossTask::job_iterator * resultptr;
3205	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3206	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3207	<	}
3208	<	return resultobj;
3209	<	fail:
3210	<	return NULL;
3211	<	}
3212	<
3213	<
3214	<	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 3268 | Line 4070 | static PyObject *_wrap_BossTask_queryJob
4070		}
4071
4072
3271	–	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
3272	–	PyObject *resultobj;
3273	–	BossTask *arg1 = (BossTask *) 0 ;
3274	–	BossJob *arg2 = (BossJob *) 0 ;
3275	–	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3276	–	PyObject * obj0 = 0 ;
3277	–	PyObject * obj1 = 0 ;
3278	–
3279	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
3280	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3281	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3282	–	{
3283	–	try {
3284	–	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
3285	–
3286	–	}catch (const std::exception& e) {
3287	–	SWIG_exception(SWIG_RuntimeError, e.what());
3288	–	}
3289	–	}
3290	–	{
3291	–	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3292	–	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3293	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3294	–	}
3295	–	return resultobj;
3296	–	fail:
3297	–	return NULL;
3298	–	}
3299	–
3300	–
4073		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4074		PyObject *resultobj;
4075		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3519 | Line 4291 | static PyObject *_wrap_BossTask_archive(
4291		}
4292
4293
3522	–	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3523	–	PyObject *resultobj;
3524	–	BossTask *arg1 = (BossTask *) 0 ;
3525	–	std::map<std::string,std::string > result;
3526	–	PyObject * obj0 = 0 ;
3527	–
3528	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3529	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3530	–	{
3531	–	try {
3532	–	result = ((BossTask const *)arg1)->taskMap();
3533	–
3534	–	}catch (const std::exception& e) {
3535	–	SWIG_exception(SWIG_RuntimeError, e.what());
3536	–	}
3537	–	}
3538	–	{
3539	–	resultobj = PyDict_New();
3540	–	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3541	–	PyDict_SetItem(resultobj,
3542	–	SwigString_FromString(i->first),
3543	–	SwigString_FromString(i->second));
3544	–	}
3545	–	}
3546	–	return resultobj;
3547	–	fail:
3548	–	return NULL;
3549	–	}
3550	–
3551	–
4294		static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4295		PyObject *resultobj;
4296		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3728 | 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 3791 | 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 3805 | 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 3827 | 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 3840 | Line 4582 | static PyObject *_wrap_BossTask_getOutpu
4582		}
4583
4584
3843	–	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
3844	–	int argc;
3845	–	PyObject *argv[6];
3846	–	int ii;
3847	–
3848	–	argc = PyObject_Length(args);
3849	–	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
3850	–	argv[ii] = PyTuple_GetItem(args,ii);
3851	–	}
3852	–	if ((argc >= 1) && (argc <= 5)) {
3853	–	int _v;
3854	–	{
3855	–	void *ptr;
3856	–	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3857	–	_v = 0;
3858	–	PyErr_Clear();
3859	–	}else {
3860	–	_v = 1;
3861	–	}
3862	–	}
3863	–	if (_v) {
3864	–	if (argc <= 1) {
3865	–	return _wrap_BossTask_getOutput__SWIG_0(self,args);
3866	–	}
3867	–	{
3868	–	_v = PyString_Check(argv[1]) ? 1 : 0;
3869	–	}
3870	–	if (_v) {
3871	–	if (argc <= 2) {
3872	–	return _wrap_BossTask_getOutput__SWIG_0(self,args);
3873	–	}
3874	–	{
3875	–	_v = PyString_Check(argv[2]) ? 1 : 0;
3876	–	}
3877	–	if (_v) {
3878	–	if (argc <= 3) {
3879	–	return _wrap_BossTask_getOutput__SWIG_0(self,args);
3880	–	}
3881	–	{
3882	–	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
3883	–	}
3884	–	if (_v) {
3885	–	if (argc <= 4) {
3886	–	return _wrap_BossTask_getOutput__SWIG_0(self,args);
3887	–	}
3888	–	{
3889	–	_v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
3890	–	}
3891	–	if (_v) {
3892	–	return _wrap_BossTask_getOutput__SWIG_0(self,args);
3893	–	}
3894	–	}
3895	–	}
3896	–	}
3897	–	}
3898	–	}
3899	–	if ((argc >= 1) && (argc <= 4)) {
3900	–	int _v;
3901	–	{
3902	–	void *ptr;
3903	–	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3904	–	_v = 0;
3905	–	PyErr_Clear();
3906	–	}else {
3907	–	_v = 1;
3908	–	}
3909	–	}
3910	–	if (_v) {
3911	–	if (argc <= 1) {
3912	–	return _wrap_BossTask_getOutput__SWIG_1(self,args);
3913	–	}
3914	–	{
3915	–	_v = PyString_Check(argv[1]) ? 1 : 0;
3916	–	}
3917	–	if (_v) {
3918	–	if (argc <= 2) {
3919	–	return _wrap_BossTask_getOutput__SWIG_1(self,args);
3920	–	}
3921	–	{
3922	–	_v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
3923	–	}
3924	–	if (_v) {
3925	–	if (argc <= 3) {
3926	–	return _wrap_BossTask_getOutput__SWIG_1(self,args);
3927	–	}
3928	–	{
3929	–	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
3930	–	}
3931	–	if (_v) {
3932	–	return _wrap_BossTask_getOutput__SWIG_1(self,args);
3933	–	}
3934	–	}
3935	–	}
3936	–	}
3937	–	}
3938	–
3939	–	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
3940	–	return NULL;
3941	–	}
3942	–
3943	–
4585		static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
4586		PyObject *resultobj;
4587		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4120 | 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 ;
4126	<	std::string *arg2 = 0 ;
4773	>	std::string *arg1 = 0 ;
4774		bool result;
4775	<	std::string temp2 ;
4775	>	std::string temp1 ;
4776		PyObject * obj0 = 0 ;
4130	–	PyObject * obj1 = 0 ;
4777
4778	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_prompt",&obj0,&obj1)) goto fail;
4133	<	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 4154 | Line 4799 | static PyObject *_wrap_BossTask_prompt(P
4799		}
4800
4801
4157	–	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
4158	–	PyObject *obj;
4159	–	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4160	–	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
4161	–	Py_INCREF(obj);
4162	–	return Py_BuildValue((char *)"");
4163	–	}
4802		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
4803		PyObject *resultobj;
4804		std::string arg1 = (std::string) "" ;
#	Line 4219 | Line 4857 | static PyObject *_wrap_delete_BossAdmini
4857		}
4858
4859
4860	+	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
4861	+	PyObject *resultobj;
4862	+	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4863	+	int result;
4864	+	PyObject * obj0 = 0 ;
4865	+
4866	+	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
4867	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4868	+	{
4869	+	try {
4870	+	result = (int)(arg1)->configureDB();
4871	+
4872	+	}catch (const std::exception& e) {
4873	+	SWIG_exception(SWIG_RuntimeError, e.what());
4874	+	}
4875	+	}
4876	+	resultobj = PyInt_FromLong((long)result);
4877	+	return resultobj;
4878	+	fail:
4879	+	return NULL;
4880	+	}
4881	+
4882	+
4883		static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
4884		PyObject *resultobj;
4885		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
#	Line 4806 | Line 5467 | static PyObject *_wrap_BossAdministrator
5467		}
5468
5469
5470	<	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
5470	>	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
5471		PyObject *resultobj;
5472		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5473	<	std::string *arg2 = 0 ;
5473	>	std::string arg2 ;
5474	>	bool arg3 = (bool) false ;
5475		std::string result;
5476		PyObject * obj0 = 0 ;
5477		PyObject * obj1 = 0 ;
5478	+	PyObject * obj2 = 0 ;
5479
5480	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureDB",&obj0,&obj1)) goto fail;
5480	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
5481		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5482	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5483	<	if (arg2 == NULL) {
5484	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5482	>	{
5483	>	if (PyString_Check(obj1))
5484	>	arg2 = std::string(PyString_AsString(obj1));
5485	>	else
5486	>	SWIG_exception(SWIG_TypeError, "string expected");
5487	>	}
5488	>	if (obj2) {
5489	>	arg3 = PyInt_AsLong(obj2) ? true : false;
5490	>	if (PyErr_Occurred()) SWIG_fail;
5491		}
5492		{
5493		try {
5494	<	result = (arg1)->configureDB(*arg2);
5494	>	result = (arg1)->SQL(arg2,arg3);
5495
5496		}catch (const std::exception& e) {
5497		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 4837 | Line 5506 | static PyObject *_wrap_BossAdministrator
5506		}
5507
5508
5509	<	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
5509	>	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
5510		PyObject *resultobj;
5511		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5512		std::string *arg2 = 0 ;
5513	<	bool arg3 = (bool) false ;
5514	<	std::string result;
5513	>	std::string *arg3 = 0 ;
5514	>	std::string *arg4 = 0 ;
5515	>	std::string const &arg5_defvalue = "0" ;
5516	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
5517	>	int result;
5518	>	std::string temp2 ;
5519	>	std::string temp3 ;
5520	>	std::string temp4 ;
5521	>	std::string temp5 ;
5522		PyObject * obj0 = 0 ;
5523		PyObject * obj1 = 0 ;
5524		PyObject * obj2 = 0 ;
5525	+	PyObject * obj3 = 0 ;
5526	+	PyObject * obj4 = 0 ;
5527
5528	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
5528	>	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5529		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5530	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5531	<	if (arg2 == NULL) {
5532	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5530	>	{
5531	>	if (PyString_Check(obj1)) {
5532	>	temp2 = std::string(PyString_AsString(obj1));
5533	>	arg2 = &temp2;
5534	>	}else {
5535	>	SWIG_exception(SWIG_TypeError, "string expected");
5536	>	}
5537		}
5538	<	if (obj2) {
5539	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5540	<	if (PyErr_Occurred()) SWIG_fail;
5538	>	{
5539	>	if (PyString_Check(obj2)) {
5540	>	temp3 = std::string(PyString_AsString(obj2));
5541	>	arg3 = &temp3;
5542	>	}else {
5543	>	SWIG_exception(SWIG_TypeError, "string expected");
5544	>	}
5545	>	}
5546	>	{
5547	>	if (PyString_Check(obj3)) {
5548	>	temp4 = std::string(PyString_AsString(obj3));
5549	>	arg4 = &temp4;
5550	>	}else {
5551	>	SWIG_exception(SWIG_TypeError, "string expected");
5552	>	}
5553	>	}
5554	>	if (obj4) {
5555	>	{
5556	>	if (PyString_Check(obj4)) {
5557	>	temp5 = std::string(PyString_AsString(obj4));
5558	>	arg5 = &temp5;
5559	>	}else {
5560	>	SWIG_exception(SWIG_TypeError, "string expected");
5561	>	}
5562	>	}
5563		}
5564		{
5565		try {
5566	<	result = (arg1)->SQL(*arg2,arg3);
5566	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
5567
5568		}catch (const std::exception& e) {
5569		SWIG_exception(SWIG_RuntimeError, e.what());
5570		}
5571		}
5572	<	{
4869	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4870	<	}
5572	>	resultobj = PyInt_FromLong((long)result);
5573		return resultobj;
5574		fail:
5575		return NULL;
5576		}
5577
5578
5579	<	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
5579	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
5580		PyObject *resultobj;
5581		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5582	<	std::string *arg2 = 0 ;
5583	<	std::string result;
5582	>	std::string arg2 ;
5583	>	int result;
5584		PyObject * obj0 = 0 ;
5585		PyObject * obj1 = 0 ;
5586
5587	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_purge",&obj0,&obj1)) goto fail;
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	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5590	<	if (arg2 == NULL) {
5591	<	PyErr_SetString(PyExc_TypeError,"null reference"); 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 = (arg1)->purge(*arg2);
5597	>	result = (int)(arg1)->registerPlugins(arg2);
5598
5599		}catch (const std::exception& e) {
5600		SWIG_exception(SWIG_RuntimeError, e.what());
5601		}
5602		}
5603	<	{
4900	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4901	<	}
5603	>	resultobj = PyInt_FromLong((long)result);
5604		return resultobj;
5605		fail:
5606		return NULL;
#	Line 4928 | 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_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_BossShowCHTools", _wrap_BossSession_BossShowCHTools, METH_VARARGS },
5660	<	{ (char *)"BossSession_BossShowProgramTypes", _wrap_BossSession_BossShowProgramTypes, METH_VARARGS },
5661	<	{ (char *)"BossSession_BossShowRTMon", _wrap_BossSession_BossShowRTMon, METH_VARARGS },
5662	<	{ (char *)"BossSession_BossShowSchedulers", _wrap_BossSession_BossShowSchedulers, METH_VARARGS },
5663	<	{ (char *)"BossSession_BossDefaultCHTool", _wrap_BossSession_BossDefaultCHTool, METH_VARARGS },
5664	<	{ (char *)"BossSession_BossDefaultProgramType", _wrap_BossSession_BossDefaultProgramType, METH_VARARGS },
4942	<	{ (char *)"BossSession_BossDefaultRTMon", _wrap_BossSession_BossDefaultRTMon, METH_VARARGS },
4943	<	{ (char *)"BossSession_BossDefaultScheduler", _wrap_BossSession_BossDefaultScheduler, METH_VARARGS },
4944	<	{ (char *)"BossSession_BossVersion", _wrap_BossSession_BossVersion, METH_VARARGS },
4945	<	{ (char *)"BossSession_BossClientID", _wrap_BossSession_BossClientID, METH_VARARGS },
5659	>	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
5660	>	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
5661	>	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
5662	>	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS },
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 },
5666	<	{ (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
5667	<	{ (char *)"BossSession_BossRTupdate", _wrap_BossSession_BossRTupdate, METH_VARARGS },
5668	<	{ (char *)"BossSession_BossListMatch", _wrap_BossSession_BossListMatch, METH_VARARGS },
4950	<	{ (char *)"BossSession_jobQuery", _wrap_BossSession_jobQuery, METH_VARARGS },
4951	<	{ (char *)"BossSession_queryPrint", _wrap_BossSession_queryPrint, METH_VARARGS },
5666	>	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
5667	>	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, 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 4957 | Line 5675 | static PyMethodDef SwigMethods[] = {
5675		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
5676		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
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 },
4976	–	{ (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 },
4984	–	{ (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 },
5710		{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
5711		{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
5712		{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
#	Line 4995 | Line 5717 | static PyMethodDef SwigMethods[] = {
5717		{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
5718		{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
5719		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
4998	–	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, 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 5005 | Line 5727 | static PyMethodDef SwigMethods[] = {
5727
5728		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5729
5008	–	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}};
5009	–	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}};
5013	–	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__string[] = {{"_p_std__string", 0, "std::string *", 0},{"_p_std__string"},{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}};
5018	–	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}};
5024	–	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{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[] = {
5029	–	_swigt__p_std__vectorTBossJob_p_t,
5030	–	_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,
5034	–	_swigt__p_std__ostream,
5756		_swigt__p_BossTask,
5757		_swigt__p_BossTaskException,
5758	<	_swigt__p_std__string,
5758	>	_swigt__p_std__ostream,
5759	>	_swigt__p_BossAttributeContainer,
5760		_swigt__p_printOption,
5039	–	_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,
5045	–	_swigt__p_jobStates,
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