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.16 by gcodispo, Thu Nov 30 15:29:48 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 872 | Line 973 | PyObject *BossSession_queryTasks(BossSes
973		it!= taskList.end(); ++it ) {
974		PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
975		}
875	–
876	–	//       int size = taskList.size();
877	–	//       PyObject * job_dict = PyList_New(0);
878	–	//       for ( unsigned int i = 0; i < size; ++i ) {
879	–	//      PyList_SetItem(job_dict,i, );
880	–	//      self->makeBossTask( *it );
881	–	//       }
976		return  job_dict;
977		}
978	+	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
979	+	std::string tmp;
980	+	BossAttributeContainer::const_iterator it_end = obj.end ();
981	+	for (BossAttributeContainer::const_iterator it = obj.begin ();
982	+	it != it_end; ++it) {
983	+	tmp = (*it).first.name ();
984	+	char * key = new char[ tmp.size() ];
985	+	key = strdup(tmp.c_str());
986	+	tmp = (*it).second.value ();
987	+	PyObject * val = PyString_FromString( tmp.c_str() );
988	+	PyDict_SetItemString( dict, key, val );
989	+	delete [] key;
990	+	}
991	+	return dict;
992	+	}
993		PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
994
995		PyObject * job_dict = PyDict_New();
887	–
996		std::string tmp;
997
998		BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
999	<	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	<	}
999	>	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1000
1001		std::set<std::string> sch = (*jit)->getSchedulerElements();
1002		std::set<std::string>::const_iterator sch_end =  sch.end();
#	Line 914 | Line 1012 | PyObject *BossTask_jobDict(BossTask cons
1012		}
1013		return job_dict;
1014		}
1015	<	PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
1015	>	PyObject *BossTask_jobsDict(BossTask *self){
1016
1017		PyObject * job_dict = PyDict_New();
1018	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1019		for (BossTask::job_iterator jit = self->job_begin ();
1020		jit != self->job_end (); ++jit) {
1021		std::string id = (*jit)->chainId();
#	Line 932 | Line 1031 | PyObject *BossTask_progDict(BossTask con
1031
1032		std::string tmp;
1033
935	–	BossAttributeContainer::const_iterator it;
936	–	BossAttributeContainer::const_iterator it_end;
937	–
1034		// PROGRAM
1035		BossAttributeContainer obj =
1036		(programs_it->first).getTableEntries("PROGRAM");
1037	<	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	<	}
1037	>	BossTask_appendToPyDict ( self, job_dict, obj );
1038
1039		// PROGRAM_EXEC
1040		obj.clear();
1041		obj = (programs_it->second).getTableEntries("PROGRAM_EXEC");
1042	<	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	<
1042	>	BossTask_appendToPyDict ( self, job_dict, obj );
1043
1044		// SPECIFICS
1045	<	std::vector < BossAttributeContainer >::const_iterator it2;
1046	<	std::vector < BossAttributeContainer >::const_iterator it2_end = (programs_it->second).specEnd ();
1047	<	for ( it2 = (programs_it->second).specBegin (); it2 != it2_end; ++it2) {
1048	<	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	<	}
1045	>	std::vector < BossAttributeContainer >::const_iterator it;
1046	>	std::vector < BossAttributeContainer >::const_iterator it_end = (programs_it->second).specEnd ();
1047	>	for ( it = (programs_it->second).specBegin (); it != it_end; ++it) {
1048	>	BossTask_appendToPyDict ( self, job_dict, *it );
1049		}
1050		return job_dict;
1051		}
#	Line 1533 | Line 1601 | static PyObject * objectMap_swigregister
1601		Py_INCREF(obj);
1602		return Py_BuildValue((char *)"");
1603		}
1604	+	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1605	+	PyObject *resultobj;
1606	+	unsigned int arg1 = (unsigned int) 0 ;
1607	+	std::vector<std::string > *result;
1608	+	PyObject * obj0 = 0 ;
1609	+
1610	+	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1611	+	if (obj0) {
1612	+	arg1 = (unsigned int) PyInt_AsLong(obj0);
1613	+	if (PyErr_Occurred()) SWIG_fail;
1614	+	}
1615	+	{
1616	+	try {
1617	+	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1618	+
1619	+	}catch (const std::exception& e) {
1620	+	SWIG_exception(SWIG_RuntimeError, e.what());
1621	+	}
1622	+	}
1623	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1624	+	return resultobj;
1625	+	fail:
1626	+	return NULL;
1627	+	}
1628	+
1629	+
1630	+	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1631	+	PyObject *resultobj;
1632	+	unsigned int arg1 ;
1633	+	std::string *arg2 = 0 ;
1634	+	std::vector<std::string > *result;
1635	+	std::string temp2 ;
1636	+	PyObject * obj0 = 0 ;
1637	+	PyObject * obj1 = 0 ;
1638	+
1639	+	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1640	+	arg1 = (unsigned int) PyInt_AsLong(obj0);
1641	+	if (PyErr_Occurred()) SWIG_fail;
1642	+	{
1643	+	if (PyString_Check(obj1)) {
1644	+	temp2 = std::string(PyString_AsString(obj1));
1645	+	arg2 = &temp2;
1646	+	}else {
1647	+	SWIG_exception(SWIG_TypeError, "string expected");
1648	+	}
1649	+	}
1650	+	{
1651	+	try {
1652	+	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1653	+
1654	+	}catch (const std::exception& e) {
1655	+	SWIG_exception(SWIG_RuntimeError, e.what());
1656	+	}
1657	+	}
1658	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1659	+	return resultobj;
1660	+	fail:
1661	+	return NULL;
1662	+	}
1663	+
1664	+
1665	+	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1666	+	PyObject *resultobj;
1667	+	std::vector<std::string > *arg1 = 0 ;
1668	+	std::vector<std::string > *result;
1669	+	std::vector<std::string > temp1 ;
1670	+	std::vector<std::string > *v1 ;
1671	+	PyObject * obj0 = 0 ;
1672	+
1673	+	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1674	+	{
1675	+	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1676	+	unsigned int size = (PyTuple_Check(obj0) ?
1677	+	PyTuple_Size(obj0) :
1678	+	PyList_Size(obj0));
1679	+	temp1 = std::vector<std::string >(size);
1680	+	arg1 = &temp1;
1681	+	for (unsigned int i=0; i<size; i++) {
1682	+	PyObject* o = PySequence_GetItem(obj0,i);
1683	+	if (PyString_Check(o)) {
1684	+	temp1[i] = (std::string)(\
1685	+	SwigString_AsString(o));
1686	+	Py_DECREF(o);
1687	+	}else {
1688	+	Py_DECREF(o);
1689	+	PyErr_SetString(PyExc_TypeError,
1690	+	"vector<""std::string""> expected");
1691	+	SWIG_fail;
1692	+	}
1693	+	}
1694	+	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1695	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1696	+	arg1 = v1;
1697	+	}else {
1698	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1699	+	SWIG_fail;
1700	+	}
1701	+	}
1702	+	{
1703	+	try {
1704	+	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1705	+
1706	+	}catch (const std::exception& e) {
1707	+	SWIG_exception(SWIG_RuntimeError, e.what());
1708	+	}
1709	+	}
1710	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1711	+	return resultobj;
1712	+	fail:
1713	+	return NULL;
1714	+	}
1715	+
1716	+
1717	+	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1718	+	int argc;
1719	+	PyObject *argv[3];
1720	+	int ii;
1721	+
1722	+	argc = PyObject_Length(args);
1723	+	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1724	+	argv[ii] = PyTuple_GetItem(args,ii);
1725	+	}
1726	+	if ((argc >= 0) && (argc <= 1)) {
1727	+	int _v;
1728	+	if (argc <= 0) {
1729	+	return _wrap_new_vector_string__SWIG_0(self,args);
1730	+	}
1731	+	{
1732	+	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1733	+	}
1734	+	if (_v) {
1735	+	return _wrap_new_vector_string__SWIG_0(self,args);
1736	+	}
1737	+	}
1738	+	if (argc == 1) {
1739	+	int _v;
1740	+	{
1741	+	/* native sequence? */
1742	+	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1743	+	unsigned int size = (PyTuple_Check(argv[0]) ?
1744	+	PyTuple_Size(argv[0]) :
1745	+	PyList_Size(argv[0]));
1746	+	if (size == 0) {
1747	+	/* an empty sequence can be of any type */
1748	+	_v = 1;
1749	+	}else {
1750	+	/* check the first element only */
1751	+	PyObject* o = PySequence_GetItem(argv[0],0);
1752	+	if (PyString_Check(o))
1753	+	_v = 1;
1754	+	else
1755	+	_v = 0;
1756	+	Py_DECREF(o);
1757	+	}
1758	+	}else {
1759	+	/* wrapped vector? */
1760	+	std::vector<std::string >* v;
1761	+	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1762	+	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1763	+	_v = 1;
1764	+	else
1765	+	_v = 0;
1766	+	}
1767	+	}
1768	+	if (_v) {
1769	+	return _wrap_new_vector_string__SWIG_2(self,args);
1770	+	}
1771	+	}
1772	+	if (argc == 2) {
1773	+	int _v;
1774	+	{
1775	+	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1776	+	}
1777	+	if (_v) {
1778	+	{
1779	+	_v = PyString_Check(argv[1]) ? 1 : 0;
1780	+	}
1781	+	if (_v) {
1782	+	return _wrap_new_vector_string__SWIG_1(self,args);
1783	+	}
1784	+	}
1785	+	}
1786	+
1787	+	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1788	+	return NULL;
1789	+	}
1790	+
1791	+
1792	+	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1793	+	PyObject *resultobj;
1794	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1795	+	unsigned int result;
1796	+	std::vector<std::string > temp1 ;
1797	+	std::vector<std::string > *v1 ;
1798	+	PyObject * obj0 = 0 ;
1799	+
1800	+	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1801	+	{
1802	+	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1803	+	unsigned int size = (PyTuple_Check(obj0) ?
1804	+	PyTuple_Size(obj0) :
1805	+	PyList_Size(obj0));
1806	+	temp1 = std::vector<std::string >(size);
1807	+	arg1 = &temp1;
1808	+	for (unsigned int i=0; i<size; i++) {
1809	+	PyObject* o = PySequence_GetItem(obj0,i);
1810	+	if (PyString_Check(o)) {
1811	+	temp1[i] = (std::string)(\
1812	+	SwigString_AsString(o));
1813	+	Py_DECREF(o);
1814	+	}else {
1815	+	Py_DECREF(o);
1816	+	PyErr_SetString(PyExc_TypeError,
1817	+	"vector<""std::string""> expected");
1818	+	SWIG_fail;
1819	+	}
1820	+	}
1821	+	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1822	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1823	+	arg1 = v1;
1824	+	}else {
1825	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1826	+	SWIG_fail;
1827	+	}
1828	+	}
1829	+	{
1830	+	try {
1831	+	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1832	+
1833	+	}catch (const std::exception& e) {
1834	+	SWIG_exception(SWIG_RuntimeError, e.what());
1835	+	}
1836	+	}
1837	+	resultobj = PyInt_FromLong((long)result);
1838	+	return resultobj;
1839	+	fail:
1840	+	return NULL;
1841	+	}
1842	+
1843	+
1844	+	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1845	+	PyObject *resultobj;
1846	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1847	+	bool result;
1848	+	std::vector<std::string > temp1 ;
1849	+	std::vector<std::string > *v1 ;
1850	+	PyObject * obj0 = 0 ;
1851	+
1852	+	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1853	+	{
1854	+	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1855	+	unsigned int size = (PyTuple_Check(obj0) ?
1856	+	PyTuple_Size(obj0) :
1857	+	PyList_Size(obj0));
1858	+	temp1 = std::vector<std::string >(size);
1859	+	arg1 = &temp1;
1860	+	for (unsigned int i=0; i<size; i++) {
1861	+	PyObject* o = PySequence_GetItem(obj0,i);
1862	+	if (PyString_Check(o)) {
1863	+	temp1[i] = (std::string)(\
1864	+	SwigString_AsString(o));
1865	+	Py_DECREF(o);
1866	+	}else {
1867	+	Py_DECREF(o);
1868	+	PyErr_SetString(PyExc_TypeError,
1869	+	"vector<""std::string""> expected");
1870	+	SWIG_fail;
1871	+	}
1872	+	}
1873	+	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1874	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1875	+	arg1 = v1;
1876	+	}else {
1877	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1878	+	SWIG_fail;
1879	+	}
1880	+	}
1881	+	{
1882	+	try {
1883	+	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1884	+
1885	+	}catch (const std::exception& e) {
1886	+	SWIG_exception(SWIG_RuntimeError, e.what());
1887	+	}
1888	+	}
1889	+	resultobj = PyInt_FromLong((long)result);
1890	+	return resultobj;
1891	+	fail:
1892	+	return NULL;
1893	+	}
1894	+
1895	+
1896	+	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1897	+	PyObject *resultobj;
1898	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1899	+	PyObject * obj0 = 0 ;
1900	+
1901	+	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1902	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1903	+	{
1904	+	try {
1905	+	(arg1)->clear();
1906	+
1907	+	}catch (const std::exception& e) {
1908	+	SWIG_exception(SWIG_RuntimeError, e.what());
1909	+	}
1910	+	}
1911	+	Py_INCREF(Py_None); resultobj = Py_None;
1912	+	return resultobj;
1913	+	fail:
1914	+	return NULL;
1915	+	}
1916	+
1917	+
1918	+	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1919	+	PyObject *resultobj;
1920	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1921	+	std::string arg2 ;
1922	+	PyObject * obj0 = 0 ;
1923	+	PyObject * obj1 = 0 ;
1924	+
1925	+	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
1926	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1927	+	{
1928	+	if (PyString_Check(obj1))
1929	+	arg2 = std::string(PyString_AsString(obj1));
1930	+	else
1931	+	SWIG_exception(SWIG_TypeError, "string expected");
1932	+	}
1933	+	{
1934	+	try {
1935	+	(arg1)->push_back(arg2);
1936	+
1937	+	}catch (const std::exception& e) {
1938	+	SWIG_exception(SWIG_RuntimeError, e.what());
1939	+	}
1940	+	}
1941	+	Py_INCREF(Py_None); resultobj = Py_None;
1942	+	return resultobj;
1943	+	fail:
1944	+	return NULL;
1945	+	}
1946	+
1947	+
1948	+	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
1949	+	PyObject *resultobj;
1950	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1951	+	std::string result;
1952	+	PyObject * obj0 = 0 ;
1953	+
1954	+	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
1955	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1956	+	{
1957	+	try {
1958	+	result = std_vectorlstd_string_g_pop___(arg1);
1959	+
1960	+	}catch (std::out_of_range& e) {
1961	+	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1962	+	}
1963	+	}
1964	+	{
1965	+	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1966	+	}
1967	+	return resultobj;
1968	+	fail:
1969	+	return NULL;
1970	+	}
1971	+
1972	+
1973	+	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
1974	+	PyObject *resultobj;
1975	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1976	+	int arg2 ;
1977	+	std::string result;
1978	+	PyObject * obj0 = 0 ;
1979	+
1980	+	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
1981	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1982	+	{
1983	+	try {
1984	+	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
1985	+
1986	+	}catch (std::out_of_range& e) {
1987	+	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1988	+	}
1989	+	}
1990	+	{
1991	+	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1992	+	}
1993	+	return resultobj;
1994	+	fail:
1995	+	return NULL;
1996	+	}
1997	+
1998	+
1999	+	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2000	+	PyObject *resultobj;
2001	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2002	+	int arg2 ;
2003	+	int arg3 ;
2004	+	std::vector<std::string > result;
2005	+	PyObject * obj0 = 0 ;
2006	+
2007	+	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2008	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2009	+	{
2010	+	try {
2011	+	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2012	+
2013	+	}catch (const std::exception& e) {
2014	+	SWIG_exception(SWIG_RuntimeError, e.what());
2015	+	}
2016	+	}
2017	+	{
2018	+	resultobj = PyTuple_New((&result)->size());
2019	+	for (unsigned int i=0; i<(&result)->size(); i++)
2020	+	PyTuple_SetItem(resultobj,i,
2021	+	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2022	+	}
2023	+	return resultobj;
2024	+	fail:
2025	+	return NULL;
2026	+	}
2027	+
2028	+
2029	+	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2030	+	PyObject *resultobj;
2031	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2032	+	int arg2 ;
2033	+	std::string arg3 ;
2034	+	PyObject * obj0 = 0 ;
2035	+	PyObject * obj2 = 0 ;
2036	+
2037	+	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2038	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2039	+	{
2040	+	if (PyString_Check(obj2))
2041	+	arg3 = std::string(PyString_AsString(obj2));
2042	+	else
2043	+	SWIG_exception(SWIG_TypeError, "string expected");
2044	+	}
2045	+	{
2046	+	try {
2047	+	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2048	+
2049	+	}catch (std::out_of_range& e) {
2050	+	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2051	+	}
2052	+	}
2053	+	Py_INCREF(Py_None); resultobj = Py_None;
2054	+	return resultobj;
2055	+	fail:
2056	+	return NULL;
2057	+	}
2058	+
2059	+
2060	+	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2061	+	PyObject *resultobj;
2062	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2063	+	int arg2 ;
2064	+	int arg3 ;
2065	+	std::vector<std::string > *arg4 = 0 ;
2066	+	std::vector<std::string > temp4 ;
2067	+	std::vector<std::string > *v4 ;
2068	+	PyObject * obj0 = 0 ;
2069	+	PyObject * obj3 = 0 ;
2070	+
2071	+	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2072	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2073	+	{
2074	+	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2075	+	unsigned int size = (PyTuple_Check(obj3) ?
2076	+	PyTuple_Size(obj3) :
2077	+	PyList_Size(obj3));
2078	+	temp4 = std::vector<std::string >(size);
2079	+	arg4 = &temp4;
2080	+	for (unsigned int i=0; i<size; i++) {
2081	+	PyObject* o = PySequence_GetItem(obj3,i);
2082	+	if (PyString_Check(o)) {
2083	+	temp4[i] = (std::string)(\
2084	+	SwigString_AsString(o));
2085	+	Py_DECREF(o);
2086	+	}else {
2087	+	Py_DECREF(o);
2088	+	PyErr_SetString(PyExc_TypeError,
2089	+	"vector<""std::string""> expected");
2090	+	SWIG_fail;
2091	+	}
2092	+	}
2093	+	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2094	+	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2095	+	arg4 = v4;
2096	+	}else {
2097	+	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2098	+	SWIG_fail;
2099	+	}
2100	+	}
2101	+	{
2102	+	try {
2103	+	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2104	+
2105	+	}catch (const std::exception& e) {
2106	+	SWIG_exception(SWIG_RuntimeError, e.what());
2107	+	}
2108	+	}
2109	+	Py_INCREF(Py_None); resultobj = Py_None;
2110	+	return resultobj;
2111	+	fail:
2112	+	return NULL;
2113	+	}
2114	+
2115	+
2116	+	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2117	+	PyObject *resultobj;
2118	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2119	+	int arg2 ;
2120	+	PyObject * obj0 = 0 ;
2121	+
2122	+	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2123	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2124	+	{
2125	+	try {
2126	+	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2127	+
2128	+	}catch (std::out_of_range& e) {
2129	+	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2130	+	}
2131	+	}
2132	+	Py_INCREF(Py_None); resultobj = Py_None;
2133	+	return resultobj;
2134	+	fail:
2135	+	return NULL;
2136	+	}
2137	+
2138	+
2139	+	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2140	+	PyObject *resultobj;
2141	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2142	+	int arg2 ;
2143	+	int arg3 ;
2144	+	PyObject * obj0 = 0 ;
2145	+
2146	+	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2147	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2148	+	{
2149	+	try {
2150	+	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2151	+
2152	+	}catch (const std::exception& e) {
2153	+	SWIG_exception(SWIG_RuntimeError, e.what());
2154	+	}
2155	+	}
2156	+	Py_INCREF(Py_None); resultobj = Py_None;
2157	+	return resultobj;
2158	+	fail:
2159	+	return NULL;
2160	+	}
2161	+
2162	+
2163	+	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2164	+	PyObject *resultobj;
2165	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2166	+	PyObject * obj0 = 0 ;
2167	+
2168	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2169	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2170	+	{
2171	+	try {
2172	+	delete arg1;
2173	+
2174	+	}catch (const std::exception& e) {
2175	+	SWIG_exception(SWIG_RuntimeError, e.what());
2176	+	}
2177	+	}
2178	+	Py_INCREF(Py_None); resultobj = Py_None;
2179	+	return resultobj;
2180	+	fail:
2181	+	return NULL;
2182	+	}
2183	+
2184	+
2185	+	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2186	+	PyObject *obj;
2187	+	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2188	+	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2189	+	Py_INCREF(obj);
2190	+	return Py_BuildValue((char *)"");
2191	+	}
2192	+	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
2193	+	PyObject *resultobj;
2194	+	BossSession *arg1 = (BossSession *) 0 ;
2195	+	std::vector<std::string > *arg2 = 0 ;
2196	+	PyObject *result;
2197	+	PyObject * obj0 = 0 ;
2198	+	PyObject * obj1 = 0 ;
2199	+
2200	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2201	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2202	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2203	+	if (arg2 == NULL) {
2204	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2205	+	}
2206	+	{
2207	+	try {
2208	+	result = (PyObject *)BossSession_show(arg1,*arg2);
2209	+
2210	+	}catch (const std::exception& e) {
2211	+	SWIG_exception(SWIG_RuntimeError, e.what());
2212	+	}
2213	+	}
2214	+	resultobj = result;
2215	+	return resultobj;
2216	+	fail:
2217	+	return NULL;
2218	+	}
2219	+
2220	+
2221	+	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
2222	+	PyObject *resultobj;
2223	+	BossSession *arg1 = (BossSession *) 0 ;
2224	+	PyObject *result;
2225	+	PyObject * obj0 = 0 ;
2226	+
2227	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2228	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2229	+	{
2230	+	try {
2231	+	result = (PyObject *)BossSession_CHTools(arg1);
2232	+
2233	+	}catch (const std::exception& e) {
2234	+	SWIG_exception(SWIG_RuntimeError, e.what());
2235	+	}
2236	+	}
2237	+	resultobj = result;
2238	+	return resultobj;
2239	+	fail:
2240	+	return NULL;
2241	+	}
2242	+
2243	+
2244	+	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
2245	+	PyObject *resultobj;
2246	+	BossSession *arg1 = (BossSession *) 0 ;
2247	+	PyObject *result;
2248	+	PyObject * obj0 = 0 ;
2249	+
2250	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2251	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2252	+	{
2253	+	try {
2254	+	result = (PyObject *)BossSession_ProgramTypes(arg1);
2255	+
2256	+	}catch (const std::exception& e) {
2257	+	SWIG_exception(SWIG_RuntimeError, e.what());
2258	+	}
2259	+	}
2260	+	resultobj = result;
2261	+	return resultobj;
2262	+	fail:
2263	+	return NULL;
2264	+	}
2265	+
2266	+
2267	+	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
2268	+	PyObject *resultobj;
2269	+	BossSession *arg1 = (BossSession *) 0 ;
2270	+	PyObject *result;
2271	+	PyObject * obj0 = 0 ;
2272	+
2273	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2274	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2275	+	{
2276	+	try {
2277	+	result = (PyObject *)BossSession_RTMons(arg1);
2278	+
2279	+	}catch (const std::exception& e) {
2280	+	SWIG_exception(SWIG_RuntimeError, e.what());
2281	+	}
2282	+	}
2283	+	resultobj = result;
2284	+	return resultobj;
2285	+	fail:
2286	+	return NULL;
2287	+	}
2288	+
2289	+
2290	+	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
2291	+	PyObject *resultobj;
2292	+	BossSession *arg1 = (BossSession *) 0 ;
2293	+	PyObject *result;
2294	+	PyObject * obj0 = 0 ;
2295	+
2296	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2297	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2298	+	{
2299	+	try {
2300	+	result = (PyObject *)BossSession_schedulers(arg1);
2301	+
2302	+	}catch (const std::exception& e) {
2303	+	SWIG_exception(SWIG_RuntimeError, e.what());
2304	+	}
2305	+	}
2306	+	resultobj = result;
2307	+	return resultobj;
2308	+	fail:
2309	+	return NULL;
2310	+	}
2311	+
2312	+
2313	+	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
2314	+	PyObject *resultobj;
2315	+	BossSession *arg1 = (BossSession *) 0 ;
2316	+	std::string *arg2 = 0 ;
2317	+	std::string *arg3 = 0 ;
2318	+	std::string const &arg4_defvalue = "" ;
2319	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
2320	+	std::string const &arg5_defvalue = "" ;
2321	+	std::string *arg5 = (std::string *) &arg5_defvalue ;
2322	+	bool arg6 = (bool) false ;
2323	+	PyObject *result;
2324	+	std::string temp2 ;
2325	+	std::string temp3 ;
2326	+	std::string temp4 ;
2327	+	std::string temp5 ;
2328	+	PyObject * obj0 = 0 ;
2329	+	PyObject * obj1 = 0 ;
2330	+	PyObject * obj2 = 0 ;
2331	+	PyObject * obj3 = 0 ;
2332	+	PyObject * obj4 = 0 ;
2333	+	PyObject * obj5 = 0 ;
2334	+
2335	+	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2336	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2337	+	{
2338	+	if (PyString_Check(obj1)) {
2339	+	temp2 = std::string(PyString_AsString(obj1));
2340	+	arg2 = &temp2;
2341	+	}else {
2342	+	SWIG_exception(SWIG_TypeError, "string expected");
2343	+	}
2344	+	}
2345	+	{
2346	+	if (PyString_Check(obj2)) {
2347	+	temp3 = std::string(PyString_AsString(obj2));
2348	+	arg3 = &temp3;
2349	+	}else {
2350	+	SWIG_exception(SWIG_TypeError, "string expected");
2351	+	}
2352	+	}
2353	+	if (obj3) {
2354	+	{
2355	+	if (PyString_Check(obj3)) {
2356	+	temp4 = std::string(PyString_AsString(obj3));
2357	+	arg4 = &temp4;
2358	+	}else {
2359	+	SWIG_exception(SWIG_TypeError, "string expected");
2360	+	}
2361	+	}
2362	+	}
2363	+	if (obj4) {
2364	+	{
2365	+	if (PyString_Check(obj4)) {
2366	+	temp5 = std::string(PyString_AsString(obj4));
2367	+	arg5 = &temp5;
2368	+	}else {
2369	+	SWIG_exception(SWIG_TypeError, "string expected");
2370	+	}
2371	+	}
2372	+	}
2373	+	if (obj5) {
2374	+	arg6 = PyInt_AsLong(obj5) ? true : false;
2375	+	if (PyErr_Occurred()) SWIG_fail;
2376	+	}
2377	+	{
2378	+	try {
2379	+	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
2380	+
2381	+	}catch (const std::exception& e) {
2382	+	SWIG_exception(SWIG_RuntimeError, e.what());
2383	+	}
2384	+	}
2385	+	resultobj = result;
2386	+	return resultobj;
2387	+	fail:
2388	+	return NULL;
2389	+	}
2390	+
2391	+
2392		static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2393		PyObject *resultobj;
2394		BossSession *arg1 = (BossSession *) 0 ;
#	Line 1648 | Line 2504 | static PyObject *_wrap_BossSession_query
2504		static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2505		PyObject *resultobj;
2506		std::string arg1 = (std::string) "" ;
2507	+	std::string arg2 = (std::string) "2" ;
2508	+	std::string arg3 = (std::string) "" ;
2509		BossSession *result;
2510		PyObject * obj0 = 0 ;
2511	+	PyObject * obj1 = 0 ;
2512	+	PyObject * obj2 = 0 ;
2513
2514	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2514	>	if(!PyArg_ParseTuple(args,(char *)"|OOO:new_BossSession",&obj0,&obj1,&obj2)) goto fail;
2515		if (obj0) {
2516		{
2517		if (PyString_Check(obj0))
#	Line 1660 | Line 2520 | static PyObject *_wrap_new_BossSession(P
2520		SWIG_exception(SWIG_TypeError, "string expected");
2521		}
2522		}
2523	+	if (obj1) {
2524	+	{
2525	+	if (PyString_Check(obj1))
2526	+	arg2 = std::string(PyString_AsString(obj1));
2527	+	else
2528	+	SWIG_exception(SWIG_TypeError, "string expected");
2529	+	}
2530	+	}
2531	+	if (obj2) {
2532	+	{
2533	+	if (PyString_Check(obj2))
2534	+	arg3 = std::string(PyString_AsString(obj2));
2535	+	else
2536	+	SWIG_exception(SWIG_TypeError, "string expected");
2537	+	}
2538	+	}
2539		{
2540		try {
2541	<	result = (BossSession *)new BossSession(arg1);
2541	>	result = (BossSession *)new BossSession(arg1,arg2,arg3);
2542
2543		}catch (const std::exception& e) {
2544		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1697 | Line 2573 | static PyObject *_wrap_delete_BossSessio
2573		}
2574
2575
2576	<	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2576	>	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2577		PyObject *resultobj;
2578		BossSession *arg1 = (BossSession *) 0 ;
1703	–	std::string const &arg2_defvalue = "" ;
1704	–	std::string *arg2 = (std::string *) &arg2_defvalue ;
1705	–	BossTask *result;
1706	–	std::string temp2 ;
2579		PyObject * obj0 = 0 ;
1708	–	PyObject * obj1 = 0 ;
2580
2581	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2581	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2582		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1712	–	if (obj1) {
1713	–	{
1714	–	if (PyString_Check(obj1)) {
1715	–	temp2 = std::string(PyString_AsString(obj1));
1716	–	arg2 = &temp2;
1717	–	}else {
1718	–	SWIG_exception(SWIG_TypeError, "string expected");
1719	–	}
1720	–	}
1721	–	}
2583		{
2584		try {
2585	<	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
1725	<
1726	<	}catch (const std::exception& e) {
1727	<	SWIG_exception(SWIG_RuntimeError, e.what());
1728	<	}
1729	<	}
1730	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
1731	<	return resultobj;
1732	<	fail:
1733	<	return NULL;
1734	<	}
1735	<
1736	<
1737	<	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
1738	<	PyObject *resultobj;
1739	<	BossSession *arg1 = (BossSession *) 0 ;
1740	<	BossTask *arg2 = (BossTask *) 0 ;
1741	<	PyObject * obj0 = 0 ;
1742	<	PyObject * obj1 = 0 ;
1743	<
1744	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
1745	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1746	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1747	<	{
1748	<	try {
1749	<	(arg1)->destroyBossTask(arg2);
2585	>	(arg1)->resetDB();
2586
2587		}catch (const std::exception& e) {
2588		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1759 | Line 2595 | static PyObject *_wrap_BossSession_destr
2595		}
2596
2597
2598	<	static PyObject *_wrap_BossSession_BossShowCHTools(PyObject *self, PyObject *args) {
2598	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2599		PyObject *resultobj;
2600		BossSession *arg1 = (BossSession *) 0 ;
1765	–	std::vector<std::string > result;
2601		PyObject * obj0 = 0 ;
2602
2603	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowCHTools",&obj0)) goto fail;
2603	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2604		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2605		{
2606		try {
2607	<	result = (arg1)->BossShowCHTools();
2607	>	(arg1)->clear();
2608
2609		}catch (const std::exception& e) {
2610		SWIG_exception(SWIG_RuntimeError, e.what());
2611		}
2612		}
2613	<	{
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	<	}
2613	>	Py_INCREF(Py_None); resultobj = Py_None;
2614		return resultobj;
2615		fail:
2616		return NULL;
2617		}
2618
2619
2620	<	static PyObject *_wrap_BossSession_BossShowProgramTypes(PyObject *self, PyObject *args) {
2620	>	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2621		PyObject *resultobj;
2622		BossSession *arg1 = (BossSession *) 0 ;
2623	<	std::vector<std::string > result;
2623	>	std::string const &arg2_defvalue = "" ;
2624	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
2625	>	BossTask *result;
2626	>	std::string temp2 ;
2627		PyObject * obj0 = 0 ;
2628	+	PyObject * obj1 = 0 ;
2629
2630	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowProgramTypes",&obj0)) goto fail;
2630	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2631		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2632	<	{
2633	<	try {
2634	<	result = (arg1)->BossShowProgramTypes();
2635	<
2636	<	}catch (const std::exception& e) {
2637	<	SWIG_exception(SWIG_RuntimeError, e.what());
2632	>	if (obj1) {
2633	>	{
2634	>	if (PyString_Check(obj1)) {
2635	>	temp2 = std::string(PyString_AsString(obj1));
2636	>	arg2 = &temp2;
2637	>	}else {
2638	>	SWIG_exception(SWIG_TypeError, "string expected");
2639	>	}
2640		}
2641		}
2642		{
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	–	{
2643		try {
2644	<	result = (arg1)->BossShowRTMon();
2644	>	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2645
2646		}catch (const std::exception& e) {
2647		SWIG_exception(SWIG_RuntimeError, e.what());
2648		}
2649		}
2650	<	{
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	<	}
2650	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2651		return resultobj;
2652		fail:
2653		return NULL;
2654		}
2655
2656
2657	<	static PyObject *_wrap_BossSession_BossShowSchedulers(PyObject *self, PyObject *args) {
2657	>	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2658		PyObject *resultobj;
2659		BossSession *arg1 = (BossSession *) 0 ;
2660	<	std::vector<std::string > result;
2660	>	BossTask *arg2 = (BossTask *) 0 ;
2661		PyObject * obj0 = 0 ;
2662	+	PyObject * obj1 = 0 ;
2663
2664	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossShowSchedulers",&obj0)) goto fail;
2664	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2665		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2666	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2667		{
2668		try {
2669	<	result = (arg1)->BossShowSchedulers();
2669	>	(arg1)->destroyBossTask(arg2);
2670
2671		}catch (const std::exception& e) {
2672		SWIG_exception(SWIG_RuntimeError, e.what());
2673		}
2674		}
2675	<	{
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	<	}
2675	>	Py_INCREF(Py_None); resultobj = Py_None;
2676		return resultobj;
2677		fail:
2678		return NULL;
2679		}
2680
2681
2682	<	static PyObject *_wrap_BossSession_BossDefaultCHTool(PyObject *self, PyObject *args) {
2682	>	static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
2683		PyObject *resultobj;
2684		BossSession *arg1 = (BossSession *) 0 ;
2685		std::string result;
2686		PyObject * obj0 = 0 ;
2687
2688	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultCHTool",&obj0)) goto fail;
2688	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) goto fail;
2689		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2690		{
2691		try {
2692	<	result = (arg1)->BossDefaultCHTool();
2692	>	result = (arg1)->defaultCHTool();
2693
2694		}catch (const std::exception& e) {
2695		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1892 | Line 2704 | static PyObject *_wrap_BossSession_BossD
2704		}
2705
2706
2707	<	static PyObject *_wrap_BossSession_BossDefaultProgramType(PyObject *self, PyObject *args) {
2707	>	static PyObject *_wrap_BossSession_defaultProgramType(PyObject *self, PyObject *args) {
2708		PyObject *resultobj;
2709		BossSession *arg1 = (BossSession *) 0 ;
2710		std::string result;
2711		PyObject * obj0 = 0 ;
2712
2713	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultProgramType",&obj0)) goto fail;
2713	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) goto fail;
2714		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2715		{
2716		try {
2717	<	result = (arg1)->BossDefaultProgramType();
2717	>	result = (arg1)->defaultProgramType();
2718
2719		}catch (const std::exception& e) {
2720		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1917 | Line 2729 | static PyObject *_wrap_BossSession_BossD
2729		}
2730
2731
2732	<	static PyObject *_wrap_BossSession_BossDefaultRTMon(PyObject *self, PyObject *args) {
2732	>	static PyObject *_wrap_BossSession_defaultRTMon(PyObject *self, PyObject *args) {
2733		PyObject *resultobj;
2734		BossSession *arg1 = (BossSession *) 0 ;
2735		std::string result;
2736		PyObject * obj0 = 0 ;
2737
2738	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultRTMon",&obj0)) goto fail;
2738	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) goto fail;
2739		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2740		{
2741		try {
2742	<	result = (arg1)->BossDefaultRTMon();
2742	>	result = (arg1)->defaultRTMon();
2743
2744		}catch (const std::exception& e) {
2745		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1942 | Line 2754 | static PyObject *_wrap_BossSession_BossD
2754		}
2755
2756
2757	<	static PyObject *_wrap_BossSession_BossDefaultScheduler(PyObject *self, PyObject *args) {
2757	>	static PyObject *_wrap_BossSession_defaultScheduler(PyObject *self, PyObject *args) {
2758		PyObject *resultobj;
2759		BossSession *arg1 = (BossSession *) 0 ;
2760		std::string result;
2761		PyObject * obj0 = 0 ;
2762
2763	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossDefaultScheduler",&obj0)) goto fail;
2763	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) goto fail;
2764		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2765		{
2766		try {
2767	<	result = (arg1)->BossDefaultScheduler();
2767	>	result = (arg1)->defaultScheduler();
2768
2769		}catch (const std::exception& e) {
2770		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1967 | Line 2779 | static PyObject *_wrap_BossSession_BossD
2779		}
2780
2781
2782	<	static PyObject *_wrap_BossSession_BossVersion(PyObject *self, PyObject *args) {
2782	>	static PyObject *_wrap_BossSession_version(PyObject *self, PyObject *args) {
2783		PyObject *resultobj;
2784		BossSession *arg1 = (BossSession *) 0 ;
2785		std::string result;
2786		PyObject * obj0 = 0 ;
2787
2788	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossVersion",&obj0)) goto fail;
2788	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) goto fail;
2789		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2790		{
2791		try {
2792	<	result = (arg1)->BossVersion();
2792	>	result = (arg1)->version();
2793
2794		}catch (const std::exception& e) {
2795		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 1992 | Line 2804 | static PyObject *_wrap_BossSession_BossV
2804		}
2805
2806
2807	<	static PyObject *_wrap_BossSession_BossClientID(PyObject *self, PyObject *args) {
2807	>	static PyObject *_wrap_BossSession_clientID(PyObject *self, PyObject *args) {
2808		PyObject *resultobj;
2809		BossSession *arg1 = (BossSession *) 0 ;
2810		std::string result;
2811		PyObject * obj0 = 0 ;
2812
2813	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_BossClientID",&obj0)) goto fail;
2813	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) goto fail;
2814		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2815		{
2816		try {
2817	<	result = (arg1)->BossClientID();
2817	>	result = (arg1)->clientID();
2818
2819		}catch (const std::exception& e) {
2820		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 2046 | Line 2858 | static PyObject *_wrap_BossSession_showC
2858		}
2859
2860
2861	<	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) {
2861	>	static PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2862		PyObject *resultobj;
2863		BossSession *arg1 = (BossSession *) 0 ;
2864		std::string arg2 = (std::string) "all" ;
#	Line 2128 | Line 2870 | static PyObject *_wrap_BossSession_BossR
2870		PyObject * obj2 = 0 ;
2871		PyObject * obj3 = 0 ;
2872
2873	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_BossRTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
2873	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
2874		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2875		if (obj1) {
2876		{
#	Line 2156 | Line 2898 | static PyObject *_wrap_BossSession_BossR
2898		}
2899		{
2900		try {
2901	<	result = (int)(arg1)->BossRTupdate(arg2,arg3,arg4);
2901	>	result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2902
2903		}catch (const std::exception& e) {
2904		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 2169 | Line 2911 | static PyObject *_wrap_BossSession_BossR
2911		}
2912
2913
2914	<	static PyObject *_wrap_BossSession_BossListMatch(PyObject *self, PyObject *args) {
2914	>	static PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
2915		PyObject *resultobj;
2916		BossSession *arg1 = (BossSession *) 0 ;
2917		std::string *arg2 = 0 ;
2918		std::string *arg3 = 0 ;
2919	<	std::ostream &arg4_defvalue = std::cout ;
2920	<	std::ostream *arg4 = (std::ostream *) &arg4_defvalue ;
2921	<	bool arg5 = (bool) false ;
2919	>	bool arg4 = (bool) false ;
2920	>	std::string const &arg5_defvalue = "" ;
2921	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2922		std::string const &arg6_defvalue = "" ;
2923		std::string *arg6 = (std::string *) &arg6_defvalue ;
2924	<	std::string const &arg7_defvalue = "" ;
2183	<	std::string *arg7 = (std::string *) &arg7_defvalue ;
2184	<	int result;
2924	>	std::vector<std::string > result;
2925		std::string temp2 ;
2926		std::string temp3 ;
2927	+	std::string temp5 ;
2928		std::string temp6 ;
2188	–	std::string temp7 ;
2929		PyObject * obj0 = 0 ;
2930		PyObject * obj1 = 0 ;
2931		PyObject * obj2 = 0 ;
2932		PyObject * obj3 = 0 ;
2933		PyObject * obj4 = 0 ;
2934		PyObject * obj5 = 0 ;
2195	–	PyObject * obj6 = 0 ;
2935
2936	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_BossListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2936	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2937		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2938		{
2939		if (PyString_Check(obj1)) {
#	Line 2213 | Line 2952 | static PyObject *_wrap_BossSession_BossL
2952		}
2953		}
2954		if (obj3) {
2955	<	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;
2955	>	arg4 = PyInt_AsLong(obj3) ? true : false;
2956		if (PyErr_Occurred()) SWIG_fail;
2957		}
2958	<	if (obj5) {
2958	>	if (obj4) {
2959		{
2960	<	if (PyString_Check(obj5)) {
2961	<	temp6 = std::string(PyString_AsString(obj5));
2962	<	arg6 = &temp6;
2960	>	if (PyString_Check(obj4)) {
2961	>	temp5 = std::string(PyString_AsString(obj4));
2962	>	arg5 = &temp5;
2963		}else {
2964		SWIG_exception(SWIG_TypeError, "string expected");
2965		}
2966		}
2967		}
2968	<	if (obj6) {
2968	>	if (obj5) {
2969		{
2970	<	if (PyString_Check(obj6)) {
2971	<	temp7 = std::string(PyString_AsString(obj6));
2972	<	arg7 = &temp7;
2970	>	if (PyString_Check(obj5)) {
2971	>	temp6 = std::string(PyString_AsString(obj5));
2972	>	arg6 = &temp6;
2973		}else {
2974		SWIG_exception(SWIG_TypeError, "string expected");
2975		}
#	Line 2244 | Line 2977 | static PyObject *_wrap_BossSession_BossL
2977		}
2978		{
2979		try {
2980	<	result = (int)(arg1)->BossListMatch((std::string const &)*arg2,(std::string const &)*arg3,*arg4,arg5,(std::string const &)*arg6,(std::string const &)*arg7);
2980	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2981
2982		}catch (const std::exception& e) {
2983		SWIG_exception(SWIG_RuntimeError, e.what());
2984		}
2985		}
2986	<	resultobj = PyInt_FromLong((long)result);
2986	>	{
2987	>	resultobj = PyTuple_New((&result)->size());
2988	>	for (unsigned int i=0; i<(&result)->size(); i++)
2989	>	PyTuple_SetItem(resultobj,i,
2990	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2991	>	}
2992		return resultobj;
2993		fail:
2994		return NULL;
2995		}
2996
2997
2998	<	static PyObject *_wrap_BossSession_jobQuery(PyObject *self, PyObject *args) {
2998	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
2999		PyObject *resultobj;
3000		BossSession *arg1 = (BossSession *) 0 ;
3001		int arg2 = (int) SCHEDULED ;
#	Line 2271 | Line 3009 | static PyObject *_wrap_BossSession_jobQu
3009		std::string arg7 = (std::string) "" ;
3010		std::string arg8 = (std::string) "" ;
3011		std::string arg9 = (std::string) "" ;
2274	–	bool arg10 = (bool) false ;
2275	–	SwigValueWrapper< std::vector<BossJob * > > result;
3012		std::string temp3 ;
3013		std::string temp4 ;
3014		std::string temp5 ;
#	Line 2284 | Line 3020 | static PyObject *_wrap_BossSession_jobQu
3020		PyObject * obj6 = 0 ;
3021		PyObject * obj7 = 0 ;
3022		PyObject * obj8 = 0 ;
2287	–	PyObject * obj9 = 0 ;
3023
3024	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_jobQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3024	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3025		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3026		if (obj2) {
3027		{
#	Line 2350 | Line 3085 | static PyObject *_wrap_BossSession_jobQu
3085		SWIG_exception(SWIG_TypeError, "string expected");
3086		}
3087		}
2353	–	if (obj9) {
2354	–	arg10 = PyInt_AsLong(obj9) ? true : false;
2355	–	if (PyErr_Occurred()) SWIG_fail;
2356	–	}
3088		{
3089		try {
3090	<	result = (arg1)->jobQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3090	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3091
3092		}catch (const std::exception& e) {
3093		SWIG_exception(SWIG_RuntimeError, e.what());
3094		}
3095		}
3096	<	{
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	<	}
3096	>	Py_INCREF(Py_None); resultobj = Py_None;
3097		return resultobj;
3098		fail:
3099		return NULL;
3100		}
3101
3102
3103	<	static PyObject *_wrap_BossSession_queryPrint(PyObject *self, PyObject *args) {
3103	>	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3104		PyObject *resultobj;
3105		BossSession *arg1 = (BossSession *) 0 ;
3106	<	SwigValueWrapper< std::vector<BossJob * > > arg2 ;
3107	<	std::ostream &arg3_defvalue = std::cout ;
3108	<	std::ostream *arg3 = (std::ostream *) &arg3_defvalue ;
3109	<	jobStates const &arg4_defvalue = SCHEDULED ;
3110	<	jobStates *arg4 = (jobStates *) &arg4_defvalue ;
3111	<	printOption const &arg5_defvalue = NORMAL ;
3112	<	printOption *arg5 = (printOption *) &arg5_defvalue ;
3113	<	std::string const &arg6_defvalue = "" ;
3114	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
3115	<	std::vector<BossJob * > *argp2 ;
3116	<	std::string temp6 ;
3106	>	std::string const &arg2_defvalue = "all" ;
3107	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3108	>	std::string const &arg3_defvalue = "" ;
3109	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3110	>	std::string const &arg4_defvalue = "" ;
3111	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3112	>	std::string const &arg5_defvalue = "" ;
3113	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3114	>	std::vector<std::string > result;
3115	>	std::string temp2 ;
3116	>	std::string temp3 ;
3117	>	std::string temp4 ;
3118	>	std::string temp5 ;
3119		PyObject * obj0 = 0 ;
3120		PyObject * obj1 = 0 ;
3121		PyObject * obj2 = 0 ;
3122		PyObject * obj3 = 0 ;
3123		PyObject * obj4 = 0 ;
2395	–	PyObject * obj5 = 0 ;
3124
3125	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossSession_queryPrint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3125	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3126		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3127	<	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3128	<	arg2 = *argp2;
3127	>	if (obj1) {
3128	>	{
3129	>	if (PyString_Check(obj1)) {
3130	>	temp2 = std::string(PyString_AsString(obj1));
3131	>	arg2 = &temp2;
3132	>	}else {
3133	>	SWIG_exception(SWIG_TypeError, "string expected");
3134	>	}
3135	>	}
3136	>	}
3137		if (obj2) {
3138	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3139	<	if (arg3 == NULL) {
3140	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3138	>	{
3139	>	if (PyString_Check(obj2)) {
3140	>	temp3 = std::string(PyString_AsString(obj2));
3141	>	arg3 = &temp3;
3142	>	}else {
3143	>	SWIG_exception(SWIG_TypeError, "string expected");
3144	>	}
3145		}
3146		}
3147		if (obj3) {
3148	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3149	<	if (arg4 == NULL) {
3150	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3148	>	{
3149	>	if (PyString_Check(obj3)) {
3150	>	temp4 = std::string(PyString_AsString(obj3));
3151	>	arg4 = &temp4;
3152	>	}else {
3153	>	SWIG_exception(SWIG_TypeError, "string expected");
3154	>	}
3155		}
3156		}
3157		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) {
3158		{
3159	<	if (PyString_Check(obj5)) {
3160	<	temp6 = std::string(PyString_AsString(obj5));
3161	<	arg6 = &temp6;
3159	>	if (PyString_Check(obj4)) {
3160	>	temp5 = std::string(PyString_AsString(obj4));
3161	>	arg5 = &temp5;
3162		}else {
3163		SWIG_exception(SWIG_TypeError, "string expected");
3164		}
#	Line 2428 | Line 3166 | static PyObject *_wrap_BossSession_query
3166		}
3167		{
3168		try {
3169	<	(arg1)->queryPrint(arg2,*arg3,(jobStates const &)*arg4,(printOption const &)*arg5,(std::string const &)*arg6);
3169	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3170
3171		}catch (const std::exception& e) {
3172		SWIG_exception(SWIG_RuntimeError, e.what());
3173		}
3174		}
3175	<	Py_INCREF(Py_None); resultobj = Py_None;
3175	>	{
3176	>	resultobj = PyTuple_New((&result)->size());
3177	>	for (unsigned int i=0; i<(&result)->size(); i++)
3178	>	PyTuple_SetItem(resultobj,i,
3179	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3180	>	}
3181		return resultobj;
3182		fail:
3183		return NULL;
3184		}
3185
3186
3187	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3187	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3188		PyObject *resultobj;
3189		BossSession *arg1 = (BossSession *) 0 ;
3190	<	std::string const &arg2_defvalue = "all" ;
3191	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
2449	<	std::string const &arg3_defvalue = "" ;
3190	>	int arg2 = (int) SCHEDULED ;
3191	>	std::string const &arg3_defvalue = "all" ;
3192		std::string *arg3 = (std::string *) &arg3_defvalue ;
3193	<	std::string const &arg4_defvalue = "" ;
3193	>	std::string const &arg4_defvalue = "all" ;
3194		std::string *arg4 = (std::string *) &arg4_defvalue ;
3195		std::string const &arg5_defvalue = "" ;
3196		std::string *arg5 = (std::string *) &arg5_defvalue ;
3197	<	std::vector<std::string > result;
3198	<	std::string temp2 ;
3197	>	std::string arg6 = (std::string) "" ;
3198	>	std::string arg7 = (std::string) "" ;
3199	>	std::string arg8 = (std::string) "" ;
3200	>	std::string arg9 = (std::string) "" ;
3201	>	bool arg10 = (bool) false ;
3202	>	SwigValueWrapper< std::vector<BossTask * > > result;
3203		std::string temp3 ;
3204		std::string temp4 ;
3205		std::string temp5 ;
3206		PyObject * obj0 = 0 ;
2461	–	PyObject * obj1 = 0 ;
3207		PyObject * obj2 = 0 ;
3208		PyObject * obj3 = 0 ;
3209		PyObject * obj4 = 0 ;
3210	+	PyObject * obj5 = 0 ;
3211	+	PyObject * obj6 = 0 ;
3212	+	PyObject * obj7 = 0 ;
3213	+	PyObject * obj8 = 0 ;
3214	+	PyObject * obj9 = 0 ;
3215
3216	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3216	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3217		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	–	}
3218		if (obj2) {
3219		{
3220		if (PyString_Check(obj2)) {
#	Line 2505 | Line 3245 | static PyObject *_wrap_BossSession_selec
3245		}
3246		}
3247		}
3248	+	if (obj5) {
3249	+	{
3250	+	if (PyString_Check(obj5))
3251	+	arg6 = std::string(PyString_AsString(obj5));
3252	+	else
3253	+	SWIG_exception(SWIG_TypeError, "string expected");
3254	+	}
3255	+	}
3256	+	if (obj6) {
3257	+	{
3258	+	if (PyString_Check(obj6))
3259	+	arg7 = std::string(PyString_AsString(obj6));
3260	+	else
3261	+	SWIG_exception(SWIG_TypeError, "string expected");
3262	+	}
3263	+	}
3264	+	if (obj7) {
3265	+	{
3266	+	if (PyString_Check(obj7))
3267	+	arg8 = std::string(PyString_AsString(obj7));
3268	+	else
3269	+	SWIG_exception(SWIG_TypeError, "string expected");
3270	+	}
3271	+	}
3272	+	if (obj8) {
3273	+	{
3274	+	if (PyString_Check(obj8))
3275	+	arg9 = std::string(PyString_AsString(obj8));
3276	+	else
3277	+	SWIG_exception(SWIG_TypeError, "string expected");
3278	+	}
3279	+	}
3280	+	if (obj9) {
3281	+	arg10 = PyInt_AsLong(obj9) ? true : false;
3282	+	if (PyErr_Occurred()) SWIG_fail;
3283	+	}
3284		{
3285		try {
3286	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3286	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3287
3288		}catch (const std::exception& e) {
3289		SWIG_exception(SWIG_RuntimeError, e.what());
3290		}
3291		}
3292		{
3293	<	std::vector<std::string > * resultptr;
3294	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
3295	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
3293	>	std::vector<BossTask * > * resultptr;
3294	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3295	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3296		}
3297		return resultobj;
3298		fail:
#	Line 2644 | Line 3420 | static PyObject * BossTaskException_swig
3420		Py_INCREF(obj);
3421		return Py_BuildValue((char *)"");
3422		}
3423	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3423	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3424		PyObject *resultobj;
3425		BossTask *arg1 = (BossTask *) 0 ;
3426	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3426	>	PyObject *arg2 = (PyObject *) 0 ;
3427	>	BossAttributeContainer *arg3 = 0 ;
3428		PyObject *result;
3429		PyObject * obj0 = 0 ;
3430		PyObject * obj1 = 0 ;
3431	+	PyObject * obj2 = 0 ;
3432
3433	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3433	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3434		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3435	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3436	<	if (arg2 == NULL) {
3435	>	arg2 = obj1;
3436	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3437	>	if (arg3 == NULL) {
3438		PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3439		}
3440		{
3441		try {
3442	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3442	>	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3443
3444		}catch (const std::exception& e) {
3445		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 2673 | Line 3452 | static PyObject *_wrap_BossTask_jobDict(
3452		}
3453
3454
3455	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
3455	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3456		PyObject *resultobj;
3457		BossTask *arg1 = (BossTask *) 0 ;
3458	+	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3459		PyObject *result;
3460		PyObject * obj0 = 0 ;
3461	+	PyObject * obj1 = 0 ;
3462
3463	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3463	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3464		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3465	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3466	+	if (arg2 == NULL) {
3467	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3468	+	}
3469		{
3470		try {
3471	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
3471	>	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3472
3473		}catch (const std::exception& e) {
3474		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 2696 | Line 3481 | static PyObject *_wrap_BossTask_jobsMap_
3481		}
3482
3483
3484	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3485	<	int argc;
3486	<	PyObject *argv[2];
3487	<	int ii;
3484	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
3485	>	PyObject *resultobj;
3486	>	BossTask *arg1 = (BossTask *) 0 ;
3487	>	PyObject *result;
3488	>	PyObject * obj0 = 0 ;
3489
3490	<	argc = PyObject_Length(args);
3491	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
3492	<	argv[ii] = PyTuple_GetItem(args,ii);
3493	<	}
3494	<	if (argc == 1) {
3495	<	int _v;
3496	<	{
3497	<	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);
3490	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3491	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3492	>	{
3493	>	try {
3494	>	result = (PyObject *)BossTask_jobsDict(arg1);
3495	>
3496	>	}catch (const std::exception& e) {
3497	>	SWIG_exception(SWIG_RuntimeError, e.what());
3498		}
3499		}
3500	<
3501	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
3500	>	resultobj = result;
3501	>	return resultobj;
3502	>	fail:
3503		return NULL;
3504		}
3505
#	Line 3015 | Line 3793 | static PyObject *_wrap_BossTask_name(PyO
3793		}
3794
3795
3796	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
3796	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3797		PyObject *resultobj;
3798		BossTask *arg1 = (BossTask *) 0 ;
3799	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3799	>	std::map<std::string,std::string > result;
3800		PyObject * obj0 = 0 ;
3801
3802	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3802	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3803		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3804		{
3805		try {
3806	<	result = ((BossTask const *)arg1)->jobsMap();
3806	>	result = ((BossTask const *)arg1)->taskMap();
3807
3808		}catch (const std::exception& e) {
3809		SWIG_exception(SWIG_RuntimeError, e.what());
3810		}
3811		}
3812		{
3813	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3814	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3815	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3813	>	resultobj = PyDict_New();
3814	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3815	>	PyDict_SetItem(resultobj,
3816	>	SwigString_FromString(i->first),
3817	>	SwigString_FromString(i->second));
3818	>	}
3819		}
3820		return resultobj;
3821		fail:
#	Line 3042 | Line 3823 | static PyObject *_wrap_BossTask_jobsMap_
3823		}
3824
3825
3826	<	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
3826	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3827		PyObject *resultobj;
3828		BossTask *arg1 = (BossTask *) 0 ;
3829	<	unsigned int arg2 ;
3049	<	std::map<std::string,std::string > result;
3829	>	BossTask::job_iterator result;
3830		PyObject * obj0 = 0 ;
3051	–	PyObject * obj1 = 0 ;
3831
3832	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
3832	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3833		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;
3834		{
3835		try {
3836	<	result = ((BossTask const *)arg1)->jobMap(arg2);
3836	>	result = ((BossTask const *)arg1)->job_begin();
3837
3838		}catch (const std::exception& e) {
3839		SWIG_exception(SWIG_RuntimeError, e.what());
3840		}
3841		}
3842		{
3843	<	resultobj = PyDict_New();
3844	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3845	<	PyDict_SetItem(resultobj,
3846	<	SwigString_FromString(i->first),
3847	<	SwigString_FromString(i->second));
3843	>	BossTask::job_iterator * resultptr;
3844	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3845	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3846	>	}
3847	>	return resultobj;
3848	>	fail:
3849	>	return NULL;
3850	>	}
3851	>
3852	>
3853	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3854	>	PyObject *resultobj;
3855	>	BossTask *arg1 = (BossTask *) 0 ;
3856	>	BossTask::job_iterator result;
3857	>	PyObject * obj0 = 0 ;
3858	>
3859	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3860	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3861	>	{
3862	>	try {
3863	>	result = ((BossTask const *)arg1)->job_end();
3864	>
3865	>	}catch (const std::exception& e) {
3866	>	SWIG_exception(SWIG_RuntimeError, e.what());
3867		}
3868		}
3869	+	{
3870	+	BossTask::job_iterator * resultptr;
3871	+	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3872	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3873	+	}
3874		return resultobj;
3875		fail:
3876		return NULL;
3877		}
3878
3879
3880	<	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
3880	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3881	>	PyObject *resultobj;
3882	>	BossTask *arg1 = (BossTask *) 0 ;
3883	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3884	>	PyObject * obj0 = 0 ;
3885	>
3886	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3887	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3888	>	{
3889	>	try {
3890	>	result = ((BossTask const *)arg1)->jobsMap();
3891	>
3892	>	}catch (const std::exception& e) {
3893	>	SWIG_exception(SWIG_RuntimeError, e.what());
3894	>	}
3895	>	}
3896	>	{
3897	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3898	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3899	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3900	>	}
3901	>	return resultobj;
3902	>	fail:
3903	>	return NULL;
3904	>	}
3905	>
3906	>
3907	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
3908		PyObject *resultobj;
3909		BossTask *arg1 = (BossTask *) 0 ;
3910		SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
#	Line 3112 | Line 3940 | static PyObject *_wrap_BossTask_jobMap__
3940		}
3941
3942
3943	+	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
3944	+	PyObject *resultobj;
3945	+	BossTask *arg1 = (BossTask *) 0 ;
3946	+	unsigned int arg2 ;
3947	+	std::map<std::string,std::string > result;
3948	+	PyObject * obj0 = 0 ;
3949	+	PyObject * obj1 = 0 ;
3950	+
3951	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
3952	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3953	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
3954	+	if (PyErr_Occurred()) SWIG_fail;
3955	+	{
3956	+	try {
3957	+	result = ((BossTask const *)arg1)->jobMap(arg2);
3958	+
3959	+	}catch (const std::exception& e) {
3960	+	SWIG_exception(SWIG_RuntimeError, e.what());
3961	+	}
3962	+	}
3963	+	{
3964	+	resultobj = PyDict_New();
3965	+	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3966	+	PyDict_SetItem(resultobj,
3967	+	SwigString_FromString(i->first),
3968	+	SwigString_FromString(i->second));
3969	+	}
3970	+	}
3971	+	return resultobj;
3972	+	fail:
3973	+	return NULL;
3974	+	}
3975	+
3976	+
3977		static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
3978		int argc;
3979		PyObject *argv[4];
#	Line 3137 | Line 3999 | static PyObject *_wrap_BossTask_jobMap(P
3999		_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4000		}
4001		if (_v) {
4002	<	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4002	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4003		}
4004		}
4005		}
#	Line 3173 | Line 4035 | static PyObject *_wrap_BossTask_jobMap(P
4035		}
4036		}
4037		if (_v) {
4038	<	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4038	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4039		}
4040		}
4041		}
#	Line 3184 | Line 4046 | static PyObject *_wrap_BossTask_jobMap(P
4046		}
4047
4048
4049	<	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) {
4049	>	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4050		PyObject *resultobj;
4051		BossTask *arg1 = (BossTask *) 0 ;
4052	<	BossTask::job_iterator result;
4052	>	BossJob *arg2 = (BossJob *) 0 ;
4053	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4054		PyObject * obj0 = 0 ;
4055	+	PyObject * obj1 = 0 ;
4056
4057	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4057	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4058		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4059	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4060		{
4061		try {
4062	<	result = ((BossTask const *)arg1)->job_end();
4062	>	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4063
4064		}catch (const std::exception& e) {
4065		SWIG_exception(SWIG_RuntimeError, e.what());
4066		}
4067		}
4068		{
4069	<	BossTask::job_iterator * resultptr;
4070	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4071	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4069	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4070	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4071	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4072		}
4073		return resultobj;
4074		fail:
#	Line 3268 | Line 4106 | static PyObject *_wrap_BossTask_queryJob
4106		}
4107
4108
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	–
4109		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4110		PyObject *resultobj;
4111		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3519 | Line 4327 | static PyObject *_wrap_BossTask_archive(
4327		}
4328
4329
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	–
4330		static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4331		PyObject *resultobj;
4332		BossTask *arg1 = (BossTask *) 0 ;
#	Line 3728 | Line 4506 | static PyObject *_wrap_BossTask_kill(PyO
4506		}
4507
4508
4509	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
4509	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4510		PyObject *resultobj;
4511		BossTask *arg1 = (BossTask *) 0 ;
4512		std::string const &arg2_defvalue = "all" ;
#	Line 3791 | Line 4569 | static PyObject *_wrap_BossTask_getOutpu
4569		}
4570
4571
4572	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
4572	>	static PyObject *_wrap_BossTask_getAllOutput(PyObject *self, PyObject *args) {
4573		PyObject *resultobj;
4574		BossTask *arg1 = (BossTask *) 0 ;
4575		std::string const &arg2_defvalue = "" ;
#	Line 3805 | Line 4583 | static PyObject *_wrap_BossTask_getOutpu
4583		PyObject * obj2 = 0 ;
4584		PyObject * obj3 = 0 ;
4585
4586	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4586	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4587		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4588		if (obj1) {
4589		{
#	Line 3827 | Line 4605 | static PyObject *_wrap_BossTask_getOutpu
4605		}
4606		{
4607		try {
4608	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
4608	>	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3,arg4);
4609
4610		}catch (const std::exception& e) {
4611		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 3840 | Line 4618 | static PyObject *_wrap_BossTask_getOutpu
4618		}
4619
4620
4621	<	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4622	<	int argc;
4623	<	PyObject *argv[6];
4624	<	int ii;
4621	>	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4622	>	PyObject *resultobj;
4623	>	BossTask *arg1 = (BossTask *) 0 ;
4624	>	int arg2 = (int) SCHEDULED ;
4625	>	std::string const &arg3_defvalue = "all" ;
4626	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4627	>	std::string const &arg4_defvalue = "" ;
4628	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4629	>	std::string arg5 = (std::string) "" ;
4630	>	std::string arg6 = (std::string) "" ;
4631	>	std::string arg7 = (std::string) "" ;
4632	>	std::string arg8 = (std::string) "" ;
4633	>	int result;
4634	>	std::string temp3 ;
4635	>	std::string temp4 ;
4636	>	PyObject * obj0 = 0 ;
4637	>	PyObject * obj2 = 0 ;
4638	>	PyObject * obj3 = 0 ;
4639	>	PyObject * obj4 = 0 ;
4640	>	PyObject * obj5 = 0 ;
4641	>	PyObject * obj6 = 0 ;
4642	>	PyObject * obj7 = 0 ;
4643
4644	<	argc = PyObject_Length(args);
4645	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
4646	<	argv[ii] = PyTuple_GetItem(args,ii);
3851	<	}
3852	<	if ((argc >= 1) && (argc <= 5)) {
3853	<	int _v;
4644	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4645	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4646	>	if (obj2) {
4647		{
4648	<	void *ptr;
4649	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4650	<	_v = 0;
3858	<	PyErr_Clear();
4648	>	if (PyString_Check(obj2)) {
4649	>	temp3 = std::string(PyString_AsString(obj2));
4650	>	arg3 = &temp3;
4651		}else {
4652	<	_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	<	}
4652	>	SWIG_exception(SWIG_TypeError, "string expected");
4653		}
4654		}
4655		}
4656	<	if ((argc >= 1) && (argc <= 4)) {
3900	<	int _v;
4656	>	if (obj3) {
4657		{
4658	<	void *ptr;
4659	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4660	<	_v = 0;
3905	<	PyErr_Clear();
4658	>	if (PyString_Check(obj3)) {
4659	>	temp4 = std::string(PyString_AsString(obj3));
4660	>	arg4 = &temp4;
4661		}else {
4662	<	_v = 1;
4662	>	SWIG_exception(SWIG_TypeError, "string expected");
4663		}
4664		}
4665	<	if (_v) {
4666	<	if (argc <= 1) {
4667	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
4668	<	}
4669	<	{
4670	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4671	<	}
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	<	}
4665	>	}
4666	>	if (obj4) {
4667	>	{
4668	>	if (PyString_Check(obj4))
4669	>	arg5 = std::string(PyString_AsString(obj4));
4670	>	else
4671	>	SWIG_exception(SWIG_TypeError, "string expected");
4672		}
4673		}
4674	<
4675	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
4674	>	if (obj5) {
4675	>	{
4676	>	if (PyString_Check(obj5))
4677	>	arg6 = std::string(PyString_AsString(obj5));
4678	>	else
4679	>	SWIG_exception(SWIG_TypeError, "string expected");
4680	>	}
4681	>	}
4682	>	if (obj6) {
4683	>	{
4684	>	if (PyString_Check(obj6))
4685	>	arg7 = std::string(PyString_AsString(obj6));
4686	>	else
4687	>	SWIG_exception(SWIG_TypeError, "string expected");
4688	>	}
4689	>	}
4690	>	if (obj7) {
4691	>	{
4692	>	if (PyString_Check(obj7))
4693	>	arg8 = std::string(PyString_AsString(obj7));
4694	>	else
4695	>	SWIG_exception(SWIG_TypeError, "string expected");
4696	>	}
4697	>	}
4698	>	{
4699	>	try {
4700	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4701	>
4702	>	}catch (const std::exception& e) {
4703	>	SWIG_exception(SWIG_RuntimeError, e.what());
4704	>	}
4705	>	}
4706	>	resultobj = PyInt_FromLong((long)result);
4707	>	return resultobj;
4708	>	fail:
4709		return NULL;
4710		}
4711
#	Line 4120 | Line 4889 | static PyObject *_wrap_BossTask_clear(Py
4889		}
4890
4891
4123	–	static PyObject *_wrap_BossTask_prompt(PyObject *self, PyObject *args) {
4124	–	PyObject *resultobj;
4125	–	BossTask *arg1 = (BossTask *) 0 ;
4126	–	std::string *arg2 = 0 ;
4127	–	bool result;
4128	–	std::string temp2 ;
4129	–	PyObject * obj0 = 0 ;
4130	–	PyObject * obj1 = 0 ;
4131	–
4132	–	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;
4134	–	{
4135	–	if (PyString_Check(obj1)) {
4136	–	temp2 = std::string(PyString_AsString(obj1));
4137	–	arg2 = &temp2;
4138	–	}else {
4139	–	SWIG_exception(SWIG_TypeError, "string expected");
4140	–	}
4141	–	}
4142	–	{
4143	–	try {
4144	–	result = (bool)(arg1)->prompt((std::string const &)*arg2);
4145	–
4146	–	}catch (const std::exception& e) {
4147	–	SWIG_exception(SWIG_RuntimeError, e.what());
4148	–	}
4149	–	}
4150	–	resultobj = PyInt_FromLong((long)result);
4151	–	return resultobj;
4152	–	fail:
4153	–	return NULL;
4154	–	}
4155	–
4156	–
4892		static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
4893		PyObject *obj;
4894		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 4164 | Line 4899 | static PyObject * BossTask_swigregister(
4899		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
4900		PyObject *resultobj;
4901		std::string arg1 = (std::string) "" ;
4902	<	bool arg2 = (bool) false ;
4902	>	std::string arg2 = (std::string) "2" ;
4903	>	std::string arg3 = (std::string) "" ;
4904	>	bool arg4 = (bool) false ;
4905		BossAdministratorSession *result;
4906		PyObject * obj0 = 0 ;
4907		PyObject * obj1 = 0 ;
4908	+	PyObject * obj2 = 0 ;
4909	+	PyObject * obj3 = 0 ;
4910
4911	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
4911	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
4912		if (obj0) {
4913		{
4914		if (PyString_Check(obj0))
#	Line 4179 | Line 4918 | static PyObject *_wrap_new_BossAdministr
4918		}
4919		}
4920		if (obj1) {
4921	<	arg2 = PyInt_AsLong(obj1) ? true : false;
4921	>	{
4922	>	if (PyString_Check(obj1))
4923	>	arg2 = std::string(PyString_AsString(obj1));
4924	>	else
4925	>	SWIG_exception(SWIG_TypeError, "string expected");
4926	>	}
4927	>	}
4928	>	if (obj2) {
4929	>	{
4930	>	if (PyString_Check(obj2))
4931	>	arg3 = std::string(PyString_AsString(obj2));
4932	>	else
4933	>	SWIG_exception(SWIG_TypeError, "string expected");
4934	>	}
4935	>	}
4936	>	if (obj3) {
4937	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4938		if (PyErr_Occurred()) SWIG_fail;
4939		}
4940		{
4941		try {
4942	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
4942	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4);
4943
4944		}catch (const std::exception& e) {
4945		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 4219 | Line 4974 | static PyObject *_wrap_delete_BossAdmini
4974		}
4975
4976
4977	+	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
4978	+	PyObject *resultobj;
4979	+	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4980	+	int result;
4981	+	PyObject * obj0 = 0 ;
4982	+
4983	+	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
4984	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4985	+	{
4986	+	try {
4987	+	result = (int)(arg1)->configureDB();
4988	+
4989	+	}catch (const std::exception& e) {
4990	+	SWIG_exception(SWIG_RuntimeError, e.what());
4991	+	}
4992	+	}
4993	+	resultobj = PyInt_FromLong((long)result);
4994	+	return resultobj;
4995	+	fail:
4996	+	return NULL;
4997	+	}
4998	+
4999	+
5000		static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
5001		PyObject *resultobj;
5002		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
#	Line 4639 | Line 5417 | static PyObject *_wrap_BossAdministrator
5417		std::string arg13 = (std::string) "" ;
5418		bool arg14 = (bool) false ;
5419		bool arg15 = (bool) false ;
5420	+	bool arg16 = (bool) false ;
5421	+	bool arg17 = (bool) false ;
5422		int result;
5423		std::string temp2 ;
5424		std::string temp11 ;
#	Line 4657 | Line 5437 | static PyObject *_wrap_BossAdministrator
5437		PyObject * obj12 = 0 ;
5438		PyObject * obj13 = 0 ;
5439		PyObject * obj14 = 0 ;
5440	+	PyObject * obj15 = 0 ;
5441	+	PyObject * obj16 = 0 ;
5442
5443	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) goto fail;
5443	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) goto fail;
5444		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5445		{
5446		if (PyString_Check(obj1)) {
#	Line 4766 | Line 5548 | static PyObject *_wrap_BossAdministrator
5548		arg15 = PyInt_AsLong(obj14) ? true : false;
5549		if (PyErr_Occurred()) SWIG_fail;
5550		}
5551	+	if (obj15) {
5552	+	arg16 = PyInt_AsLong(obj15) ? true : false;
5553	+	if (PyErr_Occurred()) SWIG_fail;
5554	+	}
5555	+	if (obj16) {
5556	+	arg17 = PyInt_AsLong(obj16) ? true : false;
5557	+	if (PyErr_Occurred()) SWIG_fail;
5558	+	}
5559		{
5560		try {
5561	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
5561	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15,arg16,arg17);
5562
5563		}catch (const std::exception& e) {
5564		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 4806 | Line 5596 | static PyObject *_wrap_BossAdministrator
5596		}
5597
5598
5599	<	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
5599	>	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
5600		PyObject *resultobj;
5601		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5602	<	std::string *arg2 = 0 ;
5602	>	std::string arg2 ;
5603	>	bool arg3 = (bool) false ;
5604		std::string result;
5605		PyObject * obj0 = 0 ;
5606		PyObject * obj1 = 0 ;
5607	+	PyObject * obj2 = 0 ;
5608
5609	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureDB",&obj0,&obj1)) goto fail;
5609	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
5610		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5611	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5612	<	if (arg2 == NULL) {
5613	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5611	>	{
5612	>	if (PyString_Check(obj1))
5613	>	arg2 = std::string(PyString_AsString(obj1));
5614	>	else
5615	>	SWIG_exception(SWIG_TypeError, "string expected");
5616	>	}
5617	>	if (obj2) {
5618	>	arg3 = PyInt_AsLong(obj2) ? true : false;
5619	>	if (PyErr_Occurred()) SWIG_fail;
5620		}
5621		{
5622		try {
5623	<	result = (arg1)->configureDB(*arg2);
5623	>	result = (arg1)->SQL(arg2,arg3);
5624
5625		}catch (const std::exception& e) {
5626		SWIG_exception(SWIG_RuntimeError, e.what());
#	Line 4837 | Line 5635 | static PyObject *_wrap_BossAdministrator
5635		}
5636
5637
5638	<	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
5638	>	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
5639		PyObject *resultobj;
5640		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5641		std::string *arg2 = 0 ;
5642	<	bool arg3 = (bool) false ;
5643	<	std::string result;
5642	>	std::string *arg3 = 0 ;
5643	>	std::string *arg4 = 0 ;
5644	>	std::string const &arg5_defvalue = "0" ;
5645	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
5646	>	int result;
5647	>	std::string temp2 ;
5648	>	std::string temp3 ;
5649	>	std::string temp4 ;
5650	>	std::string temp5 ;
5651		PyObject * obj0 = 0 ;
5652		PyObject * obj1 = 0 ;
5653		PyObject * obj2 = 0 ;
5654	+	PyObject * obj3 = 0 ;
5655	+	PyObject * obj4 = 0 ;
5656
5657	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
5657	>	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5658		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5659	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5660	<	if (arg2 == NULL) {
5661	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5659	>	{
5660	>	if (PyString_Check(obj1)) {
5661	>	temp2 = std::string(PyString_AsString(obj1));
5662	>	arg2 = &temp2;
5663	>	}else {
5664	>	SWIG_exception(SWIG_TypeError, "string expected");
5665	>	}
5666		}
5667	<	if (obj2) {
5668	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5669	<	if (PyErr_Occurred()) SWIG_fail;
5667	>	{
5668	>	if (PyString_Check(obj2)) {
5669	>	temp3 = std::string(PyString_AsString(obj2));
5670	>	arg3 = &temp3;
5671	>	}else {
5672	>	SWIG_exception(SWIG_TypeError, "string expected");
5673	>	}
5674	>	}
5675	>	{
5676	>	if (PyString_Check(obj3)) {
5677	>	temp4 = std::string(PyString_AsString(obj3));
5678	>	arg4 = &temp4;
5679	>	}else {
5680	>	SWIG_exception(SWIG_TypeError, "string expected");
5681	>	}
5682	>	}
5683	>	if (obj4) {
5684	>	{
5685	>	if (PyString_Check(obj4)) {
5686	>	temp5 = std::string(PyString_AsString(obj4));
5687	>	arg5 = &temp5;
5688	>	}else {
5689	>	SWIG_exception(SWIG_TypeError, "string expected");
5690	>	}
5691	>	}
5692		}
5693		{
5694		try {
5695	<	result = (arg1)->SQL(*arg2,arg3);
5695	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
5696
5697		}catch (const std::exception& e) {
5698		SWIG_exception(SWIG_RuntimeError, e.what());
5699		}
5700		}
5701	<	{
4869	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4870	<	}
5701	>	resultobj = PyInt_FromLong((long)result);
5702		return resultobj;
5703		fail:
5704		return NULL;
5705		}
5706
5707
5708	<	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
5708	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
5709		PyObject *resultobj;
5710		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5711	<	std::string *arg2 = 0 ;
5712	<	std::string result;
5711	>	std::string arg2 ;
5712	>	int result;
5713		PyObject * obj0 = 0 ;
5714		PyObject * obj1 = 0 ;
5715
5716	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_purge",&obj0,&obj1)) goto fail;
5716	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
5717		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5718	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__string,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5719	<	if (arg2 == NULL) {
5720	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5718	>	{
5719	>	if (PyString_Check(obj1))
5720	>	arg2 = std::string(PyString_AsString(obj1));
5721	>	else
5722	>	SWIG_exception(SWIG_TypeError, "string expected");
5723		}
5724		{
5725		try {
5726	<	result = (arg1)->purge(*arg2);
5726	>	result = (int)(arg1)->registerPlugins(arg2);
5727
5728		}catch (const std::exception& e) {
5729		SWIG_exception(SWIG_RuntimeError, e.what());
5730		}
5731		}
5732	<	{
4900	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4901	<	}
5732	>	resultobj = PyInt_FromLong((long)result);
5733		return resultobj;
5734		fail:
5735		return NULL;
#	Line 4928 | Line 5759 | static PyMethodDef SwigMethods[] = {
5759		{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
5760		{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
5761		{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
5762	+	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
5763	+	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
5764	+	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
5765	+	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
5766	+	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
5767	+	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
5768	+	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
5769	+	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
5770	+	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
5771	+	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
5772	+	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
5773	+	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
5774	+	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
5775	+	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5776	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5777	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5778	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5779	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5780	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5781	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5782		{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
5783		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
5784		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
5785	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
5786	+	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
5787		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
5788		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
5789	<	{ (char *)"BossSession_BossShowCHTools", _wrap_BossSession_BossShowCHTools, METH_VARARGS },
5790	<	{ (char *)"BossSession_BossShowProgramTypes", _wrap_BossSession_BossShowProgramTypes, METH_VARARGS },
5791	<	{ (char *)"BossSession_BossShowRTMon", _wrap_BossSession_BossShowRTMon, METH_VARARGS },
5792	<	{ (char *)"BossSession_BossShowSchedulers", _wrap_BossSession_BossShowSchedulers, METH_VARARGS },
5793	<	{ (char *)"BossSession_BossDefaultCHTool", _wrap_BossSession_BossDefaultCHTool, METH_VARARGS },
5794	<	{ (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 },
5789	>	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
5790	>	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
5791	>	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
5792	>	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS },
5793	>	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
5794	>	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
5795		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5796	<	{ (char *)"BossSession_purgeTasks", _wrap_BossSession_purgeTasks, METH_VARARGS },
5797	<	{ (char *)"BossSession_BossRTupdate", _wrap_BossSession_BossRTupdate, METH_VARARGS },
5798	<	{ (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 },
5796	>	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
5797	>	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
5798	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
5799		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
5800	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
5801		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5802		{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5803		{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
#	Line 4957 | Line 5805 | static PyMethodDef SwigMethods[] = {
5805		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
5806		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
5807		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5808	+	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5809		{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5810	<	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5810	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
5811		{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5812		{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
5813		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
5814		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
5815		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
5816		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
5817	<	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5817	>	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5818		{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5819		{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
5820	<	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
5820	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5821	>	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5822		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
5823	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
5824		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
5825		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
5826		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
4976	–	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5827		{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
5828		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
5829		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
5830		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
5831	+	{ (char *)"BossTask_getAllOutput", _wrap_BossTask_getAllOutput, METH_VARARGS },
5832	+	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
5833		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
5834		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
5835		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
4984	–	{ (char *)"BossTask_prompt", _wrap_BossTask_prompt, METH_VARARGS },
5836		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5837		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
5838		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
5839	+	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
5840		{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
5841		{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
5842		{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
#	Line 4995 | Line 5847 | static PyMethodDef SwigMethods[] = {
5847		{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
5848		{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
5849		{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
4998	–	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
5850		{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
5851		{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
5852	+	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
5853		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
5854		{ NULL, NULL }
5855		};
#	Line 5005 | Line 5857 | static PyMethodDef SwigMethods[] = {
5857
5858		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5859
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}};
5860		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}};
5861	+	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}};
5862		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
5863	+	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}};
5864		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}};
5865		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
5866		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5867	<	static swig_type_info _swigt__p_std__string[] = {{"_p_std__string", 0, "std::string *", 0},{"_p_std__string"},{0}};
5867	>	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
5868	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
5869		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}};
5870		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
5871	+	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
5872		static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
5873		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}};
5874		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}};
5875		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}};
5876		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}};
5877		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}};
5878	+	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
5879
5880		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,
5881		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
5882	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
5883		_swigt__p_XMLDoc,
5884	+	_swigt__p_std__vectorTBossTask_p_t,
5885		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
5034	–	_swigt__p_std__ostream,
5886		_swigt__p_BossTask,
5887		_swigt__p_BossTaskException,
5888	<	_swigt__p_std__string,
5888	>	_swigt__p_std__ostream,
5889	>	_swigt__p_BossAttributeContainer,
5890		_swigt__p_printOption,
5039	–	_swigt__p_BossDatabase,
5891		_swigt__p_BossJob,
5892	+	_swigt__p_BossDatabase,
5893		_swigt__p_BossSession,
5894		_swigt__p_std__vectorTstd__string_t,
5895		_swigt__p_std__mapTstd__string_std__string_t,
5896		_swigt__p_BossAdministratorSession,
5045	–	_swigt__p_jobStates,
5897		_swigt__p_BossTask__job_iterator,
5898		_swigt__p_std__vectorTBossJob_p_t__const_iterator,
5899	+	_swigt__p_jobStates,
5900		0
5901		};
5902

Diff Legend

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