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.18 by gcodispo, Mon Dec 11 09:16:06 2006 UTC

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

Diff Legend

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