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.11 by gcodispo, Mon Oct 30 14:00:27 2006 UTC

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

Diff Legend

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