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

Diff Legend

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