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

Diff Legend

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