ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/COMP/BOSS/BossPython/BossSession_wrap.cxx

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

Diff Legend

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