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.1 by yzhang, Wed Jun 14 19:56:41 2006 UTC vs.
Revision 1.15 by gcodispo, Mon Nov 6 15:03:14 2006 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_BossSession swig_types[0]
658	<	#define  SWIGTYPE_p_BossUserSession swig_types[1]
659	<	#define  SWIGTYPE_p_BossAdministratorSession swig_types[2]
660	<	static swig_type_info *swig_types[4];
657	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[0]
658	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[1]
659	>	#define  SWIGTYPE_p_XMLDoc swig_types[2]
660	>	#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[3]
661	>	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662	>	#define  SWIGTYPE_p_BossTask swig_types[5]
663	>	#define  SWIGTYPE_p_BossTaskException swig_types[6]
664	>	#define  SWIGTYPE_p_std__ostream swig_types[7]
665	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[8]
666	>	#define  SWIGTYPE_p_printOption swig_types[9]
667	>	#define  SWIGTYPE_p_BossJob swig_types[10]
668	>	#define  SWIGTYPE_p_BossDatabase swig_types[11]
669	>	#define  SWIGTYPE_p_BossSession swig_types[12]
670	>	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671	>	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672	>	#define  SWIGTYPE_p_BossAdministratorSession swig_types[15]
673	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[16]
674	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[17]
675	>	#define  SWIGTYPE_p_jobStates swig_types[18]
676	>	static swig_type_info *swig_types[20];
677
678		/* -------- TYPES TABLE (END) -------- */
679
#	Line 669 | Line 685 | static swig_type_info *swig_types[4];
685
686		#define SWIG_name    "_BossSession"
687
672	–	#include "BossUserSession.h"
673	–	#include "BossAdministratorSession.h"
674	–
675	–
688		#define  SWIG_MemoryError    1
689		#define  SWIG_IOError        2
690		#define  SWIG_RuntimeError   3
#	Line 760 | Line 772 | std::string SwigString_AsString(PyObject
772		#include <algorithm>
773		#include <stdexcept>
774
775	+	bool std_maplstd_stringcstd_string_g___nonzero_____(std::map<std::string,std::string > *self){
776	+	return !(self->empty());
777	+	}
778	+	std::string std_maplstd_stringcstd_string_g___getitem_____(std::map<std::string,std::string > *self,std::string key){
779	+	std::map<std::string,std::string >::iterator i = self->find(key);
780	+	if (i != self->end())
781	+	return i->second;
782	+	else
783	+	throw std::out_of_range("key not found");
784	+	}
785	+	void std_maplstd_stringcstd_string_g___setitem_____(std::map<std::string,std::string > *self,std::string key,std::string x){
786	+	(*self)[key] = x;
787	+	}
788	+	void std_maplstd_stringcstd_string_g___delitem_____(std::map<std::string,std::string > *self,std::string key){
789	+	std::map<std::string,std::string >::iterator i = self->find(key);
790	+	if (i != self->end())
791	+	self->erase(i);
792	+	else
793	+	throw std::out_of_range("key not found");
794	+	}
795	+	bool std_maplstd_stringcstd_string_g_has_key___(std::map<std::string,std::string > *self,std::string key){
796	+	std::map<std::string,std::string >::iterator i = self->find(key);
797	+	return i != self->end();
798	+	}
799	+	PyObject *std_maplstd_stringcstd_string_g_keys___(std::map<std::string,std::string > *self){
800	+	PyObject* keyList = PyList_New(self->size());
801	+	std::map<std::string,std::string >::iterator i;
802	+	unsigned int j;
803	+	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
804	+	PyList_SetItem(keyList,j,
805	+	SwigString_FromString(i->first));
806	+	}
807	+	return keyList;
808	+	}
809	+	PyObject *std_maplstd_stringcstd_string_g_values___(std::map<std::string,std::string > *self){
810	+	PyObject* valueList = PyList_New(self->size());
811	+	std::map<std::string,std::string >::iterator i;
812	+	unsigned int j;
813	+	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
814	+	PyList_SetItem(valueList,j,
815	+	SwigString_FromString(i->second));
816	+	}
817	+	return valueList;
818	+	}
819	+	PyObject *std_maplstd_stringcstd_string_g_items___(std::map<std::string,std::string > *self){
820	+	PyObject* itemList = PyList_New(self->size());
821	+	std::map<std::string,std::string >::iterator i;
822	+	unsigned int j;
823	+	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
824	+	PyObject* item = PyTuple_New(2);
825	+	PyTuple_SetItem(item,0,
826	+	SwigString_FromString(i->first));
827	+	PyTuple_SetItem(item,1,
828	+	SwigString_FromString(i->second));
829	+	PyList_SetItem(itemList,j,item);
830	+	}
831	+	return itemList;
832	+	}
833	+	bool std_maplstd_stringcstd_string_g___contains_____(std::map<std::string,std::string > *self,std::string key){
834	+	std::map<std::string,std::string >::iterator i = self->find(key);
835	+	return i != self->end();
836	+	}
837	+	PyObject *std_maplstd_stringcstd_string_g___iter_____(std::map<std::string,std::string > *self){
838	+	#if PY_VERSION_HEX >= 0x02020000
839	+	PyObject* keyList = PyList_New(self->size());
840	+	std::map<std::string,std::string >::iterator i;
841	+	unsigned int j;
842	+	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
843	+	PyList_SetItem(keyList,j,
844	+	SwigString_FromString(i->first));
845	+	}
846	+	PyObject* iter = PyObject_GetIter(keyList);
847	+	Py_DECREF(keyList);
848	+	return iter;
849	+	#else
850	+	throw std::runtime_error("Python 2.2 or later is needed"
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"
922	+	#include "BossTask.h"
923	+	#include "BossJob.h"
924	+	#include "BossTaskCore.h"
925	+	#include "BossAttributeContainer.h"
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	+	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);
972	+	for ( std::vector <std::string>::const_iterator it= taskList.begin();
973	+	it!= taskList.end(); ++it ) {
974	+	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
975	+	}
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();
996	+	std::string tmp;
997	+
998	+	BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
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();
1003	+	for (std::set<std::string>::const_iterator it =sch.begin();
1004	+	it != sch_end; ++ it ) {
1005	+	tmp = (*it);
1006	+	char * key = new char[ tmp.size() ];
1007	+	key = strdup(tmp.c_str());
1008	+	tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1009	+	PyObject * val = PyString_FromString( tmp.c_str() );
1010	+	PyDict_SetItemString( job_dict, key, val );
1011	+	delete [] key;
1012	+	}
1013	+	return job_dict;
1014	+	}
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();
1022	+	PyObject * tmp =  BossTask_jobDict( self, jit );
1023	+	PyObject * myid =  PyString_FromString(id.c_str() );
1024	+	PyDict_SetItem( job_dict, myid,tmp );
1025	+	}
1026	+	return job_dict;
1027	+	}
1028	+	PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator &programs_it){
1029	+
1030	+	PyObject * job_dict = PyDict_New();
1031	+
1032	+	std::string tmp;
1033	+
1034	+	// PROGRAM
1035	+	BossAttributeContainer obj =
1036	+	(programs_it->first).getTableEntries("PROGRAM");
1037	+	BossTask_appendToPyDict ( self, job_dict, obj );
1038	+
1039	+	// PROGRAM_EXEC
1040	+	obj.clear();
1041	+	obj = (programs_it->second).getTableEntries("PROGRAM_EXEC");
1042	+	BossTask_appendToPyDict ( self, job_dict, obj );
1043	+
1044	+	// SPECIFICS
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	+	}
1052	+	PyObject *BossTask_jobPrograms(BossTask const *self,std::string const &jobid){
1053	+
1054	+	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1055	+	std::map< std::string, std::map< std::string, std::string > > ret_val;
1056	+	std::vector< std::pair<BossProgram, BossProgramExec > >
1057	+	programs = self->queryJobPrograms ( jH );
1058	+	std::vector< std::pair<BossProgram, BossProgramExec > >::const_iterator
1059	+	programs_it_end = programs.end();
1060	+	std::vector< std::pair<BossProgram, BossProgramExec > >::const_iterator
1061	+	programs_it;
1062	+
1063	+
1064	+	PyObject * job_dict = PyDict_New();
1065	+
1066	+	for ( programs_it = programs.begin(); programs_it != programs_it_end;
1067	+	++programs_it  ) {
1068	+	std::string id = (programs_it->first)["PROGRAM.ID"];
1069	+	PyObject * tmp =  BossTask_progDict( self, programs_it );
1070	+	PyObject * myid =  PyString_FromString(id.c_str() );
1071	+	PyDict_SetItem( job_dict, myid,tmp );
1072	+	}
1073	+	return job_dict;
1074	+	}
1075		#ifdef __cplusplus
1076		extern "C" {
1077		#endif
1078	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
1078	>	static PyObject *_wrap_new_objectMap__SWIG_0(PyObject *self, PyObject *args) {
1079		PyObject *resultobj;
1080	<	BossSession *result;
1080	>	std::map<std::string,std::string > *result;
1081
1082	<	if(!PyArg_ParseTuple(args,(char *)":new_BossSession")) goto fail;
1083	<	result = (BossSession *)new BossSession();
1082	>	if(!PyArg_ParseTuple(args,(char *)":new_objectMap")) goto fail;
1083	>	{
1084	>	try {
1085	>	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1086	>
1087	>	}catch (const std::exception& e) {
1088	>	SWIG_exception(SWIG_RuntimeError, e.what());
1089	>	}
1090	>	}
1091	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
1092	>	return resultobj;
1093	>	fail:
1094	>	return NULL;
1095	>	}
1096	>
1097	>
1098	>	static PyObject *_wrap_new_objectMap__SWIG_1(PyObject *self, PyObject *args) {
1099	>	PyObject *resultobj;
1100	>	std::map<std::string,std::string > *arg1 = 0 ;
1101	>	std::map<std::string,std::string > *result;
1102	>	std::map<std::string,std::string > temp1 ;
1103	>	std::map<std::string,std::string > *m1 ;
1104	>	PyObject * obj0 = 0 ;
1105
1106	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
1106	>	if(!PyArg_ParseTuple(args,(char *)"O:new_objectMap",&obj0)) goto fail;
1107	>	{
1108	>	if (PyDict_Check(obj0)) {
1109	>	PyObject* items = PyMapping_Items(obj0);
1110	>	unsigned int size = PyList_Size(items);
1111	>	temp1 = std::map<std::string,std::string >();
1112	>	arg1 = &temp1;
1113	>	for (unsigned int i=0; i<size; i++) {
1114	>	PyObject* pair = PySequence_GetItem(items,i);
1115	>	PyObject* key = PySequence_GetItem(pair,0);
1116	>	PyObject* o = PySequence_GetItem(pair,1);
1117	>	if (PyString_Check(key) && PyString_Check(o)) {
1118	>	temp1[SwigString_AsString(key)] = SwigString_AsString(o);
1119	>	Py_DECREF(key);
1120	>	Py_DECREF(o);
1121	>	Py_DECREF(pair);
1122	>	}else {
1123	>	Py_DECREF(key);
1124	>	Py_DECREF(o);
1125	>	Py_DECREF(pair);
1126	>	Py_DECREF(items);
1127	>	PyErr_SetString(PyExc_TypeError,
1128	>	"map<""std::string"",""std::string""> expected");
1129	>	SWIG_fail;
1130	>	}
1131	>	}
1132	>	Py_DECREF(items);
1133	>	}else if (SWIG_ConvertPtr(obj0,(void **) &m1,
1134	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
1135	>	arg1 = m1;
1136	>	}else {
1137	>	PyErr_SetString(PyExc_TypeError,
1138	>	"map<""std::string"",""std::string""> expected");
1139	>	SWIG_fail;
1140	>	}
1141	>	}
1142	>	{
1143	>	try {
1144	>	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1145	>
1146	>	}catch (const std::exception& e) {
1147	>	SWIG_exception(SWIG_RuntimeError, e.what());
1148	>	}
1149	>	}
1150	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
1151		return resultobj;
1152		fail:
1153		return NULL;
1154		}
1155
1156
1157	<	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
1157	>	static PyObject *_wrap_new_objectMap(PyObject *self, PyObject *args) {
1158	>	int argc;
1159	>	PyObject *argv[2];
1160	>	int ii;
1161	>
1162	>	argc = PyObject_Length(args);
1163	>	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1164	>	argv[ii] = PyTuple_GetItem(args,ii);
1165	>	}
1166	>	if (argc == 0) {
1167	>	return _wrap_new_objectMap__SWIG_0(self,args);
1168	>	}
1169	>	if (argc == 1) {
1170	>	int _v;
1171	>	{
1172	>	/* native sequence? */
1173	>	if (PyDict_Check(argv[0])) {
1174	>	PyObject* items = PyMapping_Items(argv[0]);
1175	>	unsigned int size = PyList_Size(items);
1176	>	if (size == 0) {
1177	>	/* an empty dictionary can be of any type */
1178	>	_v = 1;
1179	>	}else {
1180	>	/* check the first element only */
1181	>	PyObject* pair = PySequence_GetItem(items,0);
1182	>	PyObject* key = PySequence_GetItem(pair,0);
1183	>	PyObject* o = PySequence_GetItem(pair,1);
1184	>	if (PyString_Check(key) && PyString_Check(o))
1185	>	_v = 1;
1186	>	else
1187	>	_v = 0;
1188	>	Py_DECREF(key);
1189	>	Py_DECREF(o);
1190	>	Py_DECREF(pair);
1191	>	}
1192	>	Py_DECREF(items);
1193	>	}else {
1194	>	/* wrapped map? */
1195	>	std::map<std::string,std::string >* m;
1196	>	if (SWIG_ConvertPtr(argv[0],(void **) &m,
1197	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1)
1198	>	_v = 1;
1199	>	else
1200	>	_v = 0;
1201	>	}
1202	>	}
1203	>	if (_v) {
1204	>	return _wrap_new_objectMap__SWIG_1(self,args);
1205	>	}
1206	>	}
1207	>
1208	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_objectMap'");
1209	>	return NULL;
1210	>	}
1211	>
1212	>
1213	>	static PyObject *_wrap_objectMap___len__(PyObject *self, PyObject *args) {
1214		PyObject *resultobj;
1215	<	BossSession *arg1 = (BossSession *) 0 ;
1215	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1216	>	unsigned int result;
1217	>	std::map<std::string,std::string > temp1 ;
1218	>	std::map<std::string,std::string > *m1 ;
1219		PyObject * obj0 = 0 ;
1220
1221	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
1222	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1223	<	delete arg1;
1221	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___len__",&obj0)) goto fail;
1222	>	{
1223	>	if (PyDict_Check(obj0)) {
1224	>	PyObject* items = PyMapping_Items(obj0);
1225	>	unsigned int size = PyList_Size(items);
1226	>	temp1 = std::map<std::string,std::string >();
1227	>	arg1 = &temp1;
1228	>	for (unsigned int i=0; i<size; i++) {
1229	>	PyObject* pair = PySequence_GetItem(items,i);
1230	>	PyObject* key = PySequence_GetItem(pair,0);
1231	>	PyObject* o = PySequence_GetItem(pair,1);
1232	>	if (PyString_Check(key) && PyString_Check(o)) {
1233	>	temp1[SwigString_AsString(key)] = SwigString_AsString(o);
1234	>	Py_DECREF(key);
1235	>	Py_DECREF(o);
1236	>	Py_DECREF(pair);
1237	>	}else {
1238	>	Py_DECREF(key);
1239	>	Py_DECREF(o);
1240	>	Py_DECREF(pair);
1241	>	Py_DECREF(items);
1242	>	PyErr_SetString(PyExc_TypeError,
1243	>	"map<""std::string"",""std::string""> expected");
1244	>	SWIG_fail;
1245	>	}
1246	>	}
1247	>	Py_DECREF(items);
1248	>	}else if (SWIG_ConvertPtr(obj0,(void **) &m1,
1249	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
1250	>	arg1 = m1;
1251	>	}else {
1252	>	PyErr_SetString(PyExc_TypeError,
1253	>	"map<""std::string"",""std::string""> expected");
1254	>	SWIG_fail;
1255	>	}
1256	>	}
1257	>	{
1258	>	try {
1259	>	result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1260	>
1261	>	}catch (const std::exception& e) {
1262	>	SWIG_exception(SWIG_RuntimeError, e.what());
1263	>	}
1264	>	}
1265	>	resultobj = PyInt_FromLong((long)result);
1266	>	return resultobj;
1267	>	fail:
1268	>	return NULL;
1269	>	}
1270	>
1271	>
1272	>	static PyObject *_wrap_objectMap_clear(PyObject *self, PyObject *args) {
1273	>	PyObject *resultobj;
1274	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1275	>	PyObject * obj0 = 0 ;
1276
1277	+	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_clear",&obj0)) goto fail;
1278	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1279	+	{
1280	+	try {
1281	+	(arg1)->clear();
1282	+
1283	+	}catch (const std::exception& e) {
1284	+	SWIG_exception(SWIG_RuntimeError, e.what());
1285	+	}
1286	+	}
1287		Py_INCREF(Py_None); resultobj = Py_None;
1288		return resultobj;
1289		fail:
#	Line 793 | Line 1291 | static PyObject *_wrap_delete_BossSessio
1291		}
1292
1293
1294	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
1295	<	PyObject *obj;
1296	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
1297	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
1298	<	Py_INCREF(obj);
1299	<	return Py_BuildValue((char *)"");
1294	>	static PyObject *_wrap_objectMap___nonzero__(PyObject *self, PyObject *args) {
1295	>	PyObject *resultobj;
1296	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1297	>	bool result;
1298	>	PyObject * obj0 = 0 ;
1299	>
1300	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___nonzero__",&obj0)) goto fail;
1301	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1302	>	{
1303	>	try {
1304	>	result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1305	>
1306	>	}catch (const std::exception& e) {
1307	>	SWIG_exception(SWIG_RuntimeError, e.what());
1308	>	}
1309	>	}
1310	>	resultobj = PyInt_FromLong((long)result);
1311	>	return resultobj;
1312	>	fail:
1313	>	return NULL;
1314		}
1315	<	static PyObject *_wrap_new_BossUserSession(PyObject *self, PyObject *args) {
1315	>
1316	>
1317	>	static PyObject *_wrap_objectMap___getitem__(PyObject *self, PyObject *args) {
1318		PyObject *resultobj;
1319	<	std::string arg1 ;
1320	<	BossUserSession *result;
1319	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1320	>	std::string arg2 ;
1321	>	std::string result;
1322		PyObject * obj0 = 0 ;
1323	+	PyObject * obj1 = 0 ;
1324
1325	<	if(!PyArg_ParseTuple(args,(char *)"O:new_BossUserSession",&obj0)) goto fail;
1325	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___getitem__",&obj0,&obj1)) goto fail;
1326	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1327		{
1328	<	if (PyString_Check(obj0))
1329	<	arg1 = std::string(PyString_AsString(obj0));
1328	>	if (PyString_Check(obj1))
1329	>	arg2 = std::string(PyString_AsString(obj1));
1330		else
1331		SWIG_exception(SWIG_TypeError, "string expected");
1332		}
1333	<	result = (BossUserSession *)new BossUserSession(arg1);
1334	<
1335	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossUserSession, 1);
1333	>	{
1334	>	try {
1335	>	result = std_maplstd_stringcstd_string_g___getitem_____(arg1,arg2);
1336	>
1337	>	}catch (std::out_of_range& e) {
1338	>	PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
1339	>	SWIG_fail;
1340	>	}
1341	>	}
1342	>	{
1343	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1344	>	}
1345		return resultobj;
1346		fail:
1347		return NULL;
1348		}
1349
1350
1351	<	static PyObject *_wrap_delete_BossUserSession(PyObject *self, PyObject *args) {
1351	>	static PyObject *_wrap_objectMap___setitem__(PyObject *self, PyObject *args) {
1352		PyObject *resultobj;
1353	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
1353	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1354	>	std::string arg2 ;
1355	>	std::string arg3 ;
1356		PyObject * obj0 = 0 ;
1357	+	PyObject * obj1 = 0 ;
1358	+	PyObject * obj2 = 0 ;
1359
1360	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossUserSession",&obj0)) goto fail;
1361	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1362	<	delete arg1;
1363	<
1360	>	if(!PyArg_ParseTuple(args,(char *)"OOO:objectMap___setitem__",&obj0,&obj1,&obj2)) goto fail;
1361	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1362	>	{
1363	>	if (PyString_Check(obj1))
1364	>	arg2 = std::string(PyString_AsString(obj1));
1365	>	else
1366	>	SWIG_exception(SWIG_TypeError, "string expected");
1367	>	}
1368	>	{
1369	>	if (PyString_Check(obj2))
1370	>	arg3 = std::string(PyString_AsString(obj2));
1371	>	else
1372	>	SWIG_exception(SWIG_TypeError, "string expected");
1373	>	}
1374	>	{
1375	>	try {
1376	>	std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1377	>
1378	>	}catch (const std::exception& e) {
1379	>	SWIG_exception(SWIG_RuntimeError, e.what());
1380	>	}
1381	>	}
1382		Py_INCREF(Py_None); resultobj = Py_None;
1383		return resultobj;
1384		fail:
#	Line 838 | Line 1386 | static PyObject *_wrap_delete_BossUserSe
1386		}
1387
1388
1389	<	static PyObject *_wrap_BossUserSession_exitCode(PyObject *self, PyObject *args) {
1389	>	static PyObject *_wrap_objectMap___delitem__(PyObject *self, PyObject *args) {
1390		PyObject *resultobj;
1391	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
1392	<	int result;
1391	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1392	>	std::string arg2 ;
1393		PyObject * obj0 = 0 ;
1394	+	PyObject * obj1 = 0 ;
1395
1396	<	if(!PyArg_ParseTuple(args,(char *)"O:BossUserSession_exitCode",&obj0)) goto fail;
1397	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1398	<	result = (int)(arg1)->exitCode();
1396	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___delitem__",&obj0,&obj1)) goto fail;
1397	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1398	>	{
1399	>	if (PyString_Check(obj1))
1400	>	arg2 = std::string(PyString_AsString(obj1));
1401	>	else
1402	>	SWIG_exception(SWIG_TypeError, "string expected");
1403	>	}
1404	>	{
1405	>	try {
1406	>	std_maplstd_stringcstd_string_g___delitem_____(arg1,arg2);
1407	>
1408	>	}catch (std::out_of_range& e) {
1409	>	PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
1410	>	SWIG_fail;
1411	>	}
1412	>	}
1413	>	Py_INCREF(Py_None); resultobj = Py_None;
1414	>	return resultobj;
1415	>	fail:
1416	>	return NULL;
1417	>	}
1418	>
1419	>
1420	>	static PyObject *_wrap_objectMap_has_key(PyObject *self, PyObject *args) {
1421	>	PyObject *resultobj;
1422	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1423	>	std::string arg2 ;
1424	>	bool result;
1425	>	PyObject * obj0 = 0 ;
1426	>	PyObject * obj1 = 0 ;
1427
1428	+	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap_has_key",&obj0,&obj1)) goto fail;
1429	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1430	+	{
1431	+	if (PyString_Check(obj1))
1432	+	arg2 = std::string(PyString_AsString(obj1));
1433	+	else
1434	+	SWIG_exception(SWIG_TypeError, "string expected");
1435	+	}
1436	+	{
1437	+	try {
1438	+	result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1439	+
1440	+	}catch (const std::exception& e) {
1441	+	SWIG_exception(SWIG_RuntimeError, e.what());
1442	+	}
1443	+	}
1444		resultobj = PyInt_FromLong((long)result);
1445		return resultobj;
1446		fail:
#	Line 855 | Line 1448 | static PyObject *_wrap_BossUserSession_e
1448		}
1449
1450
1451	<	static PyObject *_wrap_BossUserSession_out(PyObject *self, PyObject *args) {
1451	>	static PyObject *_wrap_objectMap_keys(PyObject *self, PyObject *args) {
1452		PyObject *resultobj;
1453	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
1454	<	std::string result;
1453	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1454	>	PyObject *result;
1455		PyObject * obj0 = 0 ;
1456
1457	<	if(!PyArg_ParseTuple(args,(char *)"O:BossUserSession_out",&obj0)) goto fail;
1458	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1459	<	result = (arg1)->out();
1457	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_keys",&obj0)) goto fail;
1458	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1459	>	{
1460	>	try {
1461	>	result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1462	>
1463	>	}catch (const std::exception& e) {
1464	>	SWIG_exception(SWIG_RuntimeError, e.what());
1465	>	}
1466	>	}
1467	>	resultobj = result;
1468	>	return resultobj;
1469	>	fail:
1470	>	return NULL;
1471	>	}
1472	>
1473	>
1474	>	static PyObject *_wrap_objectMap_values(PyObject *self, PyObject *args) {
1475	>	PyObject *resultobj;
1476	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1477	>	PyObject *result;
1478	>	PyObject * obj0 = 0 ;
1479
1480	+	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_values",&obj0)) goto fail;
1481	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1482		{
1483	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1483	>	try {
1484	>	result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1485	>
1486	>	}catch (const std::exception& e) {
1487	>	SWIG_exception(SWIG_RuntimeError, e.what());
1488	>	}
1489		}
1490	+	resultobj = result;
1491		return resultobj;
1492		fail:
1493		return NULL;
1494		}
1495
1496
1497	<	static PyObject *_wrap_BossUserSession_err(PyObject *self, PyObject *args) {
1497	>	static PyObject *_wrap_objectMap_items(PyObject *self, PyObject *args) {
1498		PyObject *resultobj;
1499	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
1500	<	std::string result;
1499	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1500	>	PyObject *result;
1501	>	PyObject * obj0 = 0 ;
1502	>
1503	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_items",&obj0)) goto fail;
1504	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1505	>	{
1506	>	try {
1507	>	result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1508	>
1509	>	}catch (const std::exception& e) {
1510	>	SWIG_exception(SWIG_RuntimeError, e.what());
1511	>	}
1512	>	}
1513	>	resultobj = result;
1514	>	return resultobj;
1515	>	fail:
1516	>	return NULL;
1517	>	}
1518	>
1519	>
1520	>	static PyObject *_wrap_objectMap___contains__(PyObject *self, PyObject *args) {
1521	>	PyObject *resultobj;
1522	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1523	>	std::string arg2 ;
1524	>	bool result;
1525		PyObject * obj0 = 0 ;
1526	+	PyObject * obj1 = 0 ;
1527
1528	<	if(!PyArg_ParseTuple(args,(char *)"O:BossUserSession_err",&obj0)) goto fail;
1529	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1530	<	result = (arg1)->err();
1528	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___contains__",&obj0,&obj1)) goto fail;
1529	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1530	>	{
1531	>	if (PyString_Check(obj1))
1532	>	arg2 = std::string(PyString_AsString(obj1));
1533	>	else
1534	>	SWIG_exception(SWIG_TypeError, "string expected");
1535	>	}
1536	>	{
1537	>	try {
1538	>	result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1539	>
1540	>	}catch (const std::exception& e) {
1541	>	SWIG_exception(SWIG_RuntimeError, e.what());
1542	>	}
1543	>	}
1544	>	resultobj = PyInt_FromLong((long)result);
1545	>	return resultobj;
1546	>	fail:
1547	>	return NULL;
1548	>	}
1549	>
1550	>
1551	>	static PyObject *_wrap_objectMap___iter__(PyObject *self, PyObject *args) {
1552	>	PyObject *resultobj;
1553	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1554	>	PyObject *result;
1555	>	PyObject * obj0 = 0 ;
1556
1557	+	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___iter__",&obj0)) goto fail;
1558	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1559		{
1560	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1560	>	try {
1561	>	result = (PyObject *)std_maplstd_stringcstd_string_g___iter_____(arg1);
1562	>
1563	>	}catch (std::runtime_error& e) {
1564	>	PyErr_SetString(PyExc_RuntimeError,const_cast<char*>(e.what()));
1565	>	SWIG_fail;
1566	>	}
1567		}
1568	+	resultobj = result;
1569		return resultobj;
1570		fail:
1571		return NULL;
1572		}
1573
1574
1575	<	static PyObject *_wrap_BossUserSession_help(PyObject *self, PyObject *args) {
1575	>	static PyObject *_wrap_delete_objectMap(PyObject *self, PyObject *args) {
1576		PyObject *resultobj;
1577	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
1578	<	std::string arg2 = (std::string) "NONE" ;
1579	<	std::string result;
1577	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1578	>	PyObject * obj0 = 0 ;
1579	>
1580	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_objectMap",&obj0)) goto fail;
1581	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1582	>	{
1583	>	try {
1584	>	delete arg1;
1585	>
1586	>	}catch (const std::exception& e) {
1587	>	SWIG_exception(SWIG_RuntimeError, e.what());
1588	>	}
1589	>	}
1590	>	Py_INCREF(Py_None); resultobj = Py_None;
1591	>	return resultobj;
1592	>	fail:
1593	>	return NULL;
1594	>	}
1595	>
1596	>
1597	>	static PyObject * objectMap_swigregister(PyObject *self, PyObject *args) {
1598	>	PyObject *obj;
1599	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
1600	>	SWIG_TypeClientData(SWIGTYPE_p_std__mapTstd__string_std__string_t, obj);
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 *)"O|O:BossUserSession_help",&obj0,&obj1)) goto fail;
1640	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1641	<	if (obj1) {
1642	<	{
1643	<	if (PyString_Check(obj1))
1644	<	arg2 = std::string(PyString_AsString(obj1));
1645	<	else
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	<	result = (arg1)->help(arg2);
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	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
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_BossUserSession_SQL(PyObject *self, PyObject *args) {
1844	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1845		PyObject *resultobj;
1846	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
1847	<	std::string arg2 = (std::string) "NONE" ;
1848	<	std::string result;
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 *)"O|O:BossUserSession_SQL",&obj0,&obj1)) goto fail;
1926	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1927	<	if (obj1) {
1928	<	{
1929	<	if (PyString_Check(obj1))
1930	<	arg2 = std::string(PyString_AsString(obj1));
1931	<	else
1932	<	SWIG_exception(SWIG_TypeError, "string expected");
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	<	result = (arg1)->SQL(arg2);
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		}
#	Line 951 | Line 1970 | static PyObject *_wrap_BossUserSession_S
1970		}
1971
1972
1973	<	static PyObject *_wrap_BossUserSession_RTupdate(PyObject *self, PyObject *args) {
1973	>	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
1974		PyObject *resultobj;
1975	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
1976	<	std::string arg2 = (std::string) "NONE" ;
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 *)"O|O:BossUserSession_RTupdate",&obj0,&obj1)) goto fail;
2201	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2202	<	if (obj1) {
2203	<	{
2204	<	if (PyString_Check(obj1))
2205	<	arg2 = std::string(PyString_AsString(obj1));
2206	<	else
2207	<	SWIG_exception(SWIG_TypeError, "string expected");
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	<	result = (arg1)->RTupdate(arg2);
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	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
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_BossUserSession_clientID(PyObject *self, PyObject *args) {
2267	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
2268		PyObject *resultobj;
2269	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
2270	<	std::string arg2 = (std::string) "NONE" ;
2271	<	std::string result;
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 *)"O|O:BossUserSession_clientID",&obj0,&obj1)) goto fail;
2336	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2337	<	if (obj1) {
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(obj1))
2356	<	arg2 = std::string(PyString_AsString(obj1));
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 ;
2395	>	int arg2 = (int) SCHEDULED ;
2396	>	std::string const &arg3_defvalue = "all" ;
2397	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
2398	>	std::string const &arg4_defvalue = "all" ;
2399	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
2400	>	std::string const &arg5_defvalue = "" ;
2401	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2402	>	std::string arg6 = (std::string) "" ;
2403	>	std::string arg7 = (std::string) "" ;
2404	>	std::string arg8 = (std::string) "" ;
2405	>	std::string arg9 = (std::string) "" ;
2406	>	bool arg10 = (bool) false ;
2407	>	PyObject *result;
2408	>	std::string temp3 ;
2409	>	std::string temp4 ;
2410	>	std::string temp5 ;
2411	>	PyObject * obj0 = 0 ;
2412	>	PyObject * obj2 = 0 ;
2413	>	PyObject * obj3 = 0 ;
2414	>	PyObject * obj4 = 0 ;
2415	>	PyObject * obj5 = 0 ;
2416	>	PyObject * obj6 = 0 ;
2417	>	PyObject * obj7 = 0 ;
2418	>	PyObject * obj8 = 0 ;
2419	>	PyObject * obj9 = 0 ;
2420	>
2421	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2422	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2423	>	if (obj2) {
2424	>	{
2425	>	if (PyString_Check(obj2)) {
2426	>	temp3 = std::string(PyString_AsString(obj2));
2427	>	arg3 = &temp3;
2428	>	}else {
2429	>	SWIG_exception(SWIG_TypeError, "string expected");
2430	>	}
2431	>	}
2432	>	}
2433	>	if (obj3) {
2434	>	{
2435	>	if (PyString_Check(obj3)) {
2436	>	temp4 = std::string(PyString_AsString(obj3));
2437	>	arg4 = &temp4;
2438	>	}else {
2439	>	SWIG_exception(SWIG_TypeError, "string expected");
2440	>	}
2441	>	}
2442	>	}
2443	>	if (obj4) {
2444	>	{
2445	>	if (PyString_Check(obj4)) {
2446	>	temp5 = std::string(PyString_AsString(obj4));
2447	>	arg5 = &temp5;
2448	>	}else {
2449	>	SWIG_exception(SWIG_TypeError, "string expected");
2450	>	}
2451	>	}
2452	>	}
2453	>	if (obj5) {
2454	>	{
2455	>	if (PyString_Check(obj5))
2456	>	arg6 = std::string(PyString_AsString(obj5));
2457		else
2458		SWIG_exception(SWIG_TypeError, "string expected");
2459		}
2460		}
2461	<	result = (arg1)->clientID(arg2);
2462	<
2461	>	if (obj6) {
2462	>	{
2463	>	if (PyString_Check(obj6))
2464	>	arg7 = std::string(PyString_AsString(obj6));
2465	>	else
2466	>	SWIG_exception(SWIG_TypeError, "string expected");
2467	>	}
2468	>	}
2469	>	if (obj7) {
2470	>	{
2471	>	if (PyString_Check(obj7))
2472	>	arg8 = std::string(PyString_AsString(obj7));
2473	>	else
2474	>	SWIG_exception(SWIG_TypeError, "string expected");
2475	>	}
2476	>	}
2477	>	if (obj8) {
2478	>	{
2479	>	if (PyString_Check(obj8))
2480	>	arg9 = std::string(PyString_AsString(obj8));
2481	>	else
2482	>	SWIG_exception(SWIG_TypeError, "string expected");
2483	>	}
2484	>	}
2485	>	if (obj9) {
2486	>	arg10 = PyInt_AsLong(obj9) ? true : false;
2487	>	if (PyErr_Occurred()) SWIG_fail;
2488	>	}
2489		{
2490	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2490	>	try {
2491	>	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2492	>
2493	>	}catch (const std::exception& e) {
2494	>	SWIG_exception(SWIG_RuntimeError, e.what());
2495	>	}
2496		}
2497	+	resultobj = result;
2498		return resultobj;
2499		fail:
2500		return NULL;
2501		}
2502
2503
2504	<	static PyObject *_wrap_BossUserSession_declare(PyObject *self, PyObject *args) {
2504	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2505		PyObject *resultobj;
2506	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
2507	<	std::string arg2 = (std::string) "NONE" ;
1016	<	std::string result;
2506	>	std::string arg1 = (std::string) "" ;
2507	>	BossSession *result;
2508		PyObject * obj0 = 0 ;
1018	–	PyObject * obj1 = 0 ;
2509
2510	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_declare",&obj0,&obj1)) goto fail;
2511	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1022	<	if (obj1) {
2510	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2511	>	if (obj0) {
2512		{
2513	<	if (PyString_Check(obj1))
2514	<	arg2 = std::string(PyString_AsString(obj1));
2513	>	if (PyString_Check(obj0))
2514	>	arg1 = std::string(PyString_AsString(obj0));
2515		else
2516		SWIG_exception(SWIG_TypeError, "string expected");
2517		}
2518		}
2519	<	result = (arg1)->declare(arg2);
2519	>	{
2520	>	try {
2521	>	result = (BossSession *)new BossSession(arg1);
2522	>
2523	>	}catch (const std::exception& e) {
2524	>	SWIG_exception(SWIG_RuntimeError, e.what());
2525	>	}
2526	>	}
2527	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2528	>	return resultobj;
2529	>	fail:
2530	>	return NULL;
2531	>	}
2532	>
2533	>
2534	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2535	>	PyObject *resultobj;
2536	>	BossSession *arg1 = (BossSession *) 0 ;
2537	>	PyObject * obj0 = 0 ;
2538
2539	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2540	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2541		{
2542	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2542	>	try {
2543	>	delete arg1;
2544	>
2545	>	}catch (const std::exception& e) {
2546	>	SWIG_exception(SWIG_RuntimeError, e.what());
2547	>	}
2548		}
2549	+	Py_INCREF(Py_None); resultobj = Py_None;
2550		return resultobj;
2551		fail:
2552		return NULL;
2553		}
2554
2555
2556	<	static PyObject *_wrap_BossUserSession_deleteTask(PyObject *self, PyObject *args) {
2556	>	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2557		PyObject *resultobj;
2558	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
2559	<	std::string arg2 = (std::string) "NONE" ;
2560	<	std::string result;
2558	>	BossSession *arg1 = (BossSession *) 0 ;
2559	>	PyObject * obj0 = 0 ;
2560	>
2561	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2562	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2563	>	{
2564	>	try {
2565	>	(arg1)->resetDB();
2566	>
2567	>	}catch (const std::exception& e) {
2568	>	SWIG_exception(SWIG_RuntimeError, e.what());
2569	>	}
2570	>	}
2571	>	Py_INCREF(Py_None); resultobj = Py_None;
2572	>	return resultobj;
2573	>	fail:
2574	>	return NULL;
2575	>	}
2576	>
2577	>
2578	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2579	>	PyObject *resultobj;
2580	>	BossSession *arg1 = (BossSession *) 0 ;
2581	>	PyObject * obj0 = 0 ;
2582	>
2583	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2584	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2585	>	{
2586	>	try {
2587	>	(arg1)->clear();
2588	>
2589	>	}catch (const std::exception& e) {
2590	>	SWIG_exception(SWIG_RuntimeError, e.what());
2591	>	}
2592	>	}
2593	>	Py_INCREF(Py_None); resultobj = Py_None;
2594	>	return resultobj;
2595	>	fail:
2596	>	return NULL;
2597	>	}
2598	>
2599	>
2600	>	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2601	>	PyObject *resultobj;
2602	>	BossSession *arg1 = (BossSession *) 0 ;
2603	>	std::string const &arg2_defvalue = "" ;
2604	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
2605	>	BossTask *result;
2606	>	std::string temp2 ;
2607		PyObject * obj0 = 0 ;
2608		PyObject * obj1 = 0 ;
2609
2610	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_deleteTask",&obj0,&obj1)) goto fail;
2611	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2610	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2611	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2612		if (obj1) {
2613		{
2614	<	if (PyString_Check(obj1))
2615	<	arg2 = std::string(PyString_AsString(obj1));
2616	<	else
2617	<	SWIG_exception(SWIG_TypeError, "string expected");
2614	>	if (PyString_Check(obj1)) {
2615	>	temp2 = std::string(PyString_AsString(obj1));
2616	>	arg2 = &temp2;
2617	>	}else {
2618	>	SWIG_exception(SWIG_TypeError, "string expected");
2619	>	}
2620	>	}
2621	>	}
2622	>	{
2623	>	try {
2624	>	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2625	>
2626	>	}catch (const std::exception& e) {
2627	>	SWIG_exception(SWIG_RuntimeError, e.what());
2628		}
2629		}
2630	<	result = (arg1)->deleteTask(arg2);
2630	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2631	>	return resultobj;
2632	>	fail:
2633	>	return NULL;
2634	>	}
2635	>
2636	>
2637	>	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2638	>	PyObject *resultobj;
2639	>	BossSession *arg1 = (BossSession *) 0 ;
2640	>	BossTask *arg2 = (BossTask *) 0 ;
2641	>	PyObject * obj0 = 0 ;
2642	>	PyObject * obj1 = 0 ;
2643
2644	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2645	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2646	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2647	+	{
2648	+	try {
2649	+	(arg1)->destroyBossTask(arg2);
2650	+
2651	+	}catch (const std::exception& e) {
2652	+	SWIG_exception(SWIG_RuntimeError, e.what());
2653	+	}
2654	+	}
2655	+	Py_INCREF(Py_None); resultobj = Py_None;
2656	+	return resultobj;
2657	+	fail:
2658	+	return NULL;
2659	+	}
2660	+
2661	+
2662	+	static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
2663	+	PyObject *resultobj;
2664	+	BossSession *arg1 = (BossSession *) 0 ;
2665	+	std::string result;
2666	+	PyObject * obj0 = 0 ;
2667	+
2668	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) goto fail;
2669	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2670	+	{
2671	+	try {
2672	+	result = (arg1)->defaultCHTool();
2673	+
2674	+	}catch (const std::exception& e) {
2675	+	SWIG_exception(SWIG_RuntimeError, e.what());
2676	+	}
2677	+	}
2678		{
2679		resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2680		}
#	Line 1067 | Line 2684 | static PyObject *_wrap_BossUserSession_d
2684		}
2685
2686
2687	<	static PyObject *_wrap_BossUserSession_getOutput(PyObject *self, PyObject *args) {
2687	>	static PyObject *_wrap_BossSession_defaultProgramType(PyObject *self, PyObject *args) {
2688		PyObject *resultobj;
2689	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
1073	<	std::string arg2 = (std::string) "NONE" ;
2689	>	BossSession *arg1 = (BossSession *) 0 ;
2690		std::string result;
2691		PyObject * obj0 = 0 ;
1076	–	PyObject * obj1 = 0 ;
2692
2693	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_getOutput",&obj0,&obj1)) goto fail;
2694	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2695	<	if (obj1) {
2696	<	{
2697	<	if (PyString_Check(obj1))
2698	<	arg2 = std::string(PyString_AsString(obj1));
2699	<	else
2700	<	SWIG_exception(SWIG_TypeError, "string expected");
2693	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) goto fail;
2694	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2695	>	{
2696	>	try {
2697	>	result = (arg1)->defaultProgramType();
2698	>
2699	>	}catch (const std::exception& e) {
2700	>	SWIG_exception(SWIG_RuntimeError, e.what());
2701		}
2702		}
2703	<	result = (arg1)->getOutput(arg2);
2703	>	{
2704	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2705	>	}
2706	>	return resultobj;
2707	>	fail:
2708	>	return NULL;
2709	>	}
2710	>
2711	>
2712	>	static PyObject *_wrap_BossSession_defaultRTMon(PyObject *self, PyObject *args) {
2713	>	PyObject *resultobj;
2714	>	BossSession *arg1 = (BossSession *) 0 ;
2715	>	std::string result;
2716	>	PyObject * obj0 = 0 ;
2717
2718	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) goto fail;
2719	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2720	+	{
2721	+	try {
2722	+	result = (arg1)->defaultRTMon();
2723	+
2724	+	}catch (const std::exception& e) {
2725	+	SWIG_exception(SWIG_RuntimeError, e.what());
2726	+	}
2727	+	}
2728		{
2729		resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2730		}
#	Line 1096 | Line 2734 | static PyObject *_wrap_BossUserSession_g
2734		}
2735
2736
2737	<	static PyObject *_wrap_BossUserSession_kill(PyObject *self, PyObject *args) {
2737	>	static PyObject *_wrap_BossSession_defaultScheduler(PyObject *self, PyObject *args) {
2738		PyObject *resultobj;
2739	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
1102	<	std::string arg2 = (std::string) "NONE" ;
2739	>	BossSession *arg1 = (BossSession *) 0 ;
2740		std::string result;
2741		PyObject * obj0 = 0 ;
1105	–	PyObject * obj1 = 0 ;
2742
2743	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_kill",&obj0,&obj1)) goto fail;
2744	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2745	<	if (obj1) {
2746	<	{
2747	<	if (PyString_Check(obj1))
2748	<	arg2 = std::string(PyString_AsString(obj1));
2749	<	else
2750	<	SWIG_exception(SWIG_TypeError, "string expected");
2743	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) goto fail;
2744	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2745	>	{
2746	>	try {
2747	>	result = (arg1)->defaultScheduler();
2748	>
2749	>	}catch (const std::exception& e) {
2750	>	SWIG_exception(SWIG_RuntimeError, e.what());
2751		}
2752		}
2753	<	result = (arg1)->kill(arg2);
2753	>	{
2754	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2755	>	}
2756	>	return resultobj;
2757	>	fail:
2758	>	return NULL;
2759	>	}
2760	>
2761	>
2762	>	static PyObject *_wrap_BossSession_version(PyObject *self, PyObject *args) {
2763	>	PyObject *resultobj;
2764	>	BossSession *arg1 = (BossSession *) 0 ;
2765	>	std::string result;
2766	>	PyObject * obj0 = 0 ;
2767
2768	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) goto fail;
2769	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2770	+	{
2771	+	try {
2772	+	result = (arg1)->version();
2773	+
2774	+	}catch (const std::exception& e) {
2775	+	SWIG_exception(SWIG_RuntimeError, e.what());
2776	+	}
2777	+	}
2778		{
2779		resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2780		}
#	Line 1125 | Line 2784 | static PyObject *_wrap_BossUserSession_k
2784		}
2785
2786
2787	<	static PyObject *_wrap_BossUserSession_query(PyObject *self, PyObject *args) {
2787	>	static PyObject *_wrap_BossSession_clientID(PyObject *self, PyObject *args) {
2788		PyObject *resultobj;
2789	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
1131	<	std::string arg2 = (std::string) "NONE" ;
2789	>	BossSession *arg1 = (BossSession *) 0 ;
2790		std::string result;
2791		PyObject * obj0 = 0 ;
2792	+
2793	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) goto fail;
2794	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2795	+	{
2796	+	try {
2797	+	result = (arg1)->clientID();
2798	+
2799	+	}catch (const std::exception& e) {
2800	+	SWIG_exception(SWIG_RuntimeError, e.what());
2801	+	}
2802	+	}
2803	+	{
2804	+	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2805	+	}
2806	+	return resultobj;
2807	+	fail:
2808	+	return NULL;
2809	+	}
2810	+
2811	+
2812	+	static PyObject *_wrap_BossSession_showConfigs(PyObject *self, PyObject *args) {
2813	+	PyObject *resultobj;
2814	+	BossSession *arg1 = (BossSession *) 0 ;
2815	+	bool arg2 = (bool) false ;
2816	+	int result;
2817	+	PyObject * obj0 = 0 ;
2818		PyObject * obj1 = 0 ;
2819
2820	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_query",&obj0,&obj1)) goto fail;
2821	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2820	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_showConfigs",&obj0,&obj1)) goto fail;
2821	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2822	>	if (obj1) {
2823	>	arg2 = PyInt_AsLong(obj1) ? true : false;
2824	>	if (PyErr_Occurred()) SWIG_fail;
2825	>	}
2826	>	{
2827	>	try {
2828	>	result = (int)(arg1)->showConfigs(arg2);
2829	>
2830	>	}catch (const std::exception& e) {
2831	>	SWIG_exception(SWIG_RuntimeError, e.what());
2832	>	}
2833	>	}
2834	>	resultobj = PyInt_FromLong((long)result);
2835	>	return resultobj;
2836	>	fail:
2837	>	return NULL;
2838	>	}
2839	>
2840	>
2841	>	static PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2842	>	PyObject *resultobj;
2843	>	BossSession *arg1 = (BossSession *) 0 ;
2844	>	std::string arg2 = (std::string) "all" ;
2845	>	std::string arg3 = (std::string) "all" ;
2846	>	std::string arg4 = (std::string) "" ;
2847	>	int result;
2848	>	PyObject * obj0 = 0 ;
2849	>	PyObject * obj1 = 0 ;
2850	>	PyObject * obj2 = 0 ;
2851	>	PyObject * obj3 = 0 ;
2852	>
2853	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
2854	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2855		if (obj1) {
2856		{
2857		if (PyString_Check(obj1))
#	Line 1143 | Line 2860 | static PyObject *_wrap_BossUserSession_q
2860		SWIG_exception(SWIG_TypeError, "string expected");
2861		}
2862		}
2863	<	result = (arg1)->query(arg2);
2864	<
2863	>	if (obj2) {
2864	>	{
2865	>	if (PyString_Check(obj2))
2866	>	arg3 = std::string(PyString_AsString(obj2));
2867	>	else
2868	>	SWIG_exception(SWIG_TypeError, "string expected");
2869	>	}
2870	>	}
2871	>	if (obj3) {
2872	>	{
2873	>	if (PyString_Check(obj3))
2874	>	arg4 = std::string(PyString_AsString(obj3));
2875	>	else
2876	>	SWIG_exception(SWIG_TypeError, "string expected");
2877	>	}
2878	>	}
2879		{
2880	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2880	>	try {
2881	>	result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2882	>
2883	>	}catch (const std::exception& e) {
2884	>	SWIG_exception(SWIG_RuntimeError, e.what());
2885	>	}
2886		}
2887	+	resultobj = PyInt_FromLong((long)result);
2888		return resultobj;
2889		fail:
2890		return NULL;
2891		}
2892
2893
2894	<	static PyObject *_wrap_BossUserSession_showCHTools(PyObject *self, PyObject *args) {
2894	>	static PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
2895		PyObject *resultobj;
2896	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
2897	<	std::string arg2 = (std::string) "NONE" ;
2898	<	std::string result;
2896	>	BossSession *arg1 = (BossSession *) 0 ;
2897	>	std::string *arg2 = 0 ;
2898	>	std::string *arg3 = 0 ;
2899	>	bool arg4 = (bool) false ;
2900	>	std::string const &arg5_defvalue = "" ;
2901	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2902	>	std::string const &arg6_defvalue = "" ;
2903	>	std::string *arg6 = (std::string *) &arg6_defvalue ;
2904	>	std::vector<std::string > result;
2905	>	std::string temp2 ;
2906	>	std::string temp3 ;
2907	>	std::string temp5 ;
2908	>	std::string temp6 ;
2909		PyObject * obj0 = 0 ;
2910		PyObject * obj1 = 0 ;
2911	+	PyObject * obj2 = 0 ;
2912	+	PyObject * obj3 = 0 ;
2913	+	PyObject * obj4 = 0 ;
2914	+	PyObject * obj5 = 0 ;
2915
2916	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_showCHTools",&obj0,&obj1)) goto fail;
2917	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2918	<	if (obj1) {
2916	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2917	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2918	>	{
2919	>	if (PyString_Check(obj1)) {
2920	>	temp2 = std::string(PyString_AsString(obj1));
2921	>	arg2 = &temp2;
2922	>	}else {
2923	>	SWIG_exception(SWIG_TypeError, "string expected");
2924	>	}
2925	>	}
2926	>	{
2927	>	if (PyString_Check(obj2)) {
2928	>	temp3 = std::string(PyString_AsString(obj2));
2929	>	arg3 = &temp3;
2930	>	}else {
2931	>	SWIG_exception(SWIG_TypeError, "string expected");
2932	>	}
2933	>	}
2934	>	if (obj3) {
2935	>	arg4 = PyInt_AsLong(obj3) ? true : false;
2936	>	if (PyErr_Occurred()) SWIG_fail;
2937	>	}
2938	>	if (obj4) {
2939		{
2940	<	if (PyString_Check(obj1))
2941	<	arg2 = std::string(PyString_AsString(obj1));
2940	>	if (PyString_Check(obj4)) {
2941	>	temp5 = std::string(PyString_AsString(obj4));
2942	>	arg5 = &temp5;
2943	>	}else {
2944	>	SWIG_exception(SWIG_TypeError, "string expected");
2945	>	}
2946	>	}
2947	>	}
2948	>	if (obj5) {
2949	>	{
2950	>	if (PyString_Check(obj5)) {
2951	>	temp6 = std::string(PyString_AsString(obj5));
2952	>	arg6 = &temp6;
2953	>	}else {
2954	>	SWIG_exception(SWIG_TypeError, "string expected");
2955	>	}
2956	>	}
2957	>	}
2958	>	{
2959	>	try {
2960	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2961	>
2962	>	}catch (const std::exception& e) {
2963	>	SWIG_exception(SWIG_RuntimeError, e.what());
2964	>	}
2965	>	}
2966	>	{
2967	>	resultobj = PyTuple_New((&result)->size());
2968	>	for (unsigned int i=0; i<(&result)->size(); i++)
2969	>	PyTuple_SetItem(resultobj,i,
2970	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2971	>	}
2972	>	return resultobj;
2973	>	fail:
2974	>	return NULL;
2975	>	}
2976	>
2977	>
2978	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
2979	>	PyObject *resultobj;
2980	>	BossSession *arg1 = (BossSession *) 0 ;
2981	>	int arg2 = (int) SCHEDULED ;
2982	>	std::string const &arg3_defvalue = "all" ;
2983	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
2984	>	std::string const &arg4_defvalue = "all" ;
2985	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
2986	>	std::string const &arg5_defvalue = "" ;
2987	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2988	>	std::string arg6 = (std::string) "" ;
2989	>	std::string arg7 = (std::string) "" ;
2990	>	std::string arg8 = (std::string) "" ;
2991	>	std::string arg9 = (std::string) "" ;
2992	>	std::string temp3 ;
2993	>	std::string temp4 ;
2994	>	std::string temp5 ;
2995	>	PyObject * obj0 = 0 ;
2996	>	PyObject * obj2 = 0 ;
2997	>	PyObject * obj3 = 0 ;
2998	>	PyObject * obj4 = 0 ;
2999	>	PyObject * obj5 = 0 ;
3000	>	PyObject * obj6 = 0 ;
3001	>	PyObject * obj7 = 0 ;
3002	>	PyObject * obj8 = 0 ;
3003	>
3004	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3005	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3006	>	if (obj2) {
3007	>	{
3008	>	if (PyString_Check(obj2)) {
3009	>	temp3 = std::string(PyString_AsString(obj2));
3010	>	arg3 = &temp3;
3011	>	}else {
3012	>	SWIG_exception(SWIG_TypeError, "string expected");
3013	>	}
3014	>	}
3015	>	}
3016	>	if (obj3) {
3017	>	{
3018	>	if (PyString_Check(obj3)) {
3019	>	temp4 = std::string(PyString_AsString(obj3));
3020	>	arg4 = &temp4;
3021	>	}else {
3022	>	SWIG_exception(SWIG_TypeError, "string expected");
3023	>	}
3024	>	}
3025	>	}
3026	>	if (obj4) {
3027	>	{
3028	>	if (PyString_Check(obj4)) {
3029	>	temp5 = std::string(PyString_AsString(obj4));
3030	>	arg5 = &temp5;
3031	>	}else {
3032	>	SWIG_exception(SWIG_TypeError, "string expected");
3033	>	}
3034	>	}
3035	>	}
3036	>	if (obj5) {
3037	>	{
3038	>	if (PyString_Check(obj5))
3039	>	arg6 = std::string(PyString_AsString(obj5));
3040	>	else
3041	>	SWIG_exception(SWIG_TypeError, "string expected");
3042	>	}
3043	>	}
3044	>	if (obj6) {
3045	>	{
3046	>	if (PyString_Check(obj6))
3047	>	arg7 = std::string(PyString_AsString(obj6));
3048	>	else
3049	>	SWIG_exception(SWIG_TypeError, "string expected");
3050	>	}
3051	>	}
3052	>	if (obj7) {
3053	>	{
3054	>	if (PyString_Check(obj7))
3055	>	arg8 = std::string(PyString_AsString(obj7));
3056	>	else
3057	>	SWIG_exception(SWIG_TypeError, "string expected");
3058	>	}
3059	>	}
3060	>	if (obj8) {
3061	>	{
3062	>	if (PyString_Check(obj8))
3063	>	arg9 = std::string(PyString_AsString(obj8));
3064		else
3065		SWIG_exception(SWIG_TypeError, "string expected");
3066		}
3067		}
1175	–	result = (arg1)->showCHTools(arg2);
1176	–
3068		{
3069	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3069	>	try {
3070	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3071	>
3072	>	}catch (const std::exception& e) {
3073	>	SWIG_exception(SWIG_RuntimeError, e.what());
3074	>	}
3075		}
3076	+	Py_INCREF(Py_None); resultobj = Py_None;
3077		return resultobj;
3078		fail:
3079		return NULL;
3080		}
3081
3082
3083	<	static PyObject *_wrap_BossUserSession_showConfig(PyObject *self, PyObject *args) {
3083	>	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3084		PyObject *resultobj;
3085	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
3086	<	std::string arg2 = (std::string) "NONE" ;
3087	<	std::string result;
3085	>	BossSession *arg1 = (BossSession *) 0 ;
3086	>	std::string const &arg2_defvalue = "all" ;
3087	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3088	>	std::string const &arg3_defvalue = "" ;
3089	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3090	>	std::string const &arg4_defvalue = "" ;
3091	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3092	>	std::string const &arg5_defvalue = "" ;
3093	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3094	>	std::vector<std::string > result;
3095	>	std::string temp2 ;
3096	>	std::string temp3 ;
3097	>	std::string temp4 ;
3098	>	std::string temp5 ;
3099		PyObject * obj0 = 0 ;
3100		PyObject * obj1 = 0 ;
3101	+	PyObject * obj2 = 0 ;
3102	+	PyObject * obj3 = 0 ;
3103	+	PyObject * obj4 = 0 ;
3104
3105	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_showConfig",&obj0,&obj1)) goto fail;
3106	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3105	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3106	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3107		if (obj1) {
3108		{
3109	<	if (PyString_Check(obj1))
3110	<	arg2 = std::string(PyString_AsString(obj1));
3109	>	if (PyString_Check(obj1)) {
3110	>	temp2 = std::string(PyString_AsString(obj1));
3111	>	arg2 = &temp2;
3112	>	}else {
3113	>	SWIG_exception(SWIG_TypeError, "string expected");
3114	>	}
3115	>	}
3116	>	}
3117	>	if (obj2) {
3118	>	{
3119	>	if (PyString_Check(obj2)) {
3120	>	temp3 = std::string(PyString_AsString(obj2));
3121	>	arg3 = &temp3;
3122	>	}else {
3123	>	SWIG_exception(SWIG_TypeError, "string expected");
3124	>	}
3125	>	}
3126	>	}
3127	>	if (obj3) {
3128	>	{
3129	>	if (PyString_Check(obj3)) {
3130	>	temp4 = std::string(PyString_AsString(obj3));
3131	>	arg4 = &temp4;
3132	>	}else {
3133	>	SWIG_exception(SWIG_TypeError, "string expected");
3134	>	}
3135	>	}
3136	>	}
3137	>	if (obj4) {
3138	>	{
3139	>	if (PyString_Check(obj4)) {
3140	>	temp5 = std::string(PyString_AsString(obj4));
3141	>	arg5 = &temp5;
3142	>	}else {
3143	>	SWIG_exception(SWIG_TypeError, "string expected");
3144	>	}
3145	>	}
3146	>	}
3147	>	{
3148	>	try {
3149	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3150	>
3151	>	}catch (const std::exception& e) {
3152	>	SWIG_exception(SWIG_RuntimeError, e.what());
3153	>	}
3154	>	}
3155	>	{
3156	>	resultobj = PyTuple_New((&result)->size());
3157	>	for (unsigned int i=0; i<(&result)->size(); i++)
3158	>	PyTuple_SetItem(resultobj,i,
3159	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3160	>	}
3161	>	return resultobj;
3162	>	fail:
3163	>	return NULL;
3164	>	}
3165	>
3166	>
3167	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3168	>	PyObject *resultobj;
3169	>	BossSession *arg1 = (BossSession *) 0 ;
3170	>	int arg2 = (int) SCHEDULED ;
3171	>	std::string const &arg3_defvalue = "all" ;
3172	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3173	>	std::string const &arg4_defvalue = "all" ;
3174	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3175	>	std::string const &arg5_defvalue = "" ;
3176	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3177	>	std::string arg6 = (std::string) "" ;
3178	>	std::string arg7 = (std::string) "" ;
3179	>	std::string arg8 = (std::string) "" ;
3180	>	std::string arg9 = (std::string) "" ;
3181	>	bool arg10 = (bool) false ;
3182	>	SwigValueWrapper< std::vector<BossTask * > > result;
3183	>	std::string temp3 ;
3184	>	std::string temp4 ;
3185	>	std::string temp5 ;
3186	>	PyObject * obj0 = 0 ;
3187	>	PyObject * obj2 = 0 ;
3188	>	PyObject * obj3 = 0 ;
3189	>	PyObject * obj4 = 0 ;
3190	>	PyObject * obj5 = 0 ;
3191	>	PyObject * obj6 = 0 ;
3192	>	PyObject * obj7 = 0 ;
3193	>	PyObject * obj8 = 0 ;
3194	>	PyObject * obj9 = 0 ;
3195	>
3196	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3197	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3198	>	if (obj2) {
3199	>	{
3200	>	if (PyString_Check(obj2)) {
3201	>	temp3 = std::string(PyString_AsString(obj2));
3202	>	arg3 = &temp3;
3203	>	}else {
3204	>	SWIG_exception(SWIG_TypeError, "string expected");
3205	>	}
3206	>	}
3207	>	}
3208	>	if (obj3) {
3209	>	{
3210	>	if (PyString_Check(obj3)) {
3211	>	temp4 = std::string(PyString_AsString(obj3));
3212	>	arg4 = &temp4;
3213	>	}else {
3214	>	SWIG_exception(SWIG_TypeError, "string expected");
3215	>	}
3216	>	}
3217	>	}
3218	>	if (obj4) {
3219	>	{
3220	>	if (PyString_Check(obj4)) {
3221	>	temp5 = std::string(PyString_AsString(obj4));
3222	>	arg5 = &temp5;
3223	>	}else {
3224	>	SWIG_exception(SWIG_TypeError, "string expected");
3225	>	}
3226	>	}
3227	>	}
3228	>	if (obj5) {
3229	>	{
3230	>	if (PyString_Check(obj5))
3231	>	arg6 = std::string(PyString_AsString(obj5));
3232	>	else
3233	>	SWIG_exception(SWIG_TypeError, "string expected");
3234	>	}
3235	>	}
3236	>	if (obj6) {
3237	>	{
3238	>	if (PyString_Check(obj6))
3239	>	arg7 = std::string(PyString_AsString(obj6));
3240		else
3241		SWIG_exception(SWIG_TypeError, "string expected");
3242		}
3243		}
3244	<	result = (arg1)->showConfig(arg2);
3244	>	if (obj7) {
3245	>	{
3246	>	if (PyString_Check(obj7))
3247	>	arg8 = std::string(PyString_AsString(obj7));
3248	>	else
3249	>	SWIG_exception(SWIG_TypeError, "string expected");
3250	>	}
3251	>	}
3252	>	if (obj8) {
3253	>	{
3254	>	if (PyString_Check(obj8))
3255	>	arg9 = std::string(PyString_AsString(obj8));
3256	>	else
3257	>	SWIG_exception(SWIG_TypeError, "string expected");
3258	>	}
3259	>	}
3260	>	if (obj9) {
3261	>	arg10 = PyInt_AsLong(obj9) ? true : false;
3262	>	if (PyErr_Occurred()) SWIG_fail;
3263	>	}
3264	>	{
3265	>	try {
3266	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3267	>
3268	>	}catch (const std::exception& e) {
3269	>	SWIG_exception(SWIG_RuntimeError, e.what());
3270	>	}
3271	>	}
3272	>	{
3273	>	std::vector<BossTask * > * resultptr;
3274	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3275	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3276	>	}
3277	>	return resultobj;
3278	>	fail:
3279	>	return NULL;
3280	>	}
3281	>
3282	>
3283	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3284	>	PyObject *obj;
3285	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3286	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3287	>	Py_INCREF(obj);
3288	>	return Py_BuildValue((char *)"");
3289	>	}
3290	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3291	>	PyObject *resultobj;
3292	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3293	>	char *arg2 ;
3294	>	PyObject * obj0 = 0 ;
3295
3296	+	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3297	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3298		{
3299	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3299	>	if (arg2) {
3300	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3301	>	strcpy((char *) arg1->key,arg2);
3302	>	}else {
3303	>	arg1->key = 0;
3304	>	}
3305		}
3306	+	Py_INCREF(Py_None); resultobj = Py_None;
3307		return resultobj;
3308		fail:
3309		return NULL;
3310		}
3311
3312
3313	<	static PyObject *_wrap_BossUserSession_showProgramTypes(PyObject *self, PyObject *args) {
3313	>	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3314		PyObject *resultobj;
3315	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
3316	<	std::string arg2 = (std::string) "NONE" ;
3317	<	std::string result;
3315	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3316	>	char *result;
3317	>	PyObject * obj0 = 0 ;
3318	>
3319	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3320	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3321	>	result = (char *) ((arg1)->key);
3322	>
3323	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3324	>	return resultobj;
3325	>	fail:
3326	>	return NULL;
3327	>	}
3328	>
3329	>
3330	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3331	>	PyObject *resultobj;
3332	>	char *arg1 ;
3333	>	BossTaskException *result;
3334	>
3335	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3336	>	{
3337	>	try {
3338	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3339	>
3340	>	}catch (const std::exception& e) {
3341	>	SWIG_exception(SWIG_RuntimeError, e.what());
3342	>	}
3343	>	}
3344	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3345	>	return resultobj;
3346	>	fail:
3347	>	return NULL;
3348	>	}
3349	>
3350	>
3351	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3352	>	PyObject *resultobj;
3353	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3354	>	char *result;
3355	>	PyObject * obj0 = 0 ;
3356	>
3357	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3358	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3359	>	{
3360	>	try {
3361	>	result = (char *)((BossTaskException const *)arg1)->what();
3362	>
3363	>	}catch (const std::exception& e) {
3364	>	SWIG_exception(SWIG_RuntimeError, e.what());
3365	>	}
3366	>	}
3367	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3368	>	return resultobj;
3369	>	fail:
3370	>	return NULL;
3371	>	}
3372	>
3373	>
3374	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3375	>	PyObject *resultobj;
3376	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3377	>	PyObject * obj0 = 0 ;
3378	>
3379	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3380	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3381	>	{
3382	>	try {
3383	>	delete arg1;
3384	>
3385	>	}catch (const std::exception& e) {
3386	>	SWIG_exception(SWIG_RuntimeError, e.what());
3387	>	}
3388	>	}
3389	>	Py_INCREF(Py_None); resultobj = Py_None;
3390	>	return resultobj;
3391	>	fail:
3392	>	return NULL;
3393	>	}
3394	>
3395	>
3396	>	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3397	>	PyObject *obj;
3398	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3399	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3400	>	Py_INCREF(obj);
3401	>	return Py_BuildValue((char *)"");
3402	>	}
3403	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3404	>	PyObject *resultobj;
3405	>	BossTask *arg1 = (BossTask *) 0 ;
3406	>	PyObject *arg2 = (PyObject *) 0 ;
3407	>	BossAttributeContainer *arg3 = 0 ;
3408	>	PyObject *result;
3409		PyObject * obj0 = 0 ;
3410		PyObject * obj1 = 0 ;
3411	+	PyObject * obj2 = 0 ;
3412
3413	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_showProgramTypes",&obj0,&obj1)) goto fail;
3414	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3415	<	if (obj1) {
3416	<	{
3417	<	if (PyString_Check(obj1))
3418	<	arg2 = std::string(PyString_AsString(obj1));
3419	<	else
3420	<	SWIG_exception(SWIG_TypeError, "string expected");
3413	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3414	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3415	>	arg2 = obj1;
3416	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3417	>	if (arg3 == NULL) {
3418	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3419	>	}
3420	>	{
3421	>	try {
3422	>	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3423	>
3424	>	}catch (const std::exception& e) {
3425	>	SWIG_exception(SWIG_RuntimeError, e.what());
3426		}
3427		}
3428	<	result = (arg1)->showProgramTypes(arg2);
3428	>	resultobj = result;
3429	>	return resultobj;
3430	>	fail:
3431	>	return NULL;
3432	>	}
3433	>
3434	>
3435	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3436	>	PyObject *resultobj;
3437	>	BossTask *arg1 = (BossTask *) 0 ;
3438	>	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3439	>	PyObject *result;
3440	>	PyObject * obj0 = 0 ;
3441	>	PyObject * obj1 = 0 ;
3442
3443	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3444	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3445	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3446	+	if (arg2 == NULL) {
3447	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3448	+	}
3449		{
3450	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3450	>	try {
3451	>	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3452	>
3453	>	}catch (const std::exception& e) {
3454	>	SWIG_exception(SWIG_RuntimeError, e.what());
3455	>	}
3456		}
3457	+	resultobj = result;
3458		return resultobj;
3459		fail:
3460		return NULL;
3461		}
3462
3463
3464	<	static PyObject *_wrap_BossUserSession_showRTMon(PyObject *self, PyObject *args) {
3464	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
3465		PyObject *resultobj;
3466	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
3467	<	std::string arg2 = (std::string) "NONE" ;
3468	<	std::string result;
3466	>	BossTask *arg1 = (BossTask *) 0 ;
3467	>	PyObject *result;
3468	>	PyObject * obj0 = 0 ;
3469	>
3470	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3471	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3472	>	{
3473	>	try {
3474	>	result = (PyObject *)BossTask_jobsDict(arg1);
3475	>
3476	>	}catch (const std::exception& e) {
3477	>	SWIG_exception(SWIG_RuntimeError, e.what());
3478	>	}
3479	>	}
3480	>	resultobj = result;
3481	>	return resultobj;
3482	>	fail:
3483	>	return NULL;
3484	>	}
3485	>
3486	>
3487	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3488	>	PyObject *resultobj;
3489	>	BossTask *arg1 = (BossTask *) 0 ;
3490	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3491	>	PyObject *result;
3492		PyObject * obj0 = 0 ;
3493		PyObject * obj1 = 0 ;
3494
3495	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_showRTMon",&obj0,&obj1)) goto fail;
3496	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3497	<	if (obj1) {
3498	<	{
3499	<	if (PyString_Check(obj1))
3500	<	arg2 = std::string(PyString_AsString(obj1));
3501	<	else
3495	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3496	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3497	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3498	>	if (arg2 == NULL) {
3499	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3500	>	}
3501	>	{
3502	>	try {
3503	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3504	>
3505	>	}catch (const std::exception& e) {
3506	>	SWIG_exception(SWIG_RuntimeError, e.what());
3507	>	}
3508	>	}
3509	>	resultobj = result;
3510	>	return resultobj;
3511	>	fail:
3512	>	return NULL;
3513	>	}
3514	>
3515	>
3516	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
3517	>	PyObject *resultobj;
3518	>	BossTask *arg1 = (BossTask *) 0 ;
3519	>	std::string *arg2 = 0 ;
3520	>	PyObject *result;
3521	>	std::string temp2 ;
3522	>	PyObject * obj0 = 0 ;
3523	>	PyObject * obj1 = 0 ;
3524	>
3525	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3526	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3527	>	{
3528	>	if (PyString_Check(obj1)) {
3529	>	temp2 = std::string(PyString_AsString(obj1));
3530	>	arg2 = &temp2;
3531	>	}else {
3532		SWIG_exception(SWIG_TypeError, "string expected");
3533		}
3534		}
3535	<	result = (arg1)->showRTMon(arg2);
3535	>	{
3536	>	try {
3537	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3538	>
3539	>	}catch (const std::exception& e) {
3540	>	SWIG_exception(SWIG_RuntimeError, e.what());
3541	>	}
3542	>	}
3543	>	resultobj = result;
3544	>	return resultobj;
3545	>	fail:
3546	>	return NULL;
3547	>	}
3548	>
3549	>
3550	>	static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3551	>	PyObject *resultobj;
3552	>	BossDatabase *arg1 = (BossDatabase *) 0 ;
3553	>	BossTask *result;
3554	>	PyObject * obj0 = 0 ;
3555
3556	+	if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
3557	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3558		{
3559	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3559	>	try {
3560	>	result = (BossTask *)new BossTask(arg1);
3561	>
3562	>	}catch (const std::exception& e) {
3563	>	SWIG_exception(SWIG_RuntimeError, e.what());
3564	>	}
3565		}
3566	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3567		return resultobj;
3568		fail:
3569		return NULL;
3570		}
3571
3572
3573	<	static PyObject *_wrap_BossUserSession_showSchedulers(PyObject *self, PyObject *args) {
3573	>	static PyObject *_wrap_new_BossTask__SWIG_1(PyObject *self, PyObject *args) {
3574		PyObject *resultobj;
3575	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
3576	<	std::string arg2 = (std::string) "NONE" ;
3577	<	std::string result;
3575	>	BossDatabase *arg1 = (BossDatabase *) 0 ;
3576	>	std::string *arg2 = 0 ;
3577	>	BossTask *result;
3578	>	std::string temp2 ;
3579		PyObject * obj0 = 0 ;
3580		PyObject * obj1 = 0 ;
3581
3582	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_showSchedulers",&obj0,&obj1)) goto fail;
3583	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3584	<	if (obj1) {
3585	<	{
3586	<	if (PyString_Check(obj1))
3587	<	arg2 = std::string(PyString_AsString(obj1));
3588	<	else
3582	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_BossTask",&obj0,&obj1)) goto fail;
3583	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3584	>	{
3585	>	if (PyString_Check(obj1)) {
3586	>	temp2 = std::string(PyString_AsString(obj1));
3587	>	arg2 = &temp2;
3588	>	}else {
3589		SWIG_exception(SWIG_TypeError, "string expected");
3590		}
3591		}
3592	<	result = (arg1)->showSchedulers(arg2);
3592	>	{
3593	>	try {
3594	>	result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3595	>
3596	>	}catch (const std::exception& e) {
3597	>	SWIG_exception(SWIG_RuntimeError, e.what());
3598	>	}
3599	>	}
3600	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3601	>	return resultobj;
3602	>	fail:
3603	>	return NULL;
3604	>	}
3605	>
3606	>
3607	>	static PyObject *_wrap_delete_BossTask(PyObject *self, PyObject *args) {
3608	>	PyObject *resultobj;
3609	>	BossTask *arg1 = (BossTask *) 0 ;
3610	>	PyObject * obj0 = 0 ;
3611
3612	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTask",&obj0)) goto fail;
3613	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3614		{
3615	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3615	>	try {
3616	>	delete arg1;
3617	>
3618	>	}catch (const std::exception& e) {
3619	>	SWIG_exception(SWIG_RuntimeError, e.what());
3620	>	}
3621		}
3622	+	Py_INCREF(Py_None); resultobj = Py_None;
3623		return resultobj;
3624		fail:
3625		return NULL;
3626		}
3627
3628
3629	<	static PyObject *_wrap_BossUserSession_submit(PyObject *self, PyObject *args) {
3629	>	static PyObject *_wrap_new_BossTask__SWIG_2(PyObject *self, PyObject *args) {
3630		PyObject *resultobj;
3631	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
3632	<	std::string arg2 = (std::string) "NONE" ;
1306	<	std::string result;
3631	>	BossTask *arg1 = 0 ;
3632	>	BossTask *result;
3633		PyObject * obj0 = 0 ;
1308	–	PyObject * obj1 = 0 ;
3634
3635	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_submit",&obj0,&obj1)) goto fail;
3636	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3637	<	if (obj1) {
3635	>	if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
3636	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3637	>	if (arg1 == NULL) {
3638	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3639	>	}
3640	>	{
3641	>	try {
3642	>	result = (BossTask *)new BossTask((BossTask const &)*arg1);
3643	>
3644	>	}catch (const std::exception& e) {
3645	>	SWIG_exception(SWIG_RuntimeError, e.what());
3646	>	}
3647	>	}
3648	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3649	>	return resultobj;
3650	>	fail:
3651	>	return NULL;
3652	>	}
3653	>
3654	>
3655	>	static PyObject *_wrap_new_BossTask(PyObject *self, PyObject *args) {
3656	>	int argc;
3657	>	PyObject *argv[3];
3658	>	int ii;
3659	>
3660	>	argc = PyObject_Length(args);
3661	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3662	>	argv[ii] = PyTuple_GetItem(args,ii);
3663	>	}
3664	>	if (argc == 1) {
3665	>	int _v;
3666		{
3667	<	if (PyString_Check(obj1))
3668	<	arg2 = std::string(PyString_AsString(obj1));
3669	<	else
3670	<	SWIG_exception(SWIG_TypeError, "string expected");
3667	>	void *ptr;
3668	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
3669	>	_v = 0;
3670	>	PyErr_Clear();
3671	>	}else {
3672	>	_v = 1;
3673	>	}
3674	>	}
3675	>	if (_v) {
3676	>	return _wrap_new_BossTask__SWIG_0(self,args);
3677	>	}
3678	>	}
3679	>	if (argc == 1) {
3680	>	int _v;
3681	>	{
3682	>	void *ptr;
3683	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3684	>	_v = 0;
3685	>	PyErr_Clear();
3686	>	}else {
3687	>	_v = 1;
3688	>	}
3689	>	}
3690	>	if (_v) {
3691	>	return _wrap_new_BossTask__SWIG_2(self,args);
3692	>	}
3693	>	}
3694	>	if (argc == 2) {
3695	>	int _v;
3696	>	{
3697	>	void *ptr;
3698	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
3699	>	_v = 0;
3700	>	PyErr_Clear();
3701	>	}else {
3702	>	_v = 1;
3703	>	}
3704	>	}
3705	>	if (_v) {
3706	>	{
3707	>	_v = PyString_Check(argv[1]) ? 1 : 0;
3708	>	}
3709	>	if (_v) {
3710	>	return _wrap_new_BossTask__SWIG_1(self,args);
3711	>	}
3712	>	}
3713	>	}
3714	>
3715	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_BossTask'");
3716	>	return NULL;
3717	>	}
3718	>
3719	>
3720	>	static PyObject *_wrap_BossTask_id(PyObject *self, PyObject *args) {
3721	>	PyObject *resultobj;
3722	>	BossTask *arg1 = (BossTask *) 0 ;
3723	>	std::string *result;
3724	>	PyObject * obj0 = 0 ;
3725	>
3726	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_id",&obj0)) goto fail;
3727	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3728	>	{
3729	>	try {
3730	>	{
3731	>	std::string const &_result_ref = ((BossTask const *)arg1)->id();
3732	>	result = (std::string *) &_result_ref;
3733	>	}
3734	>
3735	>	}catch (const std::exception& e) {
3736	>	SWIG_exception(SWIG_RuntimeError, e.what());
3737		}
3738		}
3739	<	result = (arg1)->submit(arg2);
3739	>	{
3740	>	resultobj = PyString_FromStringAndSize(result->data(),result->size());
3741	>	}
3742	>	return resultobj;
3743	>	fail:
3744	>	return NULL;
3745	>	}
3746	>
3747	>
3748	>	static PyObject *_wrap_BossTask_name(PyObject *self, PyObject *args) {
3749	>	PyObject *resultobj;
3750	>	BossTask *arg1 = (BossTask *) 0 ;
3751	>	std::string *result;
3752	>	PyObject * obj0 = 0 ;
3753
3754	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_name",&obj0)) goto fail;
3755	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3756		{
3757	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3757	>	try {
3758	>	{
3759	>	std::string const &_result_ref = ((BossTask const *)arg1)->name();
3760	>	result = (std::string *) &_result_ref;
3761	>	}
3762	>
3763	>	}catch (const std::exception& e) {
3764	>	SWIG_exception(SWIG_RuntimeError, e.what());
3765	>	}
3766	>	}
3767	>	{
3768	>	resultobj = PyString_FromStringAndSize(result->data(),result->size());
3769	>	}
3770	>	return resultobj;
3771	>	fail:
3772	>	return NULL;
3773	>	}
3774	>
3775	>
3776	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3777	>	PyObject *resultobj;
3778	>	BossTask *arg1 = (BossTask *) 0 ;
3779	>	std::map<std::string,std::string > result;
3780	>	PyObject * obj0 = 0 ;
3781	>
3782	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3783	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3784	>	{
3785	>	try {
3786	>	result = ((BossTask const *)arg1)->taskMap();
3787	>
3788	>	}catch (const std::exception& e) {
3789	>	SWIG_exception(SWIG_RuntimeError, e.what());
3790	>	}
3791	>	}
3792	>	{
3793	>	resultobj = PyDict_New();
3794	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3795	>	PyDict_SetItem(resultobj,
3796	>	SwigString_FromString(i->first),
3797	>	SwigString_FromString(i->second));
3798	>	}
3799	>	}
3800	>	return resultobj;
3801	>	fail:
3802	>	return NULL;
3803	>	}
3804	>
3805	>
3806	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3807	>	PyObject *resultobj;
3808	>	BossTask *arg1 = (BossTask *) 0 ;
3809	>	BossTask::job_iterator result;
3810	>	PyObject * obj0 = 0 ;
3811	>
3812	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3813	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3814	>	{
3815	>	try {
3816	>	result = ((BossTask const *)arg1)->job_begin();
3817	>
3818	>	}catch (const std::exception& e) {
3819	>	SWIG_exception(SWIG_RuntimeError, e.what());
3820	>	}
3821	>	}
3822	>	{
3823	>	BossTask::job_iterator * resultptr;
3824	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3825	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3826	>	}
3827	>	return resultobj;
3828	>	fail:
3829	>	return NULL;
3830	>	}
3831	>
3832	>
3833	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3834	>	PyObject *resultobj;
3835	>	BossTask *arg1 = (BossTask *) 0 ;
3836	>	BossTask::job_iterator result;
3837	>	PyObject * obj0 = 0 ;
3838	>
3839	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3840	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3841	>	{
3842	>	try {
3843	>	result = ((BossTask const *)arg1)->job_end();
3844	>
3845	>	}catch (const std::exception& e) {
3846	>	SWIG_exception(SWIG_RuntimeError, e.what());
3847	>	}
3848	>	}
3849	>	{
3850	>	BossTask::job_iterator * resultptr;
3851	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3852	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3853		}
3854		return resultobj;
3855		fail:
#	Line 1328 | Line 3857 | static PyObject *_wrap_BossUserSession_s
3857		}
3858
3859
3860	<	static PyObject *_wrap_BossUserSession_version(PyObject *self, PyObject *args) {
3860	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3861		PyObject *resultobj;
3862	<	BossUserSession *arg1 = (BossUserSession *) 0 ;
3863	<	std::string arg2 = (std::string) "NONE" ;
3862	>	BossTask *arg1 = (BossTask *) 0 ;
3863	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3864	>	PyObject * obj0 = 0 ;
3865	>
3866	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3867	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3868	>	{
3869	>	try {
3870	>	result = ((BossTask const *)arg1)->jobsMap();
3871	>
3872	>	}catch (const std::exception& e) {
3873	>	SWIG_exception(SWIG_RuntimeError, e.what());
3874	>	}
3875	>	}
3876	>	{
3877	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3878	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3879	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3880	>	}
3881	>	return resultobj;
3882	>	fail:
3883	>	return NULL;
3884	>	}
3885	>
3886	>
3887	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
3888	>	PyObject *resultobj;
3889	>	BossTask *arg1 = (BossTask *) 0 ;
3890	>	SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
3891	>	std::map<std::string,std::string > *arg3 = 0 ;
3892		std::string result;
3893	+	std::vector<BossJob * >::const_iterator *argp2 ;
3894		PyObject * obj0 = 0 ;
3895		PyObject * obj1 = 0 ;
3896	+	PyObject * obj2 = 0 ;
3897
3898	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossUserSession_version",&obj0,&obj1)) goto fail;
3899	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossUserSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3900	<	if (obj1) {
3898	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobMap",&obj0,&obj1,&obj2)) goto fail;
3899	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3900	>	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3901	>	arg2 = *argp2;
3902	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3903	>	if (arg3 == NULL) {
3904	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3905	>	}
3906	>	{
3907	>	try {
3908	>	result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
3909	>
3910	>	}catch (const std::exception& e) {
3911	>	SWIG_exception(SWIG_RuntimeError, e.what());
3912	>	}
3913	>	}
3914	>	{
3915	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3916	>	}
3917	>	return resultobj;
3918	>	fail:
3919	>	return NULL;
3920	>	}
3921	>
3922	>
3923	>	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
3924	>	PyObject *resultobj;
3925	>	BossTask *arg1 = (BossTask *) 0 ;
3926	>	unsigned int arg2 ;
3927	>	std::map<std::string,std::string > result;
3928	>	PyObject * obj0 = 0 ;
3929	>	PyObject * obj1 = 0 ;
3930	>
3931	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
3932	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3933	>	arg2 = (unsigned int) PyInt_AsLong(obj1);
3934	>	if (PyErr_Occurred()) SWIG_fail;
3935	>	{
3936	>	try {
3937	>	result = ((BossTask const *)arg1)->jobMap(arg2);
3938	>
3939	>	}catch (const std::exception& e) {
3940	>	SWIG_exception(SWIG_RuntimeError, e.what());
3941	>	}
3942	>	}
3943	>	{
3944	>	resultobj = PyDict_New();
3945	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3946	>	PyDict_SetItem(resultobj,
3947	>	SwigString_FromString(i->first),
3948	>	SwigString_FromString(i->second));
3949	>	}
3950	>	}
3951	>	return resultobj;
3952	>	fail:
3953	>	return NULL;
3954	>	}
3955	>
3956	>
3957	>	static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
3958	>	int argc;
3959	>	PyObject *argv[4];
3960	>	int ii;
3961	>
3962	>	argc = PyObject_Length(args);
3963	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3964	>	argv[ii] = PyTuple_GetItem(args,ii);
3965	>	}
3966	>	if (argc == 2) {
3967	>	int _v;
3968		{
3969	<	if (PyString_Check(obj1))
3970	<	arg2 = std::string(PyString_AsString(obj1));
3971	<	else
3972	<	SWIG_exception(SWIG_TypeError, "string expected");
3969	>	void *ptr;
3970	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3971	>	_v = 0;
3972	>	PyErr_Clear();
3973	>	}else {
3974	>	_v = 1;
3975	>	}
3976	>	}
3977	>	if (_v) {
3978	>	{
3979	>	_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
3980	>	}
3981	>	if (_v) {
3982	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
3983	>	}
3984	>	}
3985	>	}
3986	>	if (argc == 3) {
3987	>	int _v;
3988	>	{
3989	>	void *ptr;
3990	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3991	>	_v = 0;
3992	>	PyErr_Clear();
3993	>	}else {
3994	>	_v = 1;
3995	>	}
3996	>	}
3997	>	if (_v) {
3998	>	{
3999	>	void *ptr;
4000	>	if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator, 0) == -1) {
4001	>	_v = 0;
4002	>	PyErr_Clear();
4003	>	}else {
4004	>	_v = 1;
4005	>	}
4006	>	}
4007	>	if (_v) {
4008	>	{
4009	>	void *ptr;
4010	>	if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_std__mapTstd__string_std__string_t, 0) == -1) {
4011	>	_v = 0;
4012	>	PyErr_Clear();
4013	>	}else {
4014	>	_v = 1;
4015	>	}
4016	>	}
4017	>	if (_v) {
4018	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4019	>	}
4020	>	}
4021		}
4022		}
1349	–	result = (arg1)->version(arg2);
4023
4024	+	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobMap'");
4025	+	return NULL;
4026	+	}
4027	+
4028	+
4029	+	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4030	+	PyObject *resultobj;
4031	+	BossTask *arg1 = (BossTask *) 0 ;
4032	+	BossJob *arg2 = (BossJob *) 0 ;
4033	+	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4034	+	PyObject * obj0 = 0 ;
4035	+	PyObject * obj1 = 0 ;
4036	+
4037	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4038	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4039	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4040		{
4041	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4041	>	try {
4042	>	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4043	>
4044	>	}catch (const std::exception& e) {
4045	>	SWIG_exception(SWIG_RuntimeError, e.what());
4046	>	}
4047	>	}
4048	>	{
4049	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4050	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4051	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4052		}
4053		return resultobj;
4054		fail:
#	Line 1357 | Line 4056 | static PyObject *_wrap_BossUserSession_v
4056		}
4057
4058
4059	<	static PyObject * BossUserSession_swigregister(PyObject *self, PyObject *args) {
4060	<	PyObject *obj;
4061	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4062	<	SWIG_TypeClientData(SWIGTYPE_p_BossUserSession, obj);
4063	<	Py_INCREF(obj);
4064	<	return Py_BuildValue((char *)"");
4059	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4060	>	PyObject *resultobj;
4061	>	BossTask *arg1 = (BossTask *) 0 ;
4062	>	BossJob *arg2 = (BossJob *) 0 ;
4063	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4064	>	PyObject * obj0 = 0 ;
4065	>	PyObject * obj1 = 0 ;
4066	>
4067	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4068	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4069	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4070	>	{
4071	>	try {
4072	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4073	>
4074	>	}catch (const std::exception& e) {
4075	>	SWIG_exception(SWIG_RuntimeError, e.what());
4076	>	}
4077	>	}
4078	>	{
4079	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4080	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4081	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4082	>	}
4083	>	return resultobj;
4084	>	fail:
4085	>	return NULL;
4086		}
4087	<	static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
4087	>
4088	>
4089	>	static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4090		PyObject *resultobj;
4091	<	std::string arg1 ;
4092	<	BossAdministratorSession *result;
4091	>	BossTask *arg1 = (BossTask *) 0 ;
4092	>	std::string *arg2 = 0 ;
4093	>	std::string const &arg3_defvalue = "" ;
4094	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4095	>	std::string temp2 ;
4096	>	std::string temp3 ;
4097		PyObject * obj0 = 0 ;
4098	+	PyObject * obj1 = 0 ;
4099	+	PyObject * obj2 = 0 ;
4100
4101	<	if(!PyArg_ParseTuple(args,(char *)"O:new_BossAdministratorSession",&obj0)) goto fail;
4101	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
4102	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4103		{
4104	<	if (PyString_Check(obj0))
4105	<	arg1 = std::string(PyString_AsString(obj0));
4106	<	else
4107	<	SWIG_exception(SWIG_TypeError, "string expected");
4104	>	if (PyString_Check(obj1)) {
4105	>	temp2 = std::string(PyString_AsString(obj1));
4106	>	arg2 = &temp2;
4107	>	}else {
4108	>	SWIG_exception(SWIG_TypeError, "string expected");
4109	>	}
4110	>	}
4111	>	if (obj2) {
4112	>	{
4113	>	if (PyString_Check(obj2)) {
4114	>	temp3 = std::string(PyString_AsString(obj2));
4115	>	arg3 = &temp3;
4116	>	}else {
4117	>	SWIG_exception(SWIG_TypeError, "string expected");
4118	>	}
4119	>	}
4120	>	}
4121	>	{
4122	>	try {
4123	>	(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4124	>
4125	>	}catch (const std::exception& e) {
4126	>	SWIG_exception(SWIG_RuntimeError, e.what());
4127	>	}
4128		}
4129	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1);
4129	>	Py_INCREF(Py_None); resultobj = Py_None;
4130	>	return resultobj;
4131	>	fail:
4132	>	return NULL;
4133	>	}
4134	>
4135	>
4136	>	static PyObject *_wrap_BossTask_declare__SWIG_1(PyObject *self, PyObject *args) {
4137	>	PyObject *resultobj;
4138	>	BossTask *arg1 = (BossTask *) 0 ;
4139	>	XMLDoc *arg2 = (XMLDoc *) 0 ;
4140	>	std::string const &arg3_defvalue = "" ;
4141	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4142	>	std::string temp3 ;
4143	>	PyObject * obj0 = 0 ;
4144	>	PyObject * obj1 = 0 ;
4145	>	PyObject * obj2 = 0 ;
4146
4147	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
4147	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
4148	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4149	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_XMLDoc,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4150	>	if (obj2) {
4151	>	{
4152	>	if (PyString_Check(obj2)) {
4153	>	temp3 = std::string(PyString_AsString(obj2));
4154	>	arg3 = &temp3;
4155	>	}else {
4156	>	SWIG_exception(SWIG_TypeError, "string expected");
4157	>	}
4158	>	}
4159	>	}
4160	>	{
4161	>	try {
4162	>	(arg1)->declare(arg2,(std::string const &)*arg3);
4163	>
4164	>	}catch (const std::exception& e) {
4165	>	SWIG_exception(SWIG_RuntimeError, e.what());
4166	>	}
4167	>	}
4168	>	Py_INCREF(Py_None); resultobj = Py_None;
4169		return resultobj;
4170		fail:
4171		return NULL;
4172		}
4173
4174
4175	<	static PyObject *_wrap_delete_BossAdministratorSession(PyObject *self, PyObject *args) {
4175	>	static PyObject *_wrap_BossTask_declare(PyObject *self, PyObject *args) {
4176	>	int argc;
4177	>	PyObject *argv[4];
4178	>	int ii;
4179	>
4180	>	argc = PyObject_Length(args);
4181	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4182	>	argv[ii] = PyTuple_GetItem(args,ii);
4183	>	}
4184	>	if ((argc >= 2) && (argc <= 3)) {
4185	>	int _v;
4186	>	{
4187	>	void *ptr;
4188	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4189	>	_v = 0;
4190	>	PyErr_Clear();
4191	>	}else {
4192	>	_v = 1;
4193	>	}
4194	>	}
4195	>	if (_v) {
4196	>	{
4197	>	void *ptr;
4198	>	if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_XMLDoc, 0) == -1) {
4199	>	_v = 0;
4200	>	PyErr_Clear();
4201	>	}else {
4202	>	_v = 1;
4203	>	}
4204	>	}
4205	>	if (_v) {
4206	>	if (argc <= 2) {
4207	>	return _wrap_BossTask_declare__SWIG_1(self,args);
4208	>	}
4209	>	{
4210	>	_v = PyString_Check(argv[2]) ? 1 : 0;
4211	>	}
4212	>	if (_v) {
4213	>	return _wrap_BossTask_declare__SWIG_1(self,args);
4214	>	}
4215	>	}
4216	>	}
4217	>	}
4218	>	if ((argc >= 2) && (argc <= 3)) {
4219	>	int _v;
4220	>	{
4221	>	void *ptr;
4222	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4223	>	_v = 0;
4224	>	PyErr_Clear();
4225	>	}else {
4226	>	_v = 1;
4227	>	}
4228	>	}
4229	>	if (_v) {
4230	>	{
4231	>	_v = PyString_Check(argv[1]) ? 1 : 0;
4232	>	}
4233	>	if (_v) {
4234	>	if (argc <= 2) {
4235	>	return _wrap_BossTask_declare__SWIG_0(self,args);
4236	>	}
4237	>	{
4238	>	_v = PyString_Check(argv[2]) ? 1 : 0;
4239	>	}
4240	>	if (_v) {
4241	>	return _wrap_BossTask_declare__SWIG_0(self,args);
4242	>	}
4243	>	}
4244	>	}
4245	>	}
4246	>
4247	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_declare'");
4248	>	return NULL;
4249	>	}
4250	>
4251	>
4252	>	static PyObject *_wrap_BossTask_remove(PyObject *self, PyObject *args) {
4253		PyObject *resultobj;
4254	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4254	>	BossTask *arg1 = (BossTask *) 0 ;
4255		PyObject * obj0 = 0 ;
4256
4257	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossAdministratorSession",&obj0)) goto fail;
4258	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4259	<	delete arg1;
4257	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_remove",&obj0)) goto fail;
4258	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4259	>	{
4260	>	try {
4261	>	(arg1)->remove();
4262	>
4263	>	}catch (const std::exception& e) {
4264	>	SWIG_exception(SWIG_RuntimeError, e.what());
4265	>	}
4266	>	}
4267	>	Py_INCREF(Py_None); resultobj = Py_None;
4268	>	return resultobj;
4269	>	fail:
4270	>	return NULL;
4271	>	}
4272	>
4273	>
4274	>	static PyObject *_wrap_BossTask_archive(PyObject *self, PyObject *args) {
4275	>	PyObject *resultobj;
4276	>	BossTask *arg1 = (BossTask *) 0 ;
4277	>	std::string const &arg2_defvalue = "all" ;
4278	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4279	>	std::string temp2 ;
4280	>	PyObject * obj0 = 0 ;
4281	>	PyObject * obj1 = 0 ;
4282
4283	+	if(!PyArg_ParseTuple(args,(char *)"O|O:BossTask_archive",&obj0,&obj1)) goto fail;
4284	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4285	+	if (obj1) {
4286	+	{
4287	+	if (PyString_Check(obj1)) {
4288	+	temp2 = std::string(PyString_AsString(obj1));
4289	+	arg2 = &temp2;
4290	+	}else {
4291	+	SWIG_exception(SWIG_TypeError, "string expected");
4292	+	}
4293	+	}
4294	+	}
4295	+	{
4296	+	try {
4297	+	(arg1)->archive((std::string const &)*arg2);
4298	+
4299	+	}catch (const std::exception& e) {
4300	+	SWIG_exception(SWIG_RuntimeError, e.what());
4301	+	}
4302	+	}
4303		Py_INCREF(Py_None); resultobj = Py_None;
4304		return resultobj;
4305		fail:
#	Line 1402 | Line 4307 | static PyObject *_wrap_delete_BossAdmini
4307		}
4308
4309
4310	<	static PyObject *_wrap_BossAdministratorSession_exitCode(PyObject *self, PyObject *args) {
4310	>	static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4311		PyObject *resultobj;
4312	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4312	>	BossTask *arg1 = (BossTask *) 0 ;
4313	>	std::string const &arg2_defvalue = "all" ;
4314	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4315	>	std::string const &arg3_defvalue = "" ;
4316	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4317	>	std::string const &arg4_defvalue = "" ;
4318	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4319	>	std::string const &arg5_defvalue = "" ;
4320	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
4321	>	std::string const &arg6_defvalue = "" ;
4322	>	std::string *arg6 = (std::string *) &arg6_defvalue ;
4323	>	bool arg7 = (bool) false ;
4324		int result;
4325	+	std::string temp2 ;
4326	+	std::string temp3 ;
4327	+	std::string temp4 ;
4328	+	std::string temp5 ;
4329	+	std::string temp6 ;
4330		PyObject * obj0 = 0 ;
4331	+	PyObject * obj1 = 0 ;
4332	+	PyObject * obj2 = 0 ;
4333	+	PyObject * obj3 = 0 ;
4334	+	PyObject * obj4 = 0 ;
4335	+	PyObject * obj5 = 0 ;
4336	+	PyObject * obj6 = 0 ;
4337
4338	<	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_exitCode",&obj0)) goto fail;
4339	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4340	<	result = (int)(arg1)->exitCode();
4341	<
4338	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4339	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4340	>	if (obj1) {
4341	>	{
4342	>	if (PyString_Check(obj1)) {
4343	>	temp2 = std::string(PyString_AsString(obj1));
4344	>	arg2 = &temp2;
4345	>	}else {
4346	>	SWIG_exception(SWIG_TypeError, "string expected");
4347	>	}
4348	>	}
4349	>	}
4350	>	if (obj2) {
4351	>	{
4352	>	if (PyString_Check(obj2)) {
4353	>	temp3 = std::string(PyString_AsString(obj2));
4354	>	arg3 = &temp3;
4355	>	}else {
4356	>	SWIG_exception(SWIG_TypeError, "string expected");
4357	>	}
4358	>	}
4359	>	}
4360	>	if (obj3) {
4361	>	{
4362	>	if (PyString_Check(obj3)) {
4363	>	temp4 = std::string(PyString_AsString(obj3));
4364	>	arg4 = &temp4;
4365	>	}else {
4366	>	SWIG_exception(SWIG_TypeError, "string expected");
4367	>	}
4368	>	}
4369	>	}
4370	>	if (obj4) {
4371	>	{
4372	>	if (PyString_Check(obj4)) {
4373	>	temp5 = std::string(PyString_AsString(obj4));
4374	>	arg5 = &temp5;
4375	>	}else {
4376	>	SWIG_exception(SWIG_TypeError, "string expected");
4377	>	}
4378	>	}
4379	>	}
4380	>	if (obj5) {
4381	>	{
4382	>	if (PyString_Check(obj5)) {
4383	>	temp6 = std::string(PyString_AsString(obj5));
4384	>	arg6 = &temp6;
4385	>	}else {
4386	>	SWIG_exception(SWIG_TypeError, "string expected");
4387	>	}
4388	>	}
4389	>	}
4390	>	if (obj6) {
4391	>	arg7 = PyInt_AsLong(obj6) ? true : false;
4392	>	if (PyErr_Occurred()) SWIG_fail;
4393	>	}
4394	>	{
4395	>	try {
4396	>	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
4397	>
4398	>	}catch (const std::exception& e) {
4399	>	SWIG_exception(SWIG_RuntimeError, e.what());
4400	>	}
4401	>	}
4402		resultobj = PyInt_FromLong((long)result);
4403		return resultobj;
4404		fail:
#	Line 1419 | Line 4406 | static PyObject *_wrap_BossAdministrator
4406		}
4407
4408
4409	<	static PyObject *_wrap_BossAdministratorSession_out(PyObject *self, PyObject *args) {
4409	>	static PyObject *_wrap_BossTask_reSubmit(PyObject *self, PyObject *args) {
4410		PyObject *resultobj;
4411	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4412	<	std::string result;
4411	>	BossTask *arg1 = (BossTask *) 0 ;
4412	>	std::string *arg2 = 0 ;
4413	>	bool arg3 = (bool) false ;
4414	>	int result;
4415	>	std::string temp2 ;
4416		PyObject * obj0 = 0 ;
4417	+	PyObject * obj1 = 0 ;
4418	+	PyObject * obj2 = 0 ;
4419
4420	<	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_out",&obj0)) goto fail;
4421	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1430	<	result = (arg1)->out();
1431	<
4420	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_reSubmit",&obj0,&obj1,&obj2)) goto fail;
4421	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4422		{
4423	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4423	>	if (PyString_Check(obj1)) {
4424	>	temp2 = std::string(PyString_AsString(obj1));
4425	>	arg2 = &temp2;
4426	>	}else {
4427	>	SWIG_exception(SWIG_TypeError, "string expected");
4428	>	}
4429	>	}
4430	>	if (obj2) {
4431	>	arg3 = PyInt_AsLong(obj2) ? true : false;
4432	>	if (PyErr_Occurred()) SWIG_fail;
4433	>	}
4434	>	{
4435	>	try {
4436	>	result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4437	>
4438	>	}catch (const std::exception& e) {
4439	>	SWIG_exception(SWIG_RuntimeError, e.what());
4440	>	}
4441		}
4442	+	resultobj = PyInt_FromLong((long)result);
4443		return resultobj;
4444		fail:
4445		return NULL;
4446		}
4447
4448
4449	<	static PyObject *_wrap_BossAdministratorSession_err(PyObject *self, PyObject *args) {
4449	>	static PyObject *_wrap_BossTask_kill(PyObject *self, PyObject *args) {
4450		PyObject *resultobj;
4451	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4452	<	std::string result;
4451	>	BossTask *arg1 = (BossTask *) 0 ;
4452	>	std::string *arg2 = 0 ;
4453	>	bool arg3 = (bool) false ;
4454	>	int result;
4455	>	std::string temp2 ;
4456		PyObject * obj0 = 0 ;
4457	+	PyObject * obj1 = 0 ;
4458	+	PyObject * obj2 = 0 ;
4459
4460	<	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_err",&obj0)) goto fail;
4461	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4462	<	result = (arg1)->err();
4460	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4461	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4462	>	{
4463	>	if (PyString_Check(obj1)) {
4464	>	temp2 = std::string(PyString_AsString(obj1));
4465	>	arg2 = &temp2;
4466	>	}else {
4467	>	SWIG_exception(SWIG_TypeError, "string expected");
4468	>	}
4469	>	}
4470	>	if (obj2) {
4471	>	arg3 = PyInt_AsLong(obj2) ? true : false;
4472	>	if (PyErr_Occurred()) SWIG_fail;
4473	>	}
4474	>	{
4475	>	try {
4476	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4477	>
4478	>	}catch (const std::exception& e) {
4479	>	SWIG_exception(SWIG_RuntimeError, e.what());
4480	>	}
4481	>	}
4482	>	resultobj = PyInt_FromLong((long)result);
4483	>	return resultobj;
4484	>	fail:
4485	>	return NULL;
4486	>	}
4487	>
4488	>
4489	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4490	>	PyObject *resultobj;
4491	>	BossTask *arg1 = (BossTask *) 0 ;
4492	>	std::string const &arg2_defvalue = "all" ;
4493	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4494	>	std::string const &arg3_defvalue = "" ;
4495	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4496	>	bool arg4 = (bool) false ;
4497	>	bool arg5 = (bool) false ;
4498	>	int result;
4499	>	std::string temp2 ;
4500	>	std::string temp3 ;
4501	>	PyObject * obj0 = 0 ;
4502	>	PyObject * obj1 = 0 ;
4503	>	PyObject * obj2 = 0 ;
4504	>	PyObject * obj3 = 0 ;
4505	>	PyObject * obj4 = 0 ;
4506
4507	+	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4508	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4509	+	if (obj1) {
4510	+	{
4511	+	if (PyString_Check(obj1)) {
4512	+	temp2 = std::string(PyString_AsString(obj1));
4513	+	arg2 = &temp2;
4514	+	}else {
4515	+	SWIG_exception(SWIG_TypeError, "string expected");
4516	+	}
4517	+	}
4518	+	}
4519	+	if (obj2) {
4520	+	{
4521	+	if (PyString_Check(obj2)) {
4522	+	temp3 = std::string(PyString_AsString(obj2));
4523	+	arg3 = &temp3;
4524	+	}else {
4525	+	SWIG_exception(SWIG_TypeError, "string expected");
4526	+	}
4527	+	}
4528	+	}
4529	+	if (obj3) {
4530	+	arg4 = PyInt_AsLong(obj3) ? true : false;
4531	+	if (PyErr_Occurred()) SWIG_fail;
4532	+	}
4533	+	if (obj4) {
4534	+	arg5 = PyInt_AsLong(obj4) ? true : false;
4535	+	if (PyErr_Occurred()) SWIG_fail;
4536	+	}
4537		{
4538	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4538	>	try {
4539	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4540	>
4541	>	}catch (const std::exception& e) {
4542	>	SWIG_exception(SWIG_RuntimeError, e.what());
4543	>	}
4544		}
4545	+	resultobj = PyInt_FromLong((long)result);
4546		return resultobj;
4547		fail:
4548		return NULL;
4549		}
4550
4551
4552	<	static PyObject *_wrap_BossAdministratorSession_help(PyObject *self, PyObject *args) {
4552	>	static PyObject *_wrap_BossTask_getAllOutput(PyObject *self, PyObject *args) {
4553		PyObject *resultobj;
4554	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4555	<	std::string arg2 = (std::string) "NONE" ;
4556	<	std::string result;
4554	>	BossTask *arg1 = (BossTask *) 0 ;
4555	>	std::string const &arg2_defvalue = "" ;
4556	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4557	>	bool arg3 = (bool) false ;
4558	>	bool arg4 = (bool) false ;
4559	>	int result;
4560	>	std::string temp2 ;
4561		PyObject * obj0 = 0 ;
4562		PyObject * obj1 = 0 ;
4563	+	PyObject * obj2 = 0 ;
4564	+	PyObject * obj3 = 0 ;
4565
4566	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_help",&obj0,&obj1)) goto fail;
4567	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4566	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4567	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4568		if (obj1) {
4569		{
4570	<	if (PyString_Check(obj1))
4571	<	arg2 = std::string(PyString_AsString(obj1));
4570	>	if (PyString_Check(obj1)) {
4571	>	temp2 = std::string(PyString_AsString(obj1));
4572	>	arg2 = &temp2;
4573	>	}else {
4574	>	SWIG_exception(SWIG_TypeError, "string expected");
4575	>	}
4576	>	}
4577	>	}
4578	>	if (obj2) {
4579	>	arg3 = PyInt_AsLong(obj2) ? true : false;
4580	>	if (PyErr_Occurred()) SWIG_fail;
4581	>	}
4582	>	if (obj3) {
4583	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4584	>	if (PyErr_Occurred()) SWIG_fail;
4585	>	}
4586	>	{
4587	>	try {
4588	>	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3,arg4);
4589	>
4590	>	}catch (const std::exception& e) {
4591	>	SWIG_exception(SWIG_RuntimeError, e.what());
4592	>	}
4593	>	}
4594	>	resultobj = PyInt_FromLong((long)result);
4595	>	return resultobj;
4596	>	fail:
4597	>	return NULL;
4598	>	}
4599	>
4600	>
4601	>	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4602	>	PyObject *resultobj;
4603	>	BossTask *arg1 = (BossTask *) 0 ;
4604	>	int arg2 = (int) SCHEDULED ;
4605	>	std::string const &arg3_defvalue = "all" ;
4606	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4607	>	std::string const &arg4_defvalue = "" ;
4608	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4609	>	std::string arg5 = (std::string) "" ;
4610	>	std::string arg6 = (std::string) "" ;
4611	>	std::string arg7 = (std::string) "" ;
4612	>	std::string arg8 = (std::string) "" ;
4613	>	int result;
4614	>	std::string temp3 ;
4615	>	std::string temp4 ;
4616	>	PyObject * obj0 = 0 ;
4617	>	PyObject * obj2 = 0 ;
4618	>	PyObject * obj3 = 0 ;
4619	>	PyObject * obj4 = 0 ;
4620	>	PyObject * obj5 = 0 ;
4621	>	PyObject * obj6 = 0 ;
4622	>	PyObject * obj7 = 0 ;
4623	>
4624	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4625	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4626	>	if (obj2) {
4627	>	{
4628	>	if (PyString_Check(obj2)) {
4629	>	temp3 = std::string(PyString_AsString(obj2));
4630	>	arg3 = &temp3;
4631	>	}else {
4632	>	SWIG_exception(SWIG_TypeError, "string expected");
4633	>	}
4634	>	}
4635	>	}
4636	>	if (obj3) {
4637	>	{
4638	>	if (PyString_Check(obj3)) {
4639	>	temp4 = std::string(PyString_AsString(obj3));
4640	>	arg4 = &temp4;
4641	>	}else {
4642	>	SWIG_exception(SWIG_TypeError, "string expected");
4643	>	}
4644	>	}
4645	>	}
4646	>	if (obj4) {
4647	>	{
4648	>	if (PyString_Check(obj4))
4649	>	arg5 = std::string(PyString_AsString(obj4));
4650	>	else
4651	>	SWIG_exception(SWIG_TypeError, "string expected");
4652	>	}
4653	>	}
4654	>	if (obj5) {
4655	>	{
4656	>	if (PyString_Check(obj5))
4657	>	arg6 = std::string(PyString_AsString(obj5));
4658	>	else
4659	>	SWIG_exception(SWIG_TypeError, "string expected");
4660	>	}
4661	>	}
4662	>	if (obj6) {
4663	>	{
4664	>	if (PyString_Check(obj6))
4665	>	arg7 = std::string(PyString_AsString(obj6));
4666	>	else
4667	>	SWIG_exception(SWIG_TypeError, "string expected");
4668	>	}
4669	>	}
4670	>	if (obj7) {
4671	>	{
4672	>	if (PyString_Check(obj7))
4673	>	arg8 = std::string(PyString_AsString(obj7));
4674		else
4675		SWIG_exception(SWIG_TypeError, "string expected");
4676		}
4677		}
1478	–	result = (arg1)->help(arg2);
1479	–
4678		{
4679	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4679	>	try {
4680	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4681	>
4682	>	}catch (const std::exception& e) {
4683	>	SWIG_exception(SWIG_RuntimeError, e.what());
4684	>	}
4685		}
4686	+	resultobj = PyInt_FromLong((long)result);
4687		return resultobj;
4688		fail:
4689		return NULL;
4690		}
4691
4692
4693	<	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
4693	>	static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
4694		PyObject *resultobj;
4695	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4696	<	std::string arg2 = (std::string) "NONE" ;
4697	<	std::string result;
4695	>	BossTask *arg1 = (BossTask *) 0 ;
4696	>	int arg2 = (int) SCHEDULED ;
4697	>	std::string const &arg3_defvalue = "all" ;
4698	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4699	>	std::string const &arg4_defvalue = "" ;
4700	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4701	>	std::string arg5 = (std::string) "" ;
4702	>	std::string arg6 = (std::string) "" ;
4703	>	std::string arg7 = (std::string) "" ;
4704	>	std::string arg8 = (std::string) "" ;
4705	>	bool arg9 = (bool) false ;
4706	>	int result;
4707	>	std::string temp3 ;
4708	>	std::string temp4 ;
4709	>	PyObject * obj0 = 0 ;
4710	>	PyObject * obj2 = 0 ;
4711	>	PyObject * obj3 = 0 ;
4712	>	PyObject * obj4 = 0 ;
4713	>	PyObject * obj5 = 0 ;
4714	>	PyObject * obj6 = 0 ;
4715	>	PyObject * obj7 = 0 ;
4716	>	PyObject * obj8 = 0 ;
4717	>
4718	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4719	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4720	>	if (obj2) {
4721	>	{
4722	>	if (PyString_Check(obj2)) {
4723	>	temp3 = std::string(PyString_AsString(obj2));
4724	>	arg3 = &temp3;
4725	>	}else {
4726	>	SWIG_exception(SWIG_TypeError, "string expected");
4727	>	}
4728	>	}
4729	>	}
4730	>	if (obj3) {
4731	>	{
4732	>	if (PyString_Check(obj3)) {
4733	>	temp4 = std::string(PyString_AsString(obj3));
4734	>	arg4 = &temp4;
4735	>	}else {
4736	>	SWIG_exception(SWIG_TypeError, "string expected");
4737	>	}
4738	>	}
4739	>	}
4740	>	if (obj4) {
4741	>	{
4742	>	if (PyString_Check(obj4))
4743	>	arg5 = std::string(PyString_AsString(obj4));
4744	>	else
4745	>	SWIG_exception(SWIG_TypeError, "string expected");
4746	>	}
4747	>	}
4748	>	if (obj5) {
4749	>	{
4750	>	if (PyString_Check(obj5))
4751	>	arg6 = std::string(PyString_AsString(obj5));
4752	>	else
4753	>	SWIG_exception(SWIG_TypeError, "string expected");
4754	>	}
4755	>	}
4756	>	if (obj6) {
4757	>	{
4758	>	if (PyString_Check(obj6))
4759	>	arg7 = std::string(PyString_AsString(obj6));
4760	>	else
4761	>	SWIG_exception(SWIG_TypeError, "string expected");
4762	>	}
4763	>	}
4764	>	if (obj7) {
4765	>	{
4766	>	if (PyString_Check(obj7))
4767	>	arg8 = std::string(PyString_AsString(obj7));
4768	>	else
4769	>	SWIG_exception(SWIG_TypeError, "string expected");
4770	>	}
4771	>	}
4772	>	if (obj8) {
4773	>	arg9 = PyInt_AsLong(obj8) ? true : false;
4774	>	if (PyErr_Occurred()) SWIG_fail;
4775	>	}
4776	>	{
4777	>	try {
4778	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
4779	>
4780	>	}catch (const std::exception& e) {
4781	>	SWIG_exception(SWIG_RuntimeError, e.what());
4782	>	}
4783	>	}
4784	>	resultobj = PyInt_FromLong((long)result);
4785	>	return resultobj;
4786	>	fail:
4787	>	return NULL;
4788	>	}
4789	>
4790	>
4791	>	static PyObject *_wrap_BossTask_query_out(PyObject *self, PyObject *args) {
4792	>	PyObject *resultobj;
4793	>	BossTask *arg1 = (BossTask *) 0 ;
4794	>	std::ostream &arg2_defvalue = std::cout ;
4795	>	std::ostream *arg2 = (std::ostream *) &arg2_defvalue ;
4796	>	jobStates const &arg3_defvalue = SCHEDULED ;
4797	>	jobStates *arg3 = (jobStates *) &arg3_defvalue ;
4798	>	printOption const &arg4_defvalue = NORMAL ;
4799	>	printOption *arg4 = (printOption *) &arg4_defvalue ;
4800	>	std::string arg5 = (std::string) "" ;
4801		PyObject * obj0 = 0 ;
4802		PyObject * obj1 = 0 ;
4803	+	PyObject * obj2 = 0 ;
4804	+	PyObject * obj3 = 0 ;
4805	+	PyObject * obj4 = 0 ;
4806
4807	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_SQL",&obj0,&obj1)) goto fail;
4808	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4807	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_query_out",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4808	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4809		if (obj1) {
4810	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4811	+	if (arg2 == NULL) {
4812	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
4813	+	}
4814	+	}
4815	+	if (obj2) {
4816	+	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4817	+	if (arg3 == NULL) {
4818	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
4819	+	}
4820	+	}
4821	+	if (obj3) {
4822	+	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4823	+	if (arg4 == NULL) {
4824	+	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
4825	+	}
4826	+	}
4827	+	if (obj4) {
4828		{
4829	<	if (PyString_Check(obj1))
4830	<	arg2 = std::string(PyString_AsString(obj1));
4829	>	if (PyString_Check(obj4))
4830	>	arg5 = std::string(PyString_AsString(obj4));
4831		else
4832		SWIG_exception(SWIG_TypeError, "string expected");
4833		}
4834		}
4835	<	result = (arg1)->SQL(arg2);
4835	>	{
4836	>	try {
4837	>	((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
4838	>
4839	>	}catch (const std::exception& e) {
4840	>	SWIG_exception(SWIG_RuntimeError, e.what());
4841	>	}
4842	>	}
4843	>	Py_INCREF(Py_None); resultobj = Py_None;
4844	>	return resultobj;
4845	>	fail:
4846	>	return NULL;
4847	>	}
4848	>
4849	>
4850	>	static PyObject *_wrap_BossTask_clear(PyObject *self, PyObject *args) {
4851	>	PyObject *resultobj;
4852	>	BossTask *arg1 = (BossTask *) 0 ;
4853	>	PyObject * obj0 = 0 ;
4854
4855	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_clear",&obj0)) goto fail;
4856	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4857		{
4858	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4858	>	try {
4859	>	(arg1)->clear();
4860	>
4861	>	}catch (const std::exception& e) {
4862	>	SWIG_exception(SWIG_RuntimeError, e.what());
4863	>	}
4864		}
4865	+	Py_INCREF(Py_None); resultobj = Py_None;
4866		return resultobj;
4867		fail:
4868		return NULL;
4869		}
4870
4871
4872	<	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
4872	>	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
4873	>	PyObject *obj;
4874	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4875	>	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
4876	>	Py_INCREF(obj);
4877	>	return Py_BuildValue((char *)"");
4878	>	}
4879	>	static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
4880		PyObject *resultobj;
4881	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4882	<	std::string arg2 = (std::string) "NONE" ;
4883	<	std::string result;
4881	>	std::string arg1 = (std::string) "" ;
4882	>	bool arg2 = (bool) false ;
4883	>	BossAdministratorSession *result;
4884		PyObject * obj0 = 0 ;
4885		PyObject * obj1 = 0 ;
4886
4887	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_configureDB",&obj0,&obj1)) goto fail;
4888	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1528	<	if (obj1) {
4887	>	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
4888	>	if (obj0) {
4889		{
4890	<	if (PyString_Check(obj1))
4891	<	arg2 = std::string(PyString_AsString(obj1));
4890	>	if (PyString_Check(obj0))
4891	>	arg1 = std::string(PyString_AsString(obj0));
4892		else
4893		SWIG_exception(SWIG_TypeError, "string expected");
4894		}
4895		}
4896	<	result = (arg1)->configureDB(arg2);
4896	>	if (obj1) {
4897	>	arg2 = PyInt_AsLong(obj1) ? true : false;
4898	>	if (PyErr_Occurred()) SWIG_fail;
4899	>	}
4900	>	{
4901	>	try {
4902	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
4903	>
4904	>	}catch (const std::exception& e) {
4905	>	SWIG_exception(SWIG_RuntimeError, e.what());
4906	>	}
4907	>	}
4908	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
4909	>	return resultobj;
4910	>	fail:
4911	>	return NULL;
4912	>	}
4913	>
4914	>
4915	>	static PyObject *_wrap_delete_BossAdministratorSession(PyObject *self, PyObject *args) {
4916	>	PyObject *resultobj;
4917	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4918	>	PyObject * obj0 = 0 ;
4919
4920	+	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossAdministratorSession",&obj0)) goto fail;
4921	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4922		{
4923	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4923	>	try {
4924	>	delete arg1;
4925	>
4926	>	}catch (const std::exception& e) {
4927	>	SWIG_exception(SWIG_RuntimeError, e.what());
4928	>	}
4929	>	}
4930	>	Py_INCREF(Py_None); resultobj = Py_None;
4931	>	return resultobj;
4932	>	fail:
4933	>	return NULL;
4934	>	}
4935	>
4936	>
4937	>	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
4938	>	PyObject *resultobj;
4939	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4940	>	int result;
4941	>	PyObject * obj0 = 0 ;
4942	>
4943	>	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
4944	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4945	>	{
4946	>	try {
4947	>	result = (int)(arg1)->configureDB();
4948	>
4949	>	}catch (const std::exception& e) {
4950	>	SWIG_exception(SWIG_RuntimeError, e.what());
4951	>	}
4952		}
4953	+	resultobj = PyInt_FromLong((long)result);
4954		return resultobj;
4955		fail:
4956		return NULL;
#	Line 1547 | Line 4960 | static PyObject *_wrap_BossAdministrator
4960		static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
4961		PyObject *resultobj;
4962		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4963	<	std::string arg2 = (std::string) "NONE" ;
4964	<	std::string result;
4963	>	std::string *arg2 = 0 ;
4964	>	int result;
4965	>	std::string temp2 ;
4966		PyObject * obj0 = 0 ;
4967		PyObject * obj1 = 0 ;
4968
4969	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_configureRTMonDB",&obj0,&obj1)) goto fail;
4969	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureRTMonDB",&obj0,&obj1)) goto fail;
4970		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4971	<	if (obj1) {
4972	<	{
4973	<	if (PyString_Check(obj1))
4974	<	arg2 = std::string(PyString_AsString(obj1));
4975	<	else
4971	>	{
4972	>	if (PyString_Check(obj1)) {
4973	>	temp2 = std::string(PyString_AsString(obj1));
4974	>	arg2 = &temp2;
4975	>	}else {
4976		SWIG_exception(SWIG_TypeError, "string expected");
4977		}
4978		}
1565	–	result = (arg1)->configureRTMonDB(arg2);
1566	–
4979		{
4980	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4980	>	try {
4981	>	result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
4982	>
4983	>	}catch (const std::exception& e) {
4984	>	SWIG_exception(SWIG_RuntimeError, e.what());
4985	>	}
4986		}
4987	+	resultobj = PyInt_FromLong((long)result);
4988		return resultobj;
4989		fail:
4990		return NULL;
#	Line 1576 | Line 4994 | static PyObject *_wrap_BossAdministrator
4994		static PyObject *_wrap_BossAdministratorSession_deleteCHTool(PyObject *self, PyObject *args) {
4995		PyObject *resultobj;
4996		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4997	<	std::string arg2 = (std::string) "NONE" ;
4998	<	std::string result;
4997	>	std::string *arg2 = 0 ;
4998	>	int result;
4999	>	std::string temp2 ;
5000		PyObject * obj0 = 0 ;
5001		PyObject * obj1 = 0 ;
5002
5003	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_deleteCHTool",&obj0,&obj1)) goto fail;
5003	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteCHTool",&obj0,&obj1)) goto fail;
5004		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5005	<	if (obj1) {
5006	<	{
5007	<	if (PyString_Check(obj1))
5008	<	arg2 = std::string(PyString_AsString(obj1));
5009	<	else
5005	>	{
5006	>	if (PyString_Check(obj1)) {
5007	>	temp2 = std::string(PyString_AsString(obj1));
5008	>	arg2 = &temp2;
5009	>	}else {
5010		SWIG_exception(SWIG_TypeError, "string expected");
5011		}
5012		}
1594	–	result = (arg1)->deleteCHTool(arg2);
1595	–
5013		{
5014	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5014	>	try {
5015	>	result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5016	>
5017	>	}catch (const std::exception& e) {
5018	>	SWIG_exception(SWIG_RuntimeError, e.what());
5019	>	}
5020		}
5021	+	resultobj = PyInt_FromLong((long)result);
5022		return resultobj;
5023		fail:
5024		return NULL;
#	Line 1605 | Line 5028 | static PyObject *_wrap_BossAdministrator
5028		static PyObject *_wrap_BossAdministratorSession_deleteProgramType(PyObject *self, PyObject *args) {
5029		PyObject *resultobj;
5030		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5031	<	std::string arg2 = (std::string) "NONE" ;
5032	<	std::string result;
5031	>	std::string *arg2 = 0 ;
5032	>	int result;
5033	>	std::string temp2 ;
5034		PyObject * obj0 = 0 ;
5035		PyObject * obj1 = 0 ;
5036
5037	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_deleteProgramType",&obj0,&obj1)) goto fail;
5037	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteProgramType",&obj0,&obj1)) goto fail;
5038		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5039	<	if (obj1) {
5040	<	{
5041	<	if (PyString_Check(obj1))
5042	<	arg2 = std::string(PyString_AsString(obj1));
5043	<	else
5039	>	{
5040	>	if (PyString_Check(obj1)) {
5041	>	temp2 = std::string(PyString_AsString(obj1));
5042	>	arg2 = &temp2;
5043	>	}else {
5044		SWIG_exception(SWIG_TypeError, "string expected");
5045		}
5046		}
1623	–	result = (arg1)->deleteProgramType(arg2);
1624	–
5047		{
5048	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5048	>	try {
5049	>	result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5050	>
5051	>	}catch (const std::exception& e) {
5052	>	SWIG_exception(SWIG_RuntimeError, e.what());
5053	>	}
5054		}
5055	+	resultobj = PyInt_FromLong((long)result);
5056		return resultobj;
5057		fail:
5058		return NULL;
#	Line 1634 | Line 5062 | static PyObject *_wrap_BossAdministrator
5062		static PyObject *_wrap_BossAdministratorSession_deleteRTMon(PyObject *self, PyObject *args) {
5063		PyObject *resultobj;
5064		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5065	<	std::string arg2 = (std::string) "NONE" ;
5066	<	std::string result;
5065	>	std::string *arg2 = 0 ;
5066	>	int result;
5067	>	std::string temp2 ;
5068		PyObject * obj0 = 0 ;
5069		PyObject * obj1 = 0 ;
5070
5071	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_deleteRTMon",&obj0,&obj1)) goto fail;
5071	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteRTMon",&obj0,&obj1)) goto fail;
5072		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5073	<	if (obj1) {
5074	<	{
5075	<	if (PyString_Check(obj1))
5076	<	arg2 = std::string(PyString_AsString(obj1));
5077	<	else
5073	>	{
5074	>	if (PyString_Check(obj1)) {
5075	>	temp2 = std::string(PyString_AsString(obj1));
5076	>	arg2 = &temp2;
5077	>	}else {
5078		SWIG_exception(SWIG_TypeError, "string expected");
5079		}
5080		}
1652	–	result = (arg1)->deleteRTMon(arg2);
1653	–
5081		{
5082	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5082	>	try {
5083	>	result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5084	>
5085	>	}catch (const std::exception& e) {
5086	>	SWIG_exception(SWIG_RuntimeError, e.what());
5087	>	}
5088		}
5089	+	resultobj = PyInt_FromLong((long)result);
5090		return resultobj;
5091		fail:
5092		return NULL;
#	Line 1663 | Line 5096 | static PyObject *_wrap_BossAdministrator
5096		static PyObject *_wrap_BossAdministratorSession_deleteScheduler(PyObject *self, PyObject *args) {
5097		PyObject *resultobj;
5098		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5099	<	std::string arg2 = (std::string) "NONE" ;
5100	<	std::string result;
5099	>	std::string *arg2 = 0 ;
5100	>	int result;
5101	>	std::string temp2 ;
5102		PyObject * obj0 = 0 ;
5103		PyObject * obj1 = 0 ;
5104
5105	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_deleteScheduler",&obj0,&obj1)) goto fail;
5105	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteScheduler",&obj0,&obj1)) goto fail;
5106		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5107	<	if (obj1) {
5108	<	{
5109	<	if (PyString_Check(obj1))
5110	<	arg2 = std::string(PyString_AsString(obj1));
5111	<	else
5107	>	{
5108	>	if (PyString_Check(obj1)) {
5109	>	temp2 = std::string(PyString_AsString(obj1));
5110	>	arg2 = &temp2;
5111	>	}else {
5112		SWIG_exception(SWIG_TypeError, "string expected");
5113		}
5114		}
1681	–	result = (arg1)->deleteScheduler(arg2);
1682	–
5115		{
5116	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5116	>	try {
5117	>	result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5118	>
5119	>	}catch (const std::exception& e) {
5120	>	SWIG_exception(SWIG_RuntimeError, e.what());
5121	>	}
5122		}
5123	+	resultobj = PyInt_FromLong((long)result);
5124		return resultobj;
5125		fail:
5126		return NULL;
5127		}
5128
5129
5130	<	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
5130	>	static PyObject *_wrap_BossAdministratorSession_registerCHTool(PyObject *self, PyObject *args) {
5131		PyObject *resultobj;
5132		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5133	<	std::string arg2 = (std::string) "NONE" ;
5134	<	std::string result;
5133	>	std::string *arg2 = 0 ;
5134	>	std::string arg3 = (std::string) "NULL" ;
5135	>	std::string arg4 = (std::string) "NULL" ;
5136	>	bool arg5 = (bool) false ;
5137	>	bool arg6 = (bool) false ;
5138	>	int result;
5139	>	std::string temp2 ;
5140		PyObject * obj0 = 0 ;
5141		PyObject * obj1 = 0 ;
5142	+	PyObject * obj2 = 0 ;
5143	+	PyObject * obj3 = 0 ;
5144	+	PyObject * obj4 = 0 ;
5145	+	PyObject * obj5 = 0 ;
5146
5147	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_purge",&obj0,&obj1)) goto fail;
5147	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5148		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5149	<	if (obj1) {
5149	>	{
5150	>	if (PyString_Check(obj1)) {
5151	>	temp2 = std::string(PyString_AsString(obj1));
5152	>	arg2 = &temp2;
5153	>	}else {
5154	>	SWIG_exception(SWIG_TypeError, "string expected");
5155	>	}
5156	>	}
5157	>	if (obj2) {
5158		{
5159	<	if (PyString_Check(obj1))
5160	<	arg2 = std::string(PyString_AsString(obj1));
5159	>	if (PyString_Check(obj2))
5160	>	arg3 = std::string(PyString_AsString(obj2));
5161		else
5162		SWIG_exception(SWIG_TypeError, "string expected");
5163		}
5164		}
5165	<	result = (arg1)->purge(arg2);
5166	<
5165	>	if (obj3) {
5166	>	{
5167	>	if (PyString_Check(obj3))
5168	>	arg4 = std::string(PyString_AsString(obj3));
5169	>	else
5170	>	SWIG_exception(SWIG_TypeError, "string expected");
5171	>	}
5172	>	}
5173	>	if (obj4) {
5174	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5175	>	if (PyErr_Occurred()) SWIG_fail;
5176	>	}
5177	>	if (obj5) {
5178	>	arg6 = PyInt_AsLong(obj5) ? true : false;
5179	>	if (PyErr_Occurred()) SWIG_fail;
5180	>	}
5181		{
5182	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5182	>	try {
5183	>	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5184	>
5185	>	}catch (const std::exception& e) {
5186	>	SWIG_exception(SWIG_RuntimeError, e.what());
5187	>	}
5188		}
5189	+	resultobj = PyInt_FromLong((long)result);
5190		return resultobj;
5191		fail:
5192		return NULL;
5193		}
5194
5195
5196	<	static PyObject *_wrap_BossAdministratorSession_registerCHTool(PyObject *self, PyObject *args) {
5196	>	static PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
5197		PyObject *resultobj;
5198		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5199	<	std::string arg2 = (std::string) "NONE" ;
5200	<	std::string result;
5199	>	std::string *arg2 = 0 ;
5200	>	std::string arg3 = (std::string) "NULL" ;
5201	>	std::string arg4 = (std::string) "NULL" ;
5202	>	std::string arg5 = (std::string) "NULL" ;
5203	>	std::string arg6 = (std::string) "NULL" ;
5204	>	std::string arg7 = (std::string) "" ;
5205	>	bool arg8 = (bool) false ;
5206	>	int result;
5207	>	std::string temp2 ;
5208		PyObject * obj0 = 0 ;
5209		PyObject * obj1 = 0 ;
5210	+	PyObject * obj2 = 0 ;
5211	+	PyObject * obj3 = 0 ;
5212	+	PyObject * obj4 = 0 ;
5213	+	PyObject * obj5 = 0 ;
5214	+	PyObject * obj6 = 0 ;
5215	+	PyObject * obj7 = 0 ;
5216
5217	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_registerCHTool",&obj0,&obj1)) goto fail;
5217	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5218		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5219	<	if (obj1) {
5219	>	{
5220	>	if (PyString_Check(obj1)) {
5221	>	temp2 = std::string(PyString_AsString(obj1));
5222	>	arg2 = &temp2;
5223	>	}else {
5224	>	SWIG_exception(SWIG_TypeError, "string expected");
5225	>	}
5226	>	}
5227	>	if (obj2) {
5228		{
5229	<	if (PyString_Check(obj1))
5230	<	arg2 = std::string(PyString_AsString(obj1));
5229	>	if (PyString_Check(obj2))
5230	>	arg3 = std::string(PyString_AsString(obj2));
5231		else
5232		SWIG_exception(SWIG_TypeError, "string expected");
5233		}
5234		}
5235	<	result = (arg1)->registerCHTool(arg2);
5236	<
5235	>	if (obj3) {
5236	>	{
5237	>	if (PyString_Check(obj3))
5238	>	arg4 = std::string(PyString_AsString(obj3));
5239	>	else
5240	>	SWIG_exception(SWIG_TypeError, "string expected");
5241	>	}
5242	>	}
5243	>	if (obj4) {
5244	>	{
5245	>	if (PyString_Check(obj4))
5246	>	arg5 = std::string(PyString_AsString(obj4));
5247	>	else
5248	>	SWIG_exception(SWIG_TypeError, "string expected");
5249	>	}
5250	>	}
5251	>	if (obj5) {
5252	>	{
5253	>	if (PyString_Check(obj5))
5254	>	arg6 = std::string(PyString_AsString(obj5));
5255	>	else
5256	>	SWIG_exception(SWIG_TypeError, "string expected");
5257	>	}
5258	>	}
5259	>	if (obj6) {
5260	>	{
5261	>	if (PyString_Check(obj6))
5262	>	arg7 = std::string(PyString_AsString(obj6));
5263	>	else
5264	>	SWIG_exception(SWIG_TypeError, "string expected");
5265	>	}
5266	>	}
5267	>	if (obj7) {
5268	>	arg8 = PyInt_AsLong(obj7) ? true : false;
5269	>	if (PyErr_Occurred()) SWIG_fail;
5270	>	}
5271		{
5272	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5272	>	try {
5273	>	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5274	>
5275	>	}catch (const std::exception& e) {
5276	>	SWIG_exception(SWIG_RuntimeError, e.what());
5277	>	}
5278		}
5279	+	resultobj = PyInt_FromLong((long)result);
5280		return resultobj;
5281		fail:
5282		return NULL;
5283		}
5284
5285
5286	<	static PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
5286	>	static PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
5287		PyObject *resultobj;
5288		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5289	<	std::string arg2 = (std::string) "NONE" ;
5290	<	std::string result;
5289	>	std::string *arg2 = 0 ;
5290	>	std::string arg3 = (std::string) "NULL" ;
5291	>	std::string arg4 = (std::string) "NULL" ;
5292	>	std::string arg5 = (std::string) "NULL" ;
5293	>	bool arg6 = (bool) false ;
5294	>	bool arg7 = (bool) false ;
5295	>	int result;
5296	>	std::string temp2 ;
5297		PyObject * obj0 = 0 ;
5298		PyObject * obj1 = 0 ;
5299	+	PyObject * obj2 = 0 ;
5300	+	PyObject * obj3 = 0 ;
5301	+	PyObject * obj4 = 0 ;
5302	+	PyObject * obj5 = 0 ;
5303	+	PyObject * obj6 = 0 ;
5304
5305	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_registerProgram",&obj0,&obj1)) goto fail;
5305	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5306		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5307	<	if (obj1) {
5307	>	{
5308	>	if (PyString_Check(obj1)) {
5309	>	temp2 = std::string(PyString_AsString(obj1));
5310	>	arg2 = &temp2;
5311	>	}else {
5312	>	SWIG_exception(SWIG_TypeError, "string expected");
5313	>	}
5314	>	}
5315	>	if (obj2) {
5316		{
5317	<	if (PyString_Check(obj1))
5318	<	arg2 = std::string(PyString_AsString(obj1));
5317	>	if (PyString_Check(obj2))
5318	>	arg3 = std::string(PyString_AsString(obj2));
5319		else
5320		SWIG_exception(SWIG_TypeError, "string expected");
5321		}
5322		}
5323	<	result = (arg1)->registerProgram(arg2);
5324	<
5323	>	if (obj3) {
5324	>	{
5325	>	if (PyString_Check(obj3))
5326	>	arg4 = std::string(PyString_AsString(obj3));
5327	>	else
5328	>	SWIG_exception(SWIG_TypeError, "string expected");
5329	>	}
5330	>	}
5331	>	if (obj4) {
5332	>	{
5333	>	if (PyString_Check(obj4))
5334	>	arg5 = std::string(PyString_AsString(obj4));
5335	>	else
5336	>	SWIG_exception(SWIG_TypeError, "string expected");
5337	>	}
5338	>	}
5339	>	if (obj5) {
5340	>	arg6 = PyInt_AsLong(obj5) ? true : false;
5341	>	if (PyErr_Occurred()) SWIG_fail;
5342	>	}
5343	>	if (obj6) {
5344	>	arg7 = PyInt_AsLong(obj6) ? true : false;
5345	>	if (PyErr_Occurred()) SWIG_fail;
5346	>	}
5347		{
5348	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5348	>	try {
5349	>	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5350	>
5351	>	}catch (const std::exception& e) {
5352	>	SWIG_exception(SWIG_RuntimeError, e.what());
5353	>	}
5354		}
5355	+	resultobj = PyInt_FromLong((long)result);
5356		return resultobj;
5357		fail:
5358		return NULL;
5359		}
5360
5361
5362	<	static PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
5362	>	static PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
5363		PyObject *resultobj;
5364		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5365	<	std::string arg2 = (std::string) "NONE" ;
5366	<	std::string result;
5365	>	std::string *arg2 = 0 ;
5366	>	std::string arg3 = (std::string) "NULL" ;
5367	>	std::string arg4 = (std::string) "NULL" ;
5368	>	std::string arg5 = (std::string) "NULL" ;
5369	>	std::string arg6 = (std::string) "NULL" ;
5370	>	std::string arg7 = (std::string) "" ;
5371	>	std::string arg8 = (std::string) "" ;
5372	>	std::string arg9 = (std::string) "" ;
5373	>	std::string arg10 = (std::string) "" ;
5374	>	std::string const &arg11_defvalue = "" ;
5375	>	std::string *arg11 = (std::string *) &arg11_defvalue ;
5376	>	std::string arg12 = (std::string) "" ;
5377	>	std::string arg13 = (std::string) "" ;
5378	>	bool arg14 = (bool) false ;
5379	>	bool arg15 = (bool) false ;
5380	>	bool arg16 = (bool) false ;
5381	>	int result;
5382	>	std::string temp2 ;
5383	>	std::string temp11 ;
5384		PyObject * obj0 = 0 ;
5385		PyObject * obj1 = 0 ;
5386	+	PyObject * obj2 = 0 ;
5387	+	PyObject * obj3 = 0 ;
5388	+	PyObject * obj4 = 0 ;
5389	+	PyObject * obj5 = 0 ;
5390	+	PyObject * obj6 = 0 ;
5391	+	PyObject * obj7 = 0 ;
5392	+	PyObject * obj8 = 0 ;
5393	+	PyObject * obj9 = 0 ;
5394	+	PyObject * obj10 = 0 ;
5395	+	PyObject * obj11 = 0 ;
5396	+	PyObject * obj12 = 0 ;
5397	+	PyObject * obj13 = 0 ;
5398	+	PyObject * obj14 = 0 ;
5399	+	PyObject * obj15 = 0 ;
5400
5401	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_registerRTMon",&obj0,&obj1)) goto fail;
5401	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) goto fail;
5402		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5403	<	if (obj1) {
5403	>	{
5404	>	if (PyString_Check(obj1)) {
5405	>	temp2 = std::string(PyString_AsString(obj1));
5406	>	arg2 = &temp2;
5407	>	}else {
5408	>	SWIG_exception(SWIG_TypeError, "string expected");
5409	>	}
5410	>	}
5411	>	if (obj2) {
5412		{
5413	<	if (PyString_Check(obj1))
5414	<	arg2 = std::string(PyString_AsString(obj1));
5413	>	if (PyString_Check(obj2))
5414	>	arg3 = std::string(PyString_AsString(obj2));
5415	>	else
5416	>	SWIG_exception(SWIG_TypeError, "string expected");
5417	>	}
5418	>	}
5419	>	if (obj3) {
5420	>	{
5421	>	if (PyString_Check(obj3))
5422	>	arg4 = std::string(PyString_AsString(obj3));
5423	>	else
5424	>	SWIG_exception(SWIG_TypeError, "string expected");
5425	>	}
5426	>	}
5427	>	if (obj4) {
5428	>	{
5429	>	if (PyString_Check(obj4))
5430	>	arg5 = std::string(PyString_AsString(obj4));
5431	>	else
5432	>	SWIG_exception(SWIG_TypeError, "string expected");
5433	>	}
5434	>	}
5435	>	if (obj5) {
5436	>	{
5437	>	if (PyString_Check(obj5))
5438	>	arg6 = std::string(PyString_AsString(obj5));
5439	>	else
5440	>	SWIG_exception(SWIG_TypeError, "string expected");
5441	>	}
5442	>	}
5443	>	if (obj6) {
5444	>	{
5445	>	if (PyString_Check(obj6))
5446	>	arg7 = std::string(PyString_AsString(obj6));
5447		else
5448		SWIG_exception(SWIG_TypeError, "string expected");
5449		}
5450		}
5451	<	result = (arg1)->registerRTMon(arg2);
5451	>	if (obj7) {
5452	>	{
5453	>	if (PyString_Check(obj7))
5454	>	arg8 = std::string(PyString_AsString(obj7));
5455	>	else
5456	>	SWIG_exception(SWIG_TypeError, "string expected");
5457	>	}
5458	>	}
5459	>	if (obj8) {
5460	>	{
5461	>	if (PyString_Check(obj8))
5462	>	arg9 = std::string(PyString_AsString(obj8));
5463	>	else
5464	>	SWIG_exception(SWIG_TypeError, "string expected");
5465	>	}
5466	>	}
5467	>	if (obj9) {
5468	>	{
5469	>	if (PyString_Check(obj9))
5470	>	arg10 = std::string(PyString_AsString(obj9));
5471	>	else
5472	>	SWIG_exception(SWIG_TypeError, "string expected");
5473	>	}
5474	>	}
5475	>	if (obj10) {
5476	>	{
5477	>	if (PyString_Check(obj10)) {
5478	>	temp11 = std::string(PyString_AsString(obj10));
5479	>	arg11 = &temp11;
5480	>	}else {
5481	>	SWIG_exception(SWIG_TypeError, "string expected");
5482	>	}
5483	>	}
5484	>	}
5485	>	if (obj11) {
5486	>	{
5487	>	if (PyString_Check(obj11))
5488	>	arg12 = std::string(PyString_AsString(obj11));
5489	>	else
5490	>	SWIG_exception(SWIG_TypeError, "string expected");
5491	>	}
5492	>	}
5493	>	if (obj12) {
5494	>	{
5495	>	if (PyString_Check(obj12))
5496	>	arg13 = std::string(PyString_AsString(obj12));
5497	>	else
5498	>	SWIG_exception(SWIG_TypeError, "string expected");
5499	>	}
5500	>	}
5501	>	if (obj13) {
5502	>	arg14 = PyInt_AsLong(obj13) ? true : false;
5503	>	if (PyErr_Occurred()) SWIG_fail;
5504	>	}
5505	>	if (obj14) {
5506	>	arg15 = PyInt_AsLong(obj14) ? true : false;
5507	>	if (PyErr_Occurred()) SWIG_fail;
5508	>	}
5509	>	if (obj15) {
5510	>	arg16 = PyInt_AsLong(obj15) ? true : false;
5511	>	if (PyErr_Occurred()) SWIG_fail;
5512	>	}
5513	>	{
5514	>	try {
5515	>	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);
5516	>
5517	>	}catch (const std::exception& e) {
5518	>	SWIG_exception(SWIG_RuntimeError, e.what());
5519	>	}
5520	>	}
5521	>	resultobj = PyInt_FromLong((long)result);
5522	>	return resultobj;
5523	>	fail:
5524	>	return NULL;
5525	>	}
5526	>
5527	>
5528	>	static PyObject *_wrap_BossAdministratorSession_help(PyObject *self, PyObject *args) {
5529	>	PyObject *resultobj;
5530	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5531	>	std::string result;
5532	>	PyObject * obj0 = 0 ;
5533
5534	+	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_help",&obj0)) goto fail;
5535	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5536	+	{
5537	+	try {
5538	+	result = (arg1)->help();
5539	+
5540	+	}catch (const std::exception& e) {
5541	+	SWIG_exception(SWIG_RuntimeError, e.what());
5542	+	}
5543	+	}
5544		{
5545		resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5546		}
#	Line 1805 | Line 5550 | static PyObject *_wrap_BossAdministrator
5550		}
5551
5552
5553	<	static PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
5553	>	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
5554		PyObject *resultobj;
5555		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5556	<	std::string arg2 = (std::string) "NONE" ;
5556	>	std::string arg2 ;
5557	>	bool arg3 = (bool) false ;
5558		std::string result;
5559		PyObject * obj0 = 0 ;
5560		PyObject * obj1 = 0 ;
5561	+	PyObject * obj2 = 0 ;
5562
5563	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_registerScheduler",&obj0,&obj1)) goto fail;
5563	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
5564		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5565	<	if (obj1) {
5566	<	{
5567	<	if (PyString_Check(obj1))
5568	<	arg2 = std::string(PyString_AsString(obj1));
5569	<	else
5570	<	SWIG_exception(SWIG_TypeError, "string expected");
5565	>	{
5566	>	if (PyString_Check(obj1))
5567	>	arg2 = std::string(PyString_AsString(obj1));
5568	>	else
5569	>	SWIG_exception(SWIG_TypeError, "string expected");
5570	>	}
5571	>	if (obj2) {
5572	>	arg3 = PyInt_AsLong(obj2) ? true : false;
5573	>	if (PyErr_Occurred()) SWIG_fail;
5574	>	}
5575	>	{
5576	>	try {
5577	>	result = (arg1)->SQL(arg2,arg3);
5578	>
5579	>	}catch (const std::exception& e) {
5580	>	SWIG_exception(SWIG_RuntimeError, e.what());
5581		}
5582		}
1826	–	result = (arg1)->registerScheduler(arg2);
1827	–
5583		{
5584		resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5585		}
#	Line 1834 | Line 5589 | static PyObject *_wrap_BossAdministrator
5589		}
5590
5591
5592	<	static PyObject *_wrap_BossAdministratorSession_version(PyObject *self, PyObject *args) {
5592	>	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
5593		PyObject *resultobj;
5594		BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5595	<	std::string arg2 = (std::string) "NONE" ;
5596	<	std::string result;
5595	>	std::string *arg2 = 0 ;
5596	>	std::string *arg3 = 0 ;
5597	>	std::string *arg4 = 0 ;
5598	>	std::string const &arg5_defvalue = "0" ;
5599	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
5600	>	int result;
5601	>	std::string temp2 ;
5602	>	std::string temp3 ;
5603	>	std::string temp4 ;
5604	>	std::string temp5 ;
5605		PyObject * obj0 = 0 ;
5606		PyObject * obj1 = 0 ;
5607	+	PyObject * obj2 = 0 ;
5608	+	PyObject * obj3 = 0 ;
5609	+	PyObject * obj4 = 0 ;
5610
5611	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossAdministratorSession_version",&obj0,&obj1)) goto fail;
5611	>	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5612		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5613	<	if (obj1) {
5614	<	{
5615	<	if (PyString_Check(obj1))
5616	<	arg2 = std::string(PyString_AsString(obj1));
5617	<	else
5613	>	{
5614	>	if (PyString_Check(obj1)) {
5615	>	temp2 = std::string(PyString_AsString(obj1));
5616	>	arg2 = &temp2;
5617	>	}else {
5618		SWIG_exception(SWIG_TypeError, "string expected");
5619		}
5620		}
5621	<	result = (arg1)->version(arg2);
5621	>	{
5622	>	if (PyString_Check(obj2)) {
5623	>	temp3 = std::string(PyString_AsString(obj2));
5624	>	arg3 = &temp3;
5625	>	}else {
5626	>	SWIG_exception(SWIG_TypeError, "string expected");
5627	>	}
5628	>	}
5629	>	{
5630	>	if (PyString_Check(obj3)) {
5631	>	temp4 = std::string(PyString_AsString(obj3));
5632	>	arg4 = &temp4;
5633	>	}else {
5634	>	SWIG_exception(SWIG_TypeError, "string expected");
5635	>	}
5636	>	}
5637	>	if (obj4) {
5638	>	{
5639	>	if (PyString_Check(obj4)) {
5640	>	temp5 = std::string(PyString_AsString(obj4));
5641	>	arg5 = &temp5;
5642	>	}else {
5643	>	SWIG_exception(SWIG_TypeError, "string expected");
5644	>	}
5645	>	}
5646	>	}
5647	>	{
5648	>	try {
5649	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
5650	>
5651	>	}catch (const std::exception& e) {
5652	>	SWIG_exception(SWIG_RuntimeError, e.what());
5653	>	}
5654	>	}
5655	>	resultobj = PyInt_FromLong((long)result);
5656	>	return resultobj;
5657	>	fail:
5658	>	return NULL;
5659	>	}
5660	>
5661	>
5662	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
5663	>	PyObject *resultobj;
5664	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5665	>	std::string arg2 ;
5666	>	int result;
5667	>	PyObject * obj0 = 0 ;
5668	>	PyObject * obj1 = 0 ;
5669
5670	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
5671	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5672		{
5673	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5673	>	if (PyString_Check(obj1))
5674	>	arg2 = std::string(PyString_AsString(obj1));
5675	>	else
5676	>	SWIG_exception(SWIG_TypeError, "string expected");
5677		}
5678	+	{
5679	+	try {
5680	+	result = (int)(arg1)->registerPlugins(arg2);
5681	+
5682	+	}catch (const std::exception& e) {
5683	+	SWIG_exception(SWIG_RuntimeError, e.what());
5684	+	}
5685	+	}
5686	+	resultobj = PyInt_FromLong((long)result);
5687		return resultobj;
5688		fail:
5689		return NULL;
#	Line 1871 | Line 5698 | static PyObject * BossAdministratorSessi
5698		return Py_BuildValue((char *)"");
5699		}
5700		static PyMethodDef SwigMethods[] = {
5701	+	{ (char *)"new_objectMap", _wrap_new_objectMap, METH_VARARGS },
5702	+	{ (char *)"objectMap___len__", _wrap_objectMap___len__, METH_VARARGS },
5703	+	{ (char *)"objectMap_clear", _wrap_objectMap_clear, METH_VARARGS },
5704	+	{ (char *)"objectMap___nonzero__", _wrap_objectMap___nonzero__, METH_VARARGS },
5705	+	{ (char *)"objectMap___getitem__", _wrap_objectMap___getitem__, METH_VARARGS },
5706	+	{ (char *)"objectMap___setitem__", _wrap_objectMap___setitem__, METH_VARARGS },
5707	+	{ (char *)"objectMap___delitem__", _wrap_objectMap___delitem__, METH_VARARGS },
5708	+	{ (char *)"objectMap_has_key", _wrap_objectMap_has_key, METH_VARARGS },
5709	+	{ (char *)"objectMap_keys", _wrap_objectMap_keys, METH_VARARGS },
5710	+	{ (char *)"objectMap_values", _wrap_objectMap_values, METH_VARARGS },
5711	+	{ (char *)"objectMap_items", _wrap_objectMap_items, METH_VARARGS },
5712	+	{ (char *)"objectMap___contains__", _wrap_objectMap___contains__, METH_VARARGS },
5713	+	{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
5714	+	{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
5715	+	{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
5716	+	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
5717	+	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
5718	+	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
5719	+	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
5720	+	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
5721	+	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
5722	+	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
5723	+	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
5724	+	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
5725	+	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
5726	+	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
5727	+	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
5728	+	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
5729	+	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5730	+	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5731	+	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5732	+	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5733	+	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5734	+	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5735	+	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5736	+	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
5737		{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
5738		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
5739	+	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
5740	+	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
5741	+	{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
5742	+	{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
5743	+	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
5744	+	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
5745	+	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
5746	+	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS },
5747	+	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
5748	+	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
5749	+	{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5750	+	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
5751	+	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
5752	+	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
5753	+	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
5754	+	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
5755		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5756	<	{ (char *)"new_BossUserSession", _wrap_new_BossUserSession, METH_VARARGS },
5757	<	{ (char *)"delete_BossUserSession", _wrap_delete_BossUserSession, METH_VARARGS },
5758	<	{ (char *)"BossUserSession_exitCode", _wrap_BossUserSession_exitCode, METH_VARARGS },
5759	<	{ (char *)"BossUserSession_out", _wrap_BossUserSession_out, METH_VARARGS },
5760	<	{ (char *)"BossUserSession_err", _wrap_BossUserSession_err, METH_VARARGS },
5761	<	{ (char *)"BossUserSession_help", _wrap_BossUserSession_help, METH_VARARGS },
5762	<	{ (char *)"BossUserSession_SQL", _wrap_BossUserSession_SQL, METH_VARARGS },
5763	<	{ (char *)"BossUserSession_RTupdate", _wrap_BossUserSession_RTupdate, METH_VARARGS },
5764	<	{ (char *)"BossUserSession_clientID", _wrap_BossUserSession_clientID, METH_VARARGS },
5765	<	{ (char *)"BossUserSession_declare", _wrap_BossUserSession_declare, METH_VARARGS },
5766	<	{ (char *)"BossUserSession_deleteTask", _wrap_BossUserSession_deleteTask, METH_VARARGS },
5767	<	{ (char *)"BossUserSession_getOutput", _wrap_BossUserSession_getOutput, METH_VARARGS },
5768	<	{ (char *)"BossUserSession_kill", _wrap_BossUserSession_kill, METH_VARARGS },
5769	<	{ (char *)"BossUserSession_query", _wrap_BossUserSession_query, METH_VARARGS },
5770	<	{ (char *)"BossUserSession_showCHTools", _wrap_BossUserSession_showCHTools, METH_VARARGS },
5771	<	{ (char *)"BossUserSession_showConfig", _wrap_BossUserSession_showConfig, METH_VARARGS },
5772	<	{ (char *)"BossUserSession_showProgramTypes", _wrap_BossUserSession_showProgramTypes, METH_VARARGS },
5773	<	{ (char *)"BossUserSession_showRTMon", _wrap_BossUserSession_showRTMon, METH_VARARGS },
5774	<	{ (char *)"BossUserSession_showSchedulers", _wrap_BossUserSession_showSchedulers, METH_VARARGS },
5775	<	{ (char *)"BossUserSession_submit", _wrap_BossUserSession_submit, METH_VARARGS },
5776	<	{ (char *)"BossUserSession_version", _wrap_BossUserSession_version, METH_VARARGS },
5777	<	{ (char *)"BossUserSession_swigregister", BossUserSession_swigregister, METH_VARARGS },
5756	>	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5757	>	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
5758	>	{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
5759	>	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
5760	>	{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
5761	>	{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5762	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5763	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5764	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
5765	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5766	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
5767	>	{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
5768	>	{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
5769	>	{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
5770	>	{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
5771	>	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5772	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5773	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
5774	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5775	>	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5776	>	{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
5777	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
5778	>	{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
5779	>	{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
5780	>	{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
5781	>	{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
5782	>	{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
5783	>	{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
5784	>	{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
5785	>	{ (char *)"BossTask_getAllOutput", _wrap_BossTask_getAllOutput, METH_VARARGS },
5786	>	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
5787	>	{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
5788	>	{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
5789	>	{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
5790	>	{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5791		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
5792		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
1901	–	{ (char *)"BossAdministratorSession_exitCode", _wrap_BossAdministratorSession_exitCode, METH_VARARGS },
1902	–	{ (char *)"BossAdministratorSession_out", _wrap_BossAdministratorSession_out, METH_VARARGS },
1903	–	{ (char *)"BossAdministratorSession_err", _wrap_BossAdministratorSession_err, METH_VARARGS },
1904	–	{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
1905	–	{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
5793		{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
5794		{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
5795		{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
5796		{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
5797		{ (char *)"BossAdministratorSession_deleteRTMon", _wrap_BossAdministratorSession_deleteRTMon, METH_VARARGS },
5798		{ (char *)"BossAdministratorSession_deleteScheduler", _wrap_BossAdministratorSession_deleteScheduler, METH_VARARGS },
1912	–	{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
5799		{ (char *)"BossAdministratorSession_registerCHTool", _wrap_BossAdministratorSession_registerCHTool, METH_VARARGS },
5800		{ (char *)"BossAdministratorSession_registerProgram", _wrap_BossAdministratorSession_registerProgram, METH_VARARGS },
5801		{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
5802		{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
5803	<	{ (char *)"BossAdministratorSession_version", _wrap_BossAdministratorSession_version, METH_VARARGS },
5803	>	{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
5804	>	{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
5805	>	{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
5806	>	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
5807		{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
5808		{ NULL, NULL }
5809		};
#	Line 1922 | Line 5811 | static PyMethodDef SwigMethods[] = {
5811
5812		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5813
5814	<	static void *_p_BossUserSessionTo_p_BossSession(void *x) {
5815	<	return (void *)((BossSession *)  ((BossUserSession *) x));
5816	<	}
5817	<	static void *_p_BossAdministratorSessionTo_p_BossSession(void *x) {
5818	<	return (void *)((BossSession *)  ((BossAdministratorSession *) x));
5819	<	}
5820	<	static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{"_p_BossUserSession", _p_BossUserSessionTo_p_BossSession},{"_p_BossAdministratorSession", _p_BossAdministratorSessionTo_p_BossSession},{0}};
5821	<	static swig_type_info _swigt__p_BossUserSession[] = {{"_p_BossUserSession", 0, "BossUserSession *", 0},{"_p_BossUserSession"},{0}};
5814	>	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}};
5815	>	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}};
5816	>	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
5817	>	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}};
5818	>	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}};
5819	>	static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
5820	>	static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5821	>	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
5822	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
5823	>	static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
5824	>	static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
5825	>	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
5826	>	static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
5827	>	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}};
5828	>	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}};
5829		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5830	+	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}};
5831	+	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}};
5832	+	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
5833
5834		static swig_type_info *swig_types_initial[] = {
5835	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
5836	+	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
5837	+	_swigt__p_XMLDoc,
5838	+	_swigt__p_std__vectorTBossTask_p_t,
5839	+	_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
5840	+	_swigt__p_BossTask,
5841	+	_swigt__p_BossTaskException,
5842	+	_swigt__p_std__ostream,
5843	+	_swigt__p_BossAttributeContainer,
5844	+	_swigt__p_printOption,
5845	+	_swigt__p_BossJob,
5846	+	_swigt__p_BossDatabase,
5847		_swigt__p_BossSession,
5848	<	_swigt__p_BossUserSession,
5848	>	_swigt__p_std__vectorTstd__string_t,
5849	>	_swigt__p_std__mapTstd__string_std__string_t,
5850		_swigt__p_BossAdministratorSession,
5851	+	_swigt__p_BossTask__job_iterator,
5852	+	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
5853	+	_swigt__p_jobStates,
5854		0
5855		};
5856
#	Line 1943 | Line 5858 | _swigt__p_BossAdministratorSession,
5858		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
5859
5860		static swig_const_info swig_const_table[] = {
5861	+	{ SWIG_PY_INT,     (char *)"RUNNING", (long) RUNNING, 0, 0, 0},
5862	+	{ SWIG_PY_INT,     (char *)"SCHEDULED", (long) SCHEDULED, 0, 0, 0},
5863	+	{ SWIG_PY_INT,     (char *)"SUBMITTED", (long) SUBMITTED, 0, 0, 0},
5864	+	{ SWIG_PY_INT,     (char *)"ALL", (long) ALL, 0, 0, 0},
5865	+	{ SWIG_PY_INT,     (char *)"STATUS_ONLY", (long) STATUS_ONLY, 0, 0, 0},
5866	+	{ SWIG_PY_INT,     (char *)"NORMAL", (long) NORMAL, 0, 0, 0},
5867	+	{ SWIG_PY_INT,     (char *)"SPECIFIC", (long) SPECIFIC, 0, 0, 0},
5868	+	{ SWIG_PY_INT,     (char *)"PROGRAMS", (long) PROGRAMS, 0, 0, 0},
5869	+	{ SWIG_PY_INT,     (char *)"FULL", (long) FULL, 0, 0, 0},
5870		{0}};
5871
5872		#ifdef __cplusplus

Diff Legend

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