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.27 by gcodispo, Thu Mar 8 17:52:39 2007 UTC vs.
Revision 1.35 by gcodispo, Mon Jul 2 09:40:39 2007 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_XMLDoc swig_types[0]
658	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
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_std__vectorTBossTask_p_t swig_types[3]
661	<	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662	<	#define  SWIGTYPE_p_std__ostream swig_types[5]
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_printOption swig_types[8]
666	<	#define  SWIGTYPE_p_BossAttributeContainer swig_types[9]
667	<	#define  SWIGTYPE_p_BossJob swig_types[10]
668	<	#define  SWIGTYPE_p_BossDatabase swig_types[11]
669	<	#define  SWIGTYPE_p_BossSession swig_types[12]
670	<	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671	<	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672	<	#define  SWIGTYPE_p_BossAdministratorSession swig_types[15]
673	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[17]
675	<	#define  SWIGTYPE_p_jobStates swig_types[18]
676	<	static swig_type_info *swig_types[20];
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 923 | Line 926 | static PyObject * SchedulerError;
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"
#	Line 957 | Line 961 | PyObject *BossSession_schedulers(BossSes
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,bool keepfile){
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,
963	–	keepfile,
967		taskid,
968		jobid,
969		timeout);
970		return BossSession_show( self, my_vec );
971		}
972	<	PyObject *BossSession_queryTasks(BossSession *self,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
973	<	PyObject * task_list = PyList_New(0);
974	<	std::vector <std::string> taskList;
972	<	if ( taskName.empty() ) {
973	<	taskList = self->selectTasks( taskRange, before, after, user);
974	<	} else {
975	<	taskList = self->selectTasksByName( taskName );
976	<	}
977	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
978	<	it!= taskList.end(); ++it ) {
979	<	PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
980	<	}
981	<	return  task_list;
972	>	void BossSession_schedulerQuery(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,unsigned int timeout,bool avoidCheck){
973	>	self->query ( filter_opt, taskRange, jobRange, subn, type, user, after, before, timeout, avoidCheck );
974	>	return;
975		}
976		void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
977		std::string tmp;
#	Line 994 | Line 987 | void BossTask_appendToPyDict(BossTask co
987		}
988		return;
989		}
990	<	void BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit,PyObject *job_dict){
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 = (*jit)->getTableEntries("JOB");
995	>	BossAttributeContainer obj = jobH->getTableEntries("JOB");
996		BossTask_appendToPyDict ( self, job_dict, obj );
997
998	<	std::set<std::string> sch = (*jit)->getSchedulerElements();
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 = (**jit)["JOB_SCHED_INFO."+(*it)];
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);
#	Line 1024 | Line 1017 | PyObject *BossTask_jobsDict(BossTask *se
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 );
1020	>	BossTask_jobDict( self, *jit, tmp_dict );
1021		PyDict_SetItem( job_dict, id, tmp_dict );
1022		Py_DECREF(id);
1023		Py_DECREF(tmp_dict);
1024		}
1025		return job_dict;
1026		}
1027	+	PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1028	+	PyObject * job_dict = PyDict_New();
1029	+	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1030	+	return job_dict;
1031	+	}
1032	+	PyObject *BossTask_Chain(BossTask *self,std::string const &jobid){
1033	+
1034	+	PyObject * chain_dict = PyDict_New();
1035	+	BossAttributeContainer obj =
1036	+	self->chain( jobid ).getTableEntries("CHAIN");
1037	+	BossTask_appendToPyDict ( self, chain_dict, obj );
1038	+	return chain_dict;
1039	+	}
1040	+	PyObject *BossTask_jobStates(BossTask *self){
1041	+
1042	+	PyObject * job_dict = PyDict_New();
1043	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1044	+	for (BossTask::job_iterator jit = self->job_begin ();
1045	+	jit != self->job_end (); ++jit) {
1046	+	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1047	+	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1048	+	PyDict_SetItem( job_dict, id, status );
1049	+	Py_DECREF(id);
1050	+	Py_DECREF(status);
1051	+	}
1052	+	return job_dict;
1053	+	}
1054	+	PyObject *BossTask_joblist(BossTask *self){
1055	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1056	+	PyObject *  job_list = PyList_New( self->jobsInMemory() );
1057	+	unsigned int index = 0;
1058	+	for (BossTask::job_iterator jit = self->job_begin ();
1059	+	jit != self->job_end (); ++jit, ++index) {
1060	+	PyList_SetItem( job_list,
1061	+	index,
1062	+	PyString_FromString( ( (*jit)->chainId() ).c_str() )
1063	+	);
1064	+	}
1065	+	return job_list;
1066	+	}
1067	+	PyObject *BossTask_jobStatistic(BossTask *self){
1068	+
1069	+	PyObject * job_dict = PyDict_New();
1070	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1071	+	std::map< std::string, int > states;
1072	+	for (BossTask::job_iterator jit = self->job_begin ();
1073	+	jit != self->job_end (); ++jit) {
1074	+	++states[(**jit)["JOB.STATUS"]];
1075	+	}
1076	+
1077	+	std::map< std::string, int >::const_iterator end = states.end ();
1078	+	for (std::map< std::string, int >::const_iterator it = states.begin ();
1079	+	it != end; ++it) {
1080	+	PyObject * status = PyString_FromString( (it->first).c_str() );
1081	+	PyObject * jobs = PyString_FromFormat( "%d", it->second );
1082	+	PyDict_SetItem( job_dict, status, jobs );
1083	+	Py_DECREF(jobs);
1084	+	Py_DECREF(status);
1085	+	}
1086	+	return job_dict;
1087	+	}
1088		PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator &programs_it){
1089
1090		PyObject * job_dict = PyDict_New();
#	Line 1080 | Line 1134 | PyObject *BossTask_jobPrograms(BossTask
1134		}
1135		return job_dict;
1136		}
1137	+	PyObject *BossTask_program(BossTask *self,std::string const &jobid,std::string const &programId){
1138	+
1139	+	PyObject * job_dict = PyDict_New();
1140	+
1141	+	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1142	+	BossAttributeContainer obj =
1143	+	self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1144	+	BossTask_appendToPyDict ( self, job_dict, obj );
1145	+	return job_dict;
1146	+	}
1147	+	PyObject *BossTask_programExec(BossTask *self,std::string const &jobid,std::string const &programId){
1148	+
1149	+	PyObject * job_dict = PyDict_New();
1150	+
1151	+	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1152	+
1153	+	// PROGRAM_EXEC
1154	+	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1155	+	BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1156	+	BossTask_appendToPyDict ( self, job_dict, obj );
1157	+
1158	+	// SPECIFICS
1159	+	std::vector < BossAttributeContainer >::const_iterator it;
1160	+	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1161	+	for ( it = programExec.specBegin (); it != it_end; ++it) {
1162	+	BossTask_appendToPyDict ( self, job_dict, *it );
1163	+	}
1164	+	return job_dict;
1165	+	}
1166	+	PyObject *BossTask_specific(BossTask *self,std::string const &jobid,std::string const &programId){
1167	+
1168	+	PyObject * job_dict = PyDict_New();
1169	+
1170	+	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1171	+	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1172	+	BossAttributeContainer obj = programExec.getKeys ();
1173	+	BossTask_appendToPyDict ( self, job_dict, obj );
1174	+
1175	+	std::vector < BossAttributeContainer >::const_iterator it;
1176	+	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1177	+	for ( it = programExec.specBegin (); it != it_end; ++it) {
1178	+	BossTask_appendToPyDict ( self, job_dict, *it );
1179	+	}
1180	+	return job_dict;
1181	+	}
1182		#ifdef __cplusplus
1183		extern "C" {
1184		#endif
#	Line 2431 | Line 2530 | static PyObject *_wrap_BossSession_clear
2530		}
2531
2532
2533	+	static PyObject *_wrap_BossSession_task_begin(PyObject *self, PyObject *args) {
2534	+	PyObject *resultobj;
2535	+	BossSession *arg1 = (BossSession *) 0 ;
2536	+	BossSession::task_iterator result;
2537	+	PyObject * obj0 = 0 ;
2538	+
2539	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_begin",&obj0)) goto fail;
2540	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2541	+	{
2542	+	try {
2543	+	result = ((BossSession const *)arg1)->task_begin();
2544	+
2545	+	}catch (const BossSchedFailure & e) {
2546	+	PyErr_SetString ( SchedulerError, e.what() );
2547	+	return NULL;
2548	+	}catch (const std::exception& e) {
2549	+	PyErr_SetString ( BossError, e.what() );
2550	+	return NULL;
2551	+	}
2552	+	}
2553	+	{
2554	+	BossSession::task_iterator * resultptr;
2555	+	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2556	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2557	+	}
2558	+	return resultobj;
2559	+	fail:
2560	+	return NULL;
2561	+	}
2562	+
2563	+
2564	+	static PyObject *_wrap_BossSession_task_end(PyObject *self, PyObject *args) {
2565	+	PyObject *resultobj;
2566	+	BossSession *arg1 = (BossSession *) 0 ;
2567	+	BossSession::task_iterator result;
2568	+	PyObject * obj0 = 0 ;
2569	+
2570	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_end",&obj0)) goto fail;
2571	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2572	+	{
2573	+	try {
2574	+	result = ((BossSession const *)arg1)->task_end();
2575	+
2576	+	}catch (const BossSchedFailure & e) {
2577	+	PyErr_SetString ( SchedulerError, e.what() );
2578	+	return NULL;
2579	+	}catch (const std::exception& e) {
2580	+	PyErr_SetString ( BossError, e.what() );
2581	+	return NULL;
2582	+	}
2583	+	}
2584	+	{
2585	+	BossSession::task_iterator * resultptr;
2586	+	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2587	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2588	+	}
2589	+	return resultobj;
2590	+	fail:
2591	+	return NULL;
2592	+	}
2593	+
2594	+
2595	+	static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
2596	+	PyObject *resultobj;
2597	+	BossSession *arg1 = (BossSession *) 0 ;
2598	+	unsigned int result;
2599	+	PyObject * obj0 = 0 ;
2600	+
2601	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
2602	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2603	+	{
2604	+	try {
2605	+	result = (unsigned int)((BossSession const *)arg1)->tasksInMemory();
2606	+
2607	+	}catch (const BossSchedFailure & e) {
2608	+	PyErr_SetString ( SchedulerError, e.what() );
2609	+	return NULL;
2610	+	}catch (const std::exception& e) {
2611	+	PyErr_SetString ( BossError, e.what() );
2612	+	return NULL;
2613	+	}
2614	+	}
2615	+	resultobj = PyInt_FromLong((long)result);
2616	+	return resultobj;
2617	+	fail:
2618	+	return NULL;
2619	+	}
2620	+
2621	+
2622	+	static PyObject *_wrap_BossSession_locate(PyObject *self, PyObject *args) {
2623	+	PyObject *resultobj;
2624	+	BossSession *arg1 = (BossSession *) 0 ;
2625	+	unsigned int arg2 ;
2626	+	BossTask *result;
2627	+	PyObject * obj0 = 0 ;
2628	+	PyObject * obj1 = 0 ;
2629	+
2630	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
2631	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2632	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
2633	+	if (PyErr_Occurred()) SWIG_fail;
2634	+	{
2635	+	try {
2636	+	result = (BossTask *)((BossSession const *)arg1)->locate(arg2);
2637	+
2638	+	}catch (const BossSchedFailure & e) {
2639	+	PyErr_SetString ( SchedulerError, e.what() );
2640	+	return NULL;
2641	+	}catch (const std::exception& e) {
2642	+	PyErr_SetString ( BossError, e.what() );
2643	+	return NULL;
2644	+	}
2645	+	}
2646	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2647	+	return resultobj;
2648	+	fail:
2649	+	return NULL;
2650	+	}
2651	+
2652	+
2653		static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2654		PyObject *resultobj;
2655		BossSession *arg1 = (BossSession *) 0 ;
#	Line 2898 | Line 3117 | static PyObject *_wrap_BossSession_listM
3117		BossSession *arg1 = (BossSession *) 0 ;
3118		std::string *arg2 = 0 ;
3119		std::string *arg3 = 0 ;
3120	<	bool arg4 = (bool) false ;
3120	>	std::string const &arg4_defvalue = "" ;
3121	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3122		std::string const &arg5_defvalue = "" ;
3123		std::string *arg5 = (std::string *) &arg5_defvalue ;
3124	<	std::string const &arg6_defvalue = "" ;
2905	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
2906	<	unsigned int arg7 = (unsigned int) 0 ;
3124	>	unsigned int arg6 = (unsigned int) 0 ;
3125		std::vector<std::string > result;
3126		std::string temp2 ;
3127		std::string temp3 ;
3128	+	std::string temp4 ;
3129		std::string temp5 ;
2911	–	std::string temp6 ;
3130		PyObject * obj0 = 0 ;
3131		PyObject * obj1 = 0 ;
3132		PyObject * obj2 = 0 ;
3133		PyObject * obj3 = 0 ;
3134		PyObject * obj4 = 0 ;
3135		PyObject * obj5 = 0 ;
2918	–	PyObject * obj6 = 0 ;
3136
3137	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3137	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3138		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3139		{
3140		if (PyString_Check(obj1)) {
#	Line 2936 | Line 3153 | static PyObject *_wrap_BossSession_listM
3153		}
3154		}
3155		if (obj3) {
2939	–	arg4 = PyInt_AsLong(obj3) ? true : false;
2940	–	if (PyErr_Occurred()) SWIG_fail;
2941	–	}
2942	–	if (obj4) {
3156		{
3157	<	if (PyString_Check(obj4)) {
3158	<	temp5 = std::string(PyString_AsString(obj4));
3159	<	arg5 = &temp5;
3157	>	if (PyString_Check(obj3)) {
3158	>	temp4 = std::string(PyString_AsString(obj3));
3159	>	arg4 = &temp4;
3160		}else {
3161		SWIG_exception(SWIG_TypeError, "string expected");
3162		}
3163		}
3164		}
3165	<	if (obj5) {
3165	>	if (obj4) {
3166		{
3167	<	if (PyString_Check(obj5)) {
3168	<	temp6 = std::string(PyString_AsString(obj5));
3169	<	arg6 = &temp6;
3167	>	if (PyString_Check(obj4)) {
3168	>	temp5 = std::string(PyString_AsString(obj4));
3169	>	arg5 = &temp5;
3170		}else {
3171		SWIG_exception(SWIG_TypeError, "string expected");
3172		}
3173		}
3174		}
3175	<	if (obj6) {
3176	<	arg7 = (unsigned int) PyInt_AsLong(obj6);
3175	>	if (obj5) {
3176	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3177		if (PyErr_Occurred()) SWIG_fail;
3178		}
3179		{
3180		try {
3181	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
3181	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3182
3183		}catch (const BossSchedFailure & e) {
3184		PyErr_SetString ( SchedulerError, e.what() );
#	Line 2987 | Line 3200 | static PyObject *_wrap_BossSession_listM
3200		}
3201
3202
3203	<	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3203	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3204		PyObject *resultobj;
3205		BossSession *arg1 = (BossSession *) 0 ;
3206		int arg2 = (int) SCHEDULED ;
#	Line 3002 | Line 3215 | static PyObject *_wrap_BossSession_sched
3215		std::string arg8 = (std::string) "" ;
3216		std::string arg9 = (std::string) "" ;
3217		unsigned int arg10 = (unsigned int) 0 ;
3218	+	bool arg11 = (bool) false ;
3219		std::string temp3 ;
3220		std::string temp4 ;
3221		std::string temp5 ;
#	Line 3014 | Line 3228 | static PyObject *_wrap_BossSession_sched
3228		PyObject * obj7 = 0 ;
3229		PyObject * obj8 = 0 ;
3230		PyObject * obj9 = 0 ;
3231	+	PyObject * obj10 = 0 ;
3232
3233	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3233	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3234		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3235		if (obj2) {
3236		{
#	Line 3083 | Line 3298 | static PyObject *_wrap_BossSession_sched
3298		arg10 = (unsigned int) PyInt_AsLong(obj9);
3299		if (PyErr_Occurred()) SWIG_fail;
3300		}
3301	+	if (obj10) {
3302	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3303	+	if (PyErr_Occurred()) SWIG_fail;
3304	+	}
3305		{
3306		try {
3307	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3307	>	(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3308
3309		}catch (const BossSchedFailure & e) {
3310		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3102 | Line 3321 | static PyObject *_wrap_BossSession_sched
3321		}
3322
3323
3324	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3324	>	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3325		PyObject *resultobj;
3326		BossSession *arg1 = (BossSession *) 0 ;
3327	<	std::string const &arg2_defvalue = "all" ;
3109	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3110	<	std::string const &arg3_defvalue = "" ;
3111	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3112	<	std::string const &arg4_defvalue = "" ;
3113	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3114	<	std::string const &arg5_defvalue = "" ;
3115	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3116	<	std::vector<std::string > result;
3327	>	std::string *arg2 = 0 ;
3328		std::string temp2 ;
3118	–	std::string temp3 ;
3119	–	std::string temp4 ;
3120	–	std::string temp5 ;
3329		PyObject * obj0 = 0 ;
3330		PyObject * obj1 = 0 ;
3123	–	PyObject * obj2 = 0 ;
3124	–	PyObject * obj3 = 0 ;
3125	–	PyObject * obj4 = 0 ;
3331
3332	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
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	<	if (obj1) {
3335	<	{
3336	<	if (PyString_Check(obj1)) {
3337	<	temp2 = std::string(PyString_AsString(obj1));
3338	<	arg2 = &temp2;
3339	<	}else {
3135	<	SWIG_exception(SWIG_TypeError, "string expected");
3136	<	}
3137	<	}
3138	<	}
3139	<	if (obj2) {
3140	<	{
3141	<	if (PyString_Check(obj2)) {
3142	<	temp3 = std::string(PyString_AsString(obj2));
3143	<	arg3 = &temp3;
3144	<	}else {
3145	<	SWIG_exception(SWIG_TypeError, "string expected");
3146	<	}
3147	<	}
3148	<	}
3149	<	if (obj3) {
3150	<	{
3151	<	if (PyString_Check(obj3)) {
3152	<	temp4 = std::string(PyString_AsString(obj3));
3153	<	arg4 = &temp4;
3154	<	}else {
3155	<	SWIG_exception(SWIG_TypeError, "string expected");
3156	<	}
3157	<	}
3158	<	}
3159	<	if (obj4) {
3160	<	{
3161	<	if (PyString_Check(obj4)) {
3162	<	temp5 = std::string(PyString_AsString(obj4));
3163	<	arg5 = &temp5;
3164	<	}else {
3165	<	SWIG_exception(SWIG_TypeError, "string expected");
3166	<	}
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		{
3343		try {
3344	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3344	>	(arg1)->getTasksByName((std::string const &)*arg2);
3345
3346		}catch (const BossSchedFailure & e) {
3347		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3178 | Line 3351 | static PyObject *_wrap_BossSession_selec
3351		return NULL;
3352		}
3353		}
3354	<	{
3182	<	resultobj = PyTuple_New((&result)->size());
3183	<	for (unsigned int i=0; i<(&result)->size(); i++)
3184	<	PyTuple_SetItem(resultobj,i,
3185	<	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3186	<	}
3354	>	Py_INCREF(Py_None); resultobj = Py_None;
3355		return resultobj;
3356		fail:
3357		return NULL;
3358		}
3359
3360
3361	<	static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
3361	>	static PyObject *_wrap_BossSession_getTasksByTaskInfo(PyObject *self, PyObject *args) {
3362		PyObject *resultobj;
3363		BossSession *arg1 = (BossSession *) 0 ;
3364		std::string *arg2 = 0 ;
3197	–	std::vector<std::string > result;
3365		std::string temp2 ;
3366		PyObject * obj0 = 0 ;
3367		PyObject * obj1 = 0 ;
3368
3369	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3369	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByTaskInfo",&obj0,&obj1)) goto fail;
3370		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3371		{
3372		if (PyString_Check(obj1)) {
#	Line 3211 | Line 3378 | static PyObject *_wrap_BossSession_selec
3378		}
3379		{
3380		try {
3381	<	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3381	>	(arg1)->getTasksByTaskInfo((std::string const &)*arg2);
3382
3383		}catch (const BossSchedFailure & e) {
3384		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3221 | Line 3388 | static PyObject *_wrap_BossSession_selec
3388		return NULL;
3389		}
3390		}
3391	<	{
3225	<	resultobj = PyTuple_New((&result)->size());
3226	<	for (unsigned int i=0; i<(&result)->size(); i++)
3227	<	PyTuple_SetItem(resultobj,i,
3228	<	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3229	<	}
3230	<	return resultobj;
3231	<	fail:
3232	<	return NULL;
3233	<	}
3234	<
3235	<
3236	<	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3237	<	PyObject *resultobj;
3238	<	BossSession *arg1 = (BossSession *) 0 ;
3239	<	int arg2 = (int) SCHEDULED ;
3240	<	std::string const &arg3_defvalue = "all" ;
3241	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3242	<	std::string const &arg4_defvalue = "all" ;
3243	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3244	<	std::string const &arg5_defvalue = "" ;
3245	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3246	<	std::string arg6 = (std::string) "" ;
3247	<	std::string arg7 = (std::string) "" ;
3248	<	std::string arg8 = (std::string) "" ;
3249	<	std::string arg9 = (std::string) "" ;
3250	<	unsigned int arg10 = (unsigned int) 0 ;
3251	<	bool arg11 = (bool) false ;
3252	<	SwigValueWrapper< std::vector<BossTask * > > result;
3253	<	std::string temp3 ;
3254	<	std::string temp4 ;
3255	<	std::string temp5 ;
3256	<	PyObject * obj0 = 0 ;
3257	<	PyObject * obj2 = 0 ;
3258	<	PyObject * obj3 = 0 ;
3259	<	PyObject * obj4 = 0 ;
3260	<	PyObject * obj5 = 0 ;
3261	<	PyObject * obj6 = 0 ;
3262	<	PyObject * obj7 = 0 ;
3263	<	PyObject * obj8 = 0 ;
3264	<	PyObject * obj9 = 0 ;
3265	<	PyObject * obj10 = 0 ;
3266	<
3267	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3268	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3269	<	if (obj2) {
3270	<	{
3271	<	if (PyString_Check(obj2)) {
3272	<	temp3 = std::string(PyString_AsString(obj2));
3273	<	arg3 = &temp3;
3274	<	}else {
3275	<	SWIG_exception(SWIG_TypeError, "string expected");
3276	<	}
3277	<	}
3278	<	}
3279	<	if (obj3) {
3280	<	{
3281	<	if (PyString_Check(obj3)) {
3282	<	temp4 = std::string(PyString_AsString(obj3));
3283	<	arg4 = &temp4;
3284	<	}else {
3285	<	SWIG_exception(SWIG_TypeError, "string expected");
3286	<	}
3287	<	}
3288	<	}
3289	<	if (obj4) {
3290	<	{
3291	<	if (PyString_Check(obj4)) {
3292	<	temp5 = std::string(PyString_AsString(obj4));
3293	<	arg5 = &temp5;
3294	<	}else {
3295	<	SWIG_exception(SWIG_TypeError, "string expected");
3296	<	}
3297	<	}
3298	<	}
3299	<	if (obj5) {
3300	<	{
3301	<	if (PyString_Check(obj5))
3302	<	arg6 = std::string(PyString_AsString(obj5));
3303	<	else
3304	<	SWIG_exception(SWIG_TypeError, "string expected");
3305	<	}
3306	<	}
3307	<	if (obj6) {
3308	<	{
3309	<	if (PyString_Check(obj6))
3310	<	arg7 = std::string(PyString_AsString(obj6));
3311	<	else
3312	<	SWIG_exception(SWIG_TypeError, "string expected");
3313	<	}
3314	<	}
3315	<	if (obj7) {
3316	<	{
3317	<	if (PyString_Check(obj7))
3318	<	arg8 = std::string(PyString_AsString(obj7));
3319	<	else
3320	<	SWIG_exception(SWIG_TypeError, "string expected");
3321	<	}
3322	<	}
3323	<	if (obj8) {
3324	<	{
3325	<	if (PyString_Check(obj8))
3326	<	arg9 = std::string(PyString_AsString(obj8));
3327	<	else
3328	<	SWIG_exception(SWIG_TypeError, "string expected");
3329	<	}
3330	<	}
3331	<	if (obj9) {
3332	<	arg10 = (unsigned int) PyInt_AsLong(obj9);
3333	<	if (PyErr_Occurred()) SWIG_fail;
3334	<	}
3335	<	if (obj10) {
3336	<	arg11 = PyInt_AsLong(obj10) ? true : false;
3337	<	if (PyErr_Occurred()) SWIG_fail;
3338	<	}
3339	<	{
3340	<	try {
3341	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3342	<
3343	<	}catch (const BossSchedFailure & e) {
3344	<	PyErr_SetString ( SchedulerError, e.what() );
3345	<	return NULL;
3346	<	}catch (const std::exception& e) {
3347	<	PyErr_SetString ( BossError, e.what() );
3348	<	return NULL;
3349	<	}
3350	<	}
3351	<	{
3352	<	std::vector<BossTask * > * resultptr;
3353	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3354	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3355	<	}
3391	>	Py_INCREF(Py_None); resultobj = Py_None;
3392		return resultobj;
3393		fail:
3394		return NULL;
3395		}
3396
3397
3398	<	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3398	>	static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3399		PyObject *resultobj;
3400		BossSession *arg1 = (BossSession *) 0 ;
3401		std::string *arg2 = 0 ;
3366	–	SwigValueWrapper< std::vector<BossTask * > > result;
3402		std::string temp2 ;
3403		PyObject * obj0 = 0 ;
3404		PyObject * obj1 = 0 ;
3405
3406	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3406	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3407		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3408		{
3409		if (PyString_Check(obj1)) {
#	Line 3380 | Line 3415 | static PyObject *_wrap_BossSession_getTa
3415		}
3416		{
3417		try {
3418	<	result = (arg1)->getTasksByName((std::string const &)*arg2);
3418	>	(arg1)->getTasksByJobName((std::string const &)*arg2);
3419
3420		}catch (const BossSchedFailure & e) {
3421		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3390 | Line 3425 | static PyObject *_wrap_BossSession_getTa
3425		return NULL;
3426		}
3427		}
3428	<	{
3394	<	std::vector<BossTask * > * resultptr;
3395	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3396	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3397	<	}
3428	>	Py_INCREF(Py_None); resultobj = Py_None;
3429		return resultobj;
3430		fail:
3431		return NULL;
#	Line 3552 | Line 3583 | static PyObject *_wrap_BossSession_sched
3583		std::string const &arg5_defvalue = "" ;
3584		std::string *arg5 = (std::string *) &arg5_defvalue ;
3585		unsigned int arg6 = (unsigned int) 0 ;
3555	–	bool arg7 = (bool) false ;
3586		PyObject *result;
3587		std::string temp2 ;
3588		std::string temp3 ;
#	Line 3564 | Line 3594 | static PyObject *_wrap_BossSession_sched
3594		PyObject * obj3 = 0 ;
3595		PyObject * obj4 = 0 ;
3596		PyObject * obj5 = 0 ;
3567	–	PyObject * obj6 = 0 ;
3597
3598	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3598	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3599		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3600		{
3601		if (PyString_Check(obj1)) {
#	Line 3608 | Line 3637 | static PyObject *_wrap_BossSession_sched
3637		arg6 = (unsigned int) PyInt_AsLong(obj5);
3638		if (PyErr_Occurred()) SWIG_fail;
3639		}
3611	–	if (obj6) {
3612	–	arg7 = PyInt_AsLong(obj6) ? true : false;
3613	–	if (PyErr_Occurred()) SWIG_fail;
3614	–	}
3640		{
3641		try {
3642	<	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3642	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3643
3644		}catch (const BossSchedFailure & e) {
3645		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3631 | Line 3656 | static PyObject *_wrap_BossSession_sched
3656		}
3657
3658
3659	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3659	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3660		PyObject *resultobj;
3661		BossSession *arg1 = (BossSession *) 0 ;
3662	<	std::string const &arg2_defvalue = "" ;
3638	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3662	>	int arg2 = (int) SCHEDULED ;
3663		std::string const &arg3_defvalue = "all" ;
3664		std::string *arg3 = (std::string *) &arg3_defvalue ;
3665	<	std::string arg4 = (std::string) "" ;
3666	<	std::string arg5 = (std::string) "" ;
3665	>	std::string const &arg4_defvalue = "all" ;
3666	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3667	>	std::string const &arg5_defvalue = "" ;
3668	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3669		std::string arg6 = (std::string) "" ;
3670	<	PyObject *result;
3671	<	std::string temp2 ;
3670	>	std::string arg7 = (std::string) "" ;
3671	>	std::string arg8 = (std::string) "" ;
3672	>	std::string arg9 = (std::string) "" ;
3673	>	unsigned int arg10 = (unsigned int) 0 ;
3674	>	bool arg11 = (bool) false ;
3675		std::string temp3 ;
3676	+	std::string temp4 ;
3677	+	std::string temp5 ;
3678		PyObject * obj0 = 0 ;
3648	–	PyObject * obj1 = 0 ;
3679		PyObject * obj2 = 0 ;
3680		PyObject * obj3 = 0 ;
3681		PyObject * obj4 = 0 ;
3682		PyObject * obj5 = 0 ;
3683	+	PyObject * obj6 = 0 ;
3684	+	PyObject * obj7 = 0 ;
3685	+	PyObject * obj8 = 0 ;
3686	+	PyObject * obj9 = 0 ;
3687	+	PyObject * obj10 = 0 ;
3688
3689	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3689	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3690		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3691	<	if (obj1) {
3691	>	if (obj2) {
3692		{
3693	<	if (PyString_Check(obj1)) {
3694	<	temp2 = std::string(PyString_AsString(obj1));
3695	<	arg2 = &temp2;
3693	>	if (PyString_Check(obj2)) {
3694	>	temp3 = std::string(PyString_AsString(obj2));
3695	>	arg3 = &temp3;
3696		}else {
3697		SWIG_exception(SWIG_TypeError, "string expected");
3698		}
3699		}
3700		}
3701	<	if (obj2) {
3701	>	if (obj3) {
3702		{
3703	<	if (PyString_Check(obj2)) {
3704	<	temp3 = std::string(PyString_AsString(obj2));
3705	<	arg3 = &temp3;
3703	>	if (PyString_Check(obj3)) {
3704	>	temp4 = std::string(PyString_AsString(obj3));
3705	>	arg4 = &temp4;
3706		}else {
3707		SWIG_exception(SWIG_TypeError, "string expected");
3708		}
3709		}
3710		}
3711	<	if (obj3) {
3711	>	if (obj4) {
3712		{
3713	<	if (PyString_Check(obj3))
3714	<	arg4 = std::string(PyString_AsString(obj3));
3713	>	if (PyString_Check(obj4)) {
3714	>	temp5 = std::string(PyString_AsString(obj4));
3715	>	arg5 = &temp5;
3716	>	}else {
3717	>	SWIG_exception(SWIG_TypeError, "string expected");
3718	>	}
3719	>	}
3720	>	}
3721	>	if (obj5) {
3722	>	{
3723	>	if (PyString_Check(obj5))
3724	>	arg6 = std::string(PyString_AsString(obj5));
3725		else
3726		SWIG_exception(SWIG_TypeError, "string expected");
3727		}
3728		}
3729	<	if (obj4) {
3729	>	if (obj6) {
3730		{
3731	<	if (PyString_Check(obj4))
3732	<	arg5 = std::string(PyString_AsString(obj4));
3731	>	if (PyString_Check(obj6))
3732	>	arg7 = std::string(PyString_AsString(obj6));
3733		else
3734		SWIG_exception(SWIG_TypeError, "string expected");
3735		}
3736		}
3737	<	if (obj5) {
3737	>	if (obj7) {
3738		{
3739	<	if (PyString_Check(obj5))
3740	<	arg6 = std::string(PyString_AsString(obj5));
3739	>	if (PyString_Check(obj7))
3740	>	arg8 = std::string(PyString_AsString(obj7));
3741		else
3742		SWIG_exception(SWIG_TypeError, "string expected");
3743		}
3744		}
3745	+	if (obj8) {
3746	+	{
3747	+	if (PyString_Check(obj8))
3748	+	arg9 = std::string(PyString_AsString(obj8));
3749	+	else
3750	+	SWIG_exception(SWIG_TypeError, "string expected");
3751	+	}
3752	+	}
3753	+	if (obj9) {
3754	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3755	+	if (PyErr_Occurred()) SWIG_fail;
3756	+	}
3757	+	if (obj10) {
3758	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3759	+	if (PyErr_Occurred()) SWIG_fail;
3760	+	}
3761		{
3762		try {
3763	<	result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3763	>	BossSession_schedulerQuery(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3764
3765		}catch (const BossSchedFailure & e) {
3766		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3709 | Line 3770 | static PyObject *_wrap_BossSession_query
3770		return NULL;
3771		}
3772		}
3773	<	resultobj = result;
3773	>	Py_INCREF(Py_None); resultobj = Py_None;
3774		return resultobj;
3775		fail:
3776		return NULL;
#	Line 3723 | Line 3784 | static PyObject * BossSession_swigregist
3784		Py_INCREF(obj);
3785		return Py_BuildValue((char *)"");
3786		}
3787	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3787	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3788	>	PyObject *resultobj;
3789	>	char *arg1 ;
3790	>	BossTaskException *result;
3791	>
3792	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3793	>	{
3794	>	try {
3795	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3796	>
3797	>	}catch (const BossSchedFailure & e) {
3798	>	PyErr_SetString ( SchedulerError, e.what() );
3799	>	return NULL;
3800	>	}catch (const std::exception& e) {
3801	>	PyErr_SetString ( BossError, e.what() );
3802	>	return NULL;
3803	>	}
3804	>	}
3805	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3806	>	return resultobj;
3807	>	fail:
3808	>	return NULL;
3809	>	}
3810	>
3811	>
3812	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3813		PyObject *resultobj;
3814		BossTaskException *arg1 = (BossTaskException *) 0 ;
3729	–	char *arg2 ;
3815		PyObject * obj0 = 0 ;
3816
3817	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3817	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3818		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3819		{
3820	<	if (arg2) {
3821	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3822	<	strcpy((char *) arg1->key,arg2);
3823	<	}else {
3824	<	arg1->key = 0;
3820	>	try {
3821	>	delete arg1;
3822	>
3823	>	}catch (const BossSchedFailure & e) {
3824	>	PyErr_SetString ( SchedulerError, e.what() );
3825	>	return NULL;
3826	>	}catch (const std::exception& e) {
3827	>	PyErr_SetString ( BossError, e.what() );
3828	>	return NULL;
3829		}
3830		}
3831		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3746 | Line 3835 | static PyObject *_wrap_BossTaskException
3835		}
3836
3837
3838	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3838	>	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3839	>	PyObject *obj;
3840	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3841	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3842	>	Py_INCREF(obj);
3843	>	return Py_BuildValue((char *)"");
3844	>	}
3845	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3846		PyObject *resultobj;
3847	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3848	<	char *result;
3847	>	BossTask *arg1 = (BossTask *) 0 ;
3848	>	BossTask::job_iterator result;
3849		PyObject * obj0 = 0 ;
3850
3851	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3852	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3853	<	result = (char *) ((arg1)->key);
3851	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3852	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3853	>	{
3854	>	try {
3855	>	result = ((BossTask const *)arg1)->job_begin();
3856	>
3857	>	}catch (const BossSchedFailure & e) {
3858	>	PyErr_SetString ( SchedulerError, e.what() );
3859	>	return NULL;
3860	>	}catch (const std::exception& e) {
3861	>	PyErr_SetString ( BossError, e.what() );
3862	>	return NULL;
3863	>	}
3864	>	}
3865	>	{
3866	>	BossTask::job_iterator * resultptr;
3867	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3868	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3869	>	}
3870	>	return resultobj;
3871	>	fail:
3872	>	return NULL;
3873	>	}
3874	>
3875	>
3876	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3877	>	PyObject *resultobj;
3878	>	BossTask *arg1 = (BossTask *) 0 ;
3879	>	BossTask::job_iterator result;
3880	>	PyObject * obj0 = 0 ;
3881
3882	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3882	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3883	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3884	>	{
3885	>	try {
3886	>	result = ((BossTask const *)arg1)->job_end();
3887	>
3888	>	}catch (const BossSchedFailure & e) {
3889	>	PyErr_SetString ( SchedulerError, e.what() );
3890	>	return NULL;
3891	>	}catch (const std::exception& e) {
3892	>	PyErr_SetString ( BossError, e.what() );
3893	>	return NULL;
3894	>	}
3895	>	}
3896	>	{
3897	>	BossTask::job_iterator * resultptr;
3898	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3899	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3900	>	}
3901		return resultobj;
3902		fail:
3903		return NULL;
3904		}
3905
3906
3907	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3907	>	static PyObject *_wrap_BossTask_jobsInMemory(PyObject *self, PyObject *args) {
3908		PyObject *resultobj;
3909	<	char *arg1 ;
3910	<	BossTaskException *result;
3909	>	BossTask *arg1 = (BossTask *) 0 ;
3910	>	unsigned int result;
3911	>	PyObject * obj0 = 0 ;
3912
3913	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3913	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsInMemory",&obj0)) goto fail;
3914	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3915		{
3916		try {
3917	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3917	>	result = (unsigned int)((BossTask const *)arg1)->jobsInMemory();
3918
3919		}catch (const BossSchedFailure & e) {
3920		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3781 | Line 3924 | static PyObject *_wrap_new_BossTaskExcep
3924		return NULL;
3925		}
3926		}
3927	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3927	>	resultobj = PyInt_FromLong((long)result);
3928		return resultobj;
3929		fail:
3930		return NULL;
3931		}
3932
3933
3934	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3934	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3935		PyObject *resultobj;
3936	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3937	<	char *result;
3936	>	BossTask *arg1 = (BossTask *) 0 ;
3937	>	BossJob *arg2 = (BossJob *) 0 ;
3938	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3939		PyObject * obj0 = 0 ;
3940	+	PyObject * obj1 = 0 ;
3941
3942	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3943	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3942	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3943	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3944	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3945		{
3946		try {
3947	<	result = (char *)((BossTaskException const *)arg1)->what();
3947	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
3948
3949		}catch (const BossSchedFailure & e) {
3950		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3808 | Line 3954 | static PyObject *_wrap_BossTaskException
3954		return NULL;
3955		}
3956		}
3957	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3957	>	{
3958	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3959	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3960	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3961	>	}
3962		return resultobj;
3963		fail:
3964		return NULL;
3965		}
3966
3967
3968	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3968	>	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
3969		PyObject *resultobj;
3970	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3970	>	BossTask *arg1 = (BossTask *) 0 ;
3971	>	BossJob *arg2 = (BossJob *) 0 ;
3972	>	std::string *arg3 = 0 ;
3973	>	BossProgram result;
3974	>	std::string temp3 ;
3975		PyObject * obj0 = 0 ;
3976	+	PyObject * obj1 = 0 ;
3977	+	PyObject * obj2 = 0 ;
3978
3979	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3980	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3979	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
3980	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3981	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3982	>	{
3983	>	if (PyString_Check(obj2)) {
3984	>	temp3 = std::string(PyString_AsString(obj2));
3985	>	arg3 = &temp3;
3986	>	}else {
3987	>	SWIG_exception(SWIG_TypeError, "string expected");
3988	>	}
3989	>	}
3990		{
3991		try {
3992	<	delete arg1;
3992	>	result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
3993
3994		}catch (const BossSchedFailure & e) {
3995		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3834 | Line 3999 | static PyObject *_wrap_delete_BossTaskEx
3999		return NULL;
4000		}
4001		}
4002	<	Py_INCREF(Py_None); resultobj = Py_None;
4002	>	{
4003	>	BossProgram * resultptr;
4004	>	resultptr = new BossProgram((BossProgram &) result);
4005	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4006	>	}
4007		return resultobj;
4008		fail:
4009		return NULL;
4010		}
4011
4012
4013	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
4014	<	PyObject *obj;
4015	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4016	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
4017	<	Py_INCREF(obj);
4018	<	return Py_BuildValue((char *)"");
4013	>	static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4014	>	PyObject *resultobj;
4015	>	BossTask *arg1 = (BossTask *) 0 ;
4016	>	BossJob *arg2 = (BossJob *) 0 ;
4017	>	std::string *arg3 = 0 ;
4018	>	BossProgramExec result;
4019	>	std::string temp3 ;
4020	>	PyObject * obj0 = 0 ;
4021	>	PyObject * obj1 = 0 ;
4022	>	PyObject * obj2 = 0 ;
4023	>
4024	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4025	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4026	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4027	>	{
4028	>	if (PyString_Check(obj2)) {
4029	>	temp3 = std::string(PyString_AsString(obj2));
4030	>	arg3 = &temp3;
4031	>	}else {
4032	>	SWIG_exception(SWIG_TypeError, "string expected");
4033	>	}
4034	>	}
4035	>	{
4036	>	try {
4037	>	result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4038	>
4039	>	}catch (const BossSchedFailure & e) {
4040	>	PyErr_SetString ( SchedulerError, e.what() );
4041	>	return NULL;
4042	>	}catch (const std::exception& e) {
4043	>	PyErr_SetString ( BossError, e.what() );
4044	>	return NULL;
4045	>	}
4046	>	}
4047	>	{
4048	>	BossProgramExec * resultptr;
4049	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4050	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4051	>	}
4052	>	return resultobj;
4053	>	fail:
4054	>	return NULL;
4055		}
4056	+
4057	+
4058		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
4059		PyObject *resultobj;
4060		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 4098 | Line 4305 | static PyObject *_wrap_BossTask_name(PyO
4305		}
4306
4307
4308	<	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4308	>	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4309		PyObject *resultobj;
4310		BossTask *arg1 = (BossTask *) 0 ;
4311	<	std::map<std::string,std::string > result;
4311	>	std::string *arg2 = 0 ;
4312	>	BossChain result;
4313	>	std::string temp2 ;
4314		PyObject * obj0 = 0 ;
4315	+	PyObject * obj1 = 0 ;
4316
4317	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4317	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4318		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4319		{
4320	<	try {
4321	<	result = ((BossTask const *)arg1)->taskMap();
4322	<
4323	<	}catch (const BossSchedFailure & e) {
4324	<	PyErr_SetString ( SchedulerError, e.what() );
4115	<	return NULL;
4116	<	}catch (const std::exception& e) {
4117	<	PyErr_SetString ( BossError, e.what() );
4118	<	return NULL;
4119	<	}
4120	<	}
4121	<	{
4122	<	resultobj = PyDict_New();
4123	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4124	<	PyDict_SetItem(resultobj,
4125	<	SwigString_FromString(i->first),
4126	<	SwigString_FromString(i->second));
4320	>	if (PyString_Check(obj1)) {
4321	>	temp2 = std::string(PyString_AsString(obj1));
4322	>	arg2 = &temp2;
4323	>	}else {
4324	>	SWIG_exception(SWIG_TypeError, "string expected");
4325		}
4326		}
4129	–	return resultobj;
4130	–	fail:
4131	–	return NULL;
4132	–	}
4133	–
4134	–
4135	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4136	–	PyObject *resultobj;
4137	–	BossTask *arg1 = (BossTask *) 0 ;
4138	–	BossTask::job_iterator result;
4139	–	PyObject * obj0 = 0 ;
4140	–
4141	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4142	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4327		{
4328		try {
4329	<	result = ((BossTask const *)arg1)->job_begin();
4329	>	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4330
4331		}catch (const BossSchedFailure & e) {
4332		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4153 | Line 4337 | static PyObject *_wrap_BossTask_job_begi
4337		}
4338		}
4339		{
4340	<	BossTask::job_iterator * resultptr;
4341	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4342	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4340	>	BossChain * resultptr;
4341	>	resultptr = new BossChain((BossChain &) result);
4342	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4343		}
4344		return resultobj;
4345		fail:
#	Line 4163 | Line 4347 | static PyObject *_wrap_BossTask_job_begi
4347		}
4348
4349
4350	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4350	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4351		PyObject *resultobj;
4352		BossTask *arg1 = (BossTask *) 0 ;
4353	<	BossTask::job_iterator result;
4353	>	std::map<std::string,std::string > result;
4354		PyObject * obj0 = 0 ;
4355
4356	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4356	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4357		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4358		{
4359		try {
4360	<	result = ((BossTask const *)arg1)->job_end();
4360	>	result = ((BossTask const *)arg1)->taskMap();
4361
4362		}catch (const BossSchedFailure & e) {
4363		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4184 | Line 4368 | static PyObject *_wrap_BossTask_job_end(
4368		}
4369		}
4370		{
4371	<	BossTask::job_iterator * resultptr;
4372	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4373	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4371	>	resultobj = PyDict_New();
4372	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4373	>	PyDict_SetItem(resultobj,
4374	>	SwigString_FromString(i->first),
4375	>	SwigString_FromString(i->second));
4376	>	}
4377		}
4378		return resultobj;
4379		fail:
#	Line 4409 | Line 4596 | static PyObject *_wrap_BossTask_programs
4596		}
4597
4598
4412	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4413	–	PyObject *resultobj;
4414	–	BossTask *arg1 = (BossTask *) 0 ;
4415	–	BossJob *arg2 = (BossJob *) 0 ;
4416	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4417	–	PyObject * obj0 = 0 ;
4418	–	PyObject * obj1 = 0 ;
4419	–
4420	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4421	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4422	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4423	–	{
4424	–	try {
4425	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4426	–
4427	–	}catch (const BossSchedFailure & e) {
4428	–	PyErr_SetString ( SchedulerError, e.what() );
4429	–	return NULL;
4430	–	}catch (const std::exception& e) {
4431	–	PyErr_SetString ( BossError, e.what() );
4432	–	return NULL;
4433	–	}
4434	–	}
4435	–	{
4436	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4437	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4438	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4439	–	}
4440	–	return resultobj;
4441	–	fail:
4442	–	return NULL;
4443	–	}
4444	–
4445	–
4599		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4600		PyObject *resultobj;
4601		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5090 | Line 5243 | static PyObject *_wrap_BossTask_load(PyO
5243		}
5244
5245
5246	+	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5247	+	PyObject *resultobj;
5248	+	BossTask *arg1 = (BossTask *) 0 ;
5249	+	int arg2 = (int) SCHEDULED ;
5250	+	std::string const &arg3_defvalue = "all" ;
5251	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
5252	+	std::string const &arg4_defvalue = "" ;
5253	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
5254	+	std::string arg5 = (std::string) "" ;
5255	+	std::string arg6 = (std::string) "" ;
5256	+	std::string arg7 = (std::string) "" ;
5257	+	std::string arg8 = (std::string) "" ;
5258	+	unsigned int arg9 = (unsigned int) 0 ;
5259	+	int result;
5260	+	std::string temp3 ;
5261	+	std::string temp4 ;
5262	+	PyObject * obj0 = 0 ;
5263	+	PyObject * obj2 = 0 ;
5264	+	PyObject * obj3 = 0 ;
5265	+	PyObject * obj4 = 0 ;
5266	+	PyObject * obj5 = 0 ;
5267	+	PyObject * obj6 = 0 ;
5268	+	PyObject * obj7 = 0 ;
5269	+	PyObject * obj8 = 0 ;
5270	+
5271	+	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5272	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5273	+	if (obj2) {
5274	+	{
5275	+	if (PyString_Check(obj2)) {
5276	+	temp3 = std::string(PyString_AsString(obj2));
5277	+	arg3 = &temp3;
5278	+	}else {
5279	+	SWIG_exception(SWIG_TypeError, "string expected");
5280	+	}
5281	+	}
5282	+	}
5283	+	if (obj3) {
5284	+	{
5285	+	if (PyString_Check(obj3)) {
5286	+	temp4 = std::string(PyString_AsString(obj3));
5287	+	arg4 = &temp4;
5288	+	}else {
5289	+	SWIG_exception(SWIG_TypeError, "string expected");
5290	+	}
5291	+	}
5292	+	}
5293	+	if (obj4) {
5294	+	{
5295	+	if (PyString_Check(obj4))
5296	+	arg5 = std::string(PyString_AsString(obj4));
5297	+	else
5298	+	SWIG_exception(SWIG_TypeError, "string expected");
5299	+	}
5300	+	}
5301	+	if (obj5) {
5302	+	{
5303	+	if (PyString_Check(obj5))
5304	+	arg6 = std::string(PyString_AsString(obj5));
5305	+	else
5306	+	SWIG_exception(SWIG_TypeError, "string expected");
5307	+	}
5308	+	}
5309	+	if (obj6) {
5310	+	{
5311	+	if (PyString_Check(obj6))
5312	+	arg7 = std::string(PyString_AsString(obj6));
5313	+	else
5314	+	SWIG_exception(SWIG_TypeError, "string expected");
5315	+	}
5316	+	}
5317	+	if (obj7) {
5318	+	{
5319	+	if (PyString_Check(obj7))
5320	+	arg8 = std::string(PyString_AsString(obj7));
5321	+	else
5322	+	SWIG_exception(SWIG_TypeError, "string expected");
5323	+	}
5324	+	}
5325	+	if (obj8) {
5326	+	arg9 = (unsigned int) PyInt_AsLong(obj8);
5327	+	if (PyErr_Occurred()) SWIG_fail;
5328	+	}
5329	+	{
5330	+	try {
5331	+	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5332	+
5333	+	}catch (const BossSchedFailure & e) {
5334	+	PyErr_SetString ( SchedulerError, e.what() );
5335	+	return NULL;
5336	+	}catch (const std::exception& e) {
5337	+	PyErr_SetString ( BossError, e.what() );
5338	+	return NULL;
5339	+	}
5340	+	}
5341	+	resultobj = PyInt_FromLong((long)result);
5342	+	return resultobj;
5343	+	fail:
5344	+	return NULL;
5345	+	}
5346	+
5347	+
5348		static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
5349		PyObject *resultobj;
5350		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5325 | Line 5580 | static PyObject *_wrap_BossTask_appendTo
5580		static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5581		PyObject *resultobj;
5582		BossTask *arg1 = (BossTask *) 0 ;
5583	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5583	>	BossJob *arg2 = (BossJob *) 0 ;
5584		PyObject *arg3 = (PyObject *) 0 ;
5585		PyObject * obj0 = 0 ;
5586		PyObject * obj1 = 0 ;
#	Line 5333 | Line 5588 | static PyObject *_wrap_BossTask_jobDict(
5588
5589		if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5590		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5591	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5337	<	if (arg2 == NULL) {
5338	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5339	<	}
5591	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5592		arg3 = obj2;
5593		{
5594		try {
5595	<	BossTask_jobDict((BossTask const *)arg1,*arg2,arg3);
5595	>	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5596
5597		}catch (const BossSchedFailure & e) {
5598		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5384 | Line 5636 | static PyObject *_wrap_BossTask_jobsDict
5636		}
5637
5638
5639	+	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5640	+	PyObject *resultobj;
5641	+	BossTask *arg1 = (BossTask *) 0 ;
5642	+	std::string *arg2 = 0 ;
5643	+	PyObject *result;
5644	+	std::string temp2 ;
5645	+	PyObject * obj0 = 0 ;
5646	+	PyObject * obj1 = 0 ;
5647	+
5648	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5649	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5650	+	{
5651	+	if (PyString_Check(obj1)) {
5652	+	temp2 = std::string(PyString_AsString(obj1));
5653	+	arg2 = &temp2;
5654	+	}else {
5655	+	SWIG_exception(SWIG_TypeError, "string expected");
5656	+	}
5657	+	}
5658	+	{
5659	+	try {
5660	+	result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5661	+
5662	+	}catch (const BossSchedFailure & e) {
5663	+	PyErr_SetString ( SchedulerError, e.what() );
5664	+	return NULL;
5665	+	}catch (const std::exception& e) {
5666	+	PyErr_SetString ( BossError, e.what() );
5667	+	return NULL;
5668	+	}
5669	+	}
5670	+	resultobj = result;
5671	+	return resultobj;
5672	+	fail:
5673	+	return NULL;
5674	+	}
5675	+
5676	+
5677	+	static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
5678	+	PyObject *resultobj;
5679	+	BossTask *arg1 = (BossTask *) 0 ;
5680	+	std::string *arg2 = 0 ;
5681	+	PyObject *result;
5682	+	std::string temp2 ;
5683	+	PyObject * obj0 = 0 ;
5684	+	PyObject * obj1 = 0 ;
5685	+
5686	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5687	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5688	+	{
5689	+	if (PyString_Check(obj1)) {
5690	+	temp2 = std::string(PyString_AsString(obj1));
5691	+	arg2 = &temp2;
5692	+	}else {
5693	+	SWIG_exception(SWIG_TypeError, "string expected");
5694	+	}
5695	+	}
5696	+	{
5697	+	try {
5698	+	result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
5699	+
5700	+	}catch (const BossSchedFailure & e) {
5701	+	PyErr_SetString ( SchedulerError, e.what() );
5702	+	return NULL;
5703	+	}catch (const std::exception& e) {
5704	+	PyErr_SetString ( BossError, e.what() );
5705	+	return NULL;
5706	+	}
5707	+	}
5708	+	resultobj = result;
5709	+	return resultobj;
5710	+	fail:
5711	+	return NULL;
5712	+	}
5713	+
5714	+
5715	+	static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5716	+	PyObject *resultobj;
5717	+	BossTask *arg1 = (BossTask *) 0 ;
5718	+	PyObject *result;
5719	+	PyObject * obj0 = 0 ;
5720	+
5721	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5722	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5723	+	{
5724	+	try {
5725	+	result = (PyObject *)BossTask_jobStates(arg1);
5726	+
5727	+	}catch (const BossSchedFailure & e) {
5728	+	PyErr_SetString ( SchedulerError, e.what() );
5729	+	return NULL;
5730	+	}catch (const std::exception& e) {
5731	+	PyErr_SetString ( BossError, e.what() );
5732	+	return NULL;
5733	+	}
5734	+	}
5735	+	resultobj = result;
5736	+	return resultobj;
5737	+	fail:
5738	+	return NULL;
5739	+	}
5740	+
5741	+
5742	+	static PyObject *_wrap_BossTask_joblist(PyObject *self, PyObject *args) {
5743	+	PyObject *resultobj;
5744	+	BossTask *arg1 = (BossTask *) 0 ;
5745	+	PyObject *result;
5746	+	PyObject * obj0 = 0 ;
5747	+
5748	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_joblist",&obj0)) goto fail;
5749	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5750	+	{
5751	+	try {
5752	+	result = (PyObject *)BossTask_joblist(arg1);
5753	+
5754	+	}catch (const BossSchedFailure & e) {
5755	+	PyErr_SetString ( SchedulerError, e.what() );
5756	+	return NULL;
5757	+	}catch (const std::exception& e) {
5758	+	PyErr_SetString ( BossError, e.what() );
5759	+	return NULL;
5760	+	}
5761	+	}
5762	+	resultobj = result;
5763	+	return resultobj;
5764	+	fail:
5765	+	return NULL;
5766	+	}
5767	+
5768	+
5769	+	static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5770	+	PyObject *resultobj;
5771	+	BossTask *arg1 = (BossTask *) 0 ;
5772	+	PyObject *result;
5773	+	PyObject * obj0 = 0 ;
5774	+
5775	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5776	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5777	+	{
5778	+	try {
5779	+	result = (PyObject *)BossTask_jobStatistic(arg1);
5780	+
5781	+	}catch (const BossSchedFailure & e) {
5782	+	PyErr_SetString ( SchedulerError, e.what() );
5783	+	return NULL;
5784	+	}catch (const std::exception& e) {
5785	+	PyErr_SetString ( BossError, e.what() );
5786	+	return NULL;
5787	+	}
5788	+	}
5789	+	resultobj = result;
5790	+	return resultobj;
5791	+	fail:
5792	+	return NULL;
5793	+	}
5794	+
5795	+
5796		static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5797		PyObject *resultobj;
5798		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5455 | Line 5864 | static PyObject *_wrap_BossTask_jobProgr
5864		}
5865
5866
5867	+	static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5868	+	PyObject *resultobj;
5869	+	BossTask *arg1 = (BossTask *) 0 ;
5870	+	std::string *arg2 = 0 ;
5871	+	std::string *arg3 = 0 ;
5872	+	PyObject *result;
5873	+	std::string temp2 ;
5874	+	std::string temp3 ;
5875	+	PyObject * obj0 = 0 ;
5876	+	PyObject * obj1 = 0 ;
5877	+	PyObject * obj2 = 0 ;
5878	+
5879	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5880	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5881	+	{
5882	+	if (PyString_Check(obj1)) {
5883	+	temp2 = std::string(PyString_AsString(obj1));
5884	+	arg2 = &temp2;
5885	+	}else {
5886	+	SWIG_exception(SWIG_TypeError, "string expected");
5887	+	}
5888	+	}
5889	+	{
5890	+	if (PyString_Check(obj2)) {
5891	+	temp3 = std::string(PyString_AsString(obj2));
5892	+	arg3 = &temp3;
5893	+	}else {
5894	+	SWIG_exception(SWIG_TypeError, "string expected");
5895	+	}
5896	+	}
5897	+	{
5898	+	try {
5899	+	result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5900	+
5901	+	}catch (const BossSchedFailure & e) {
5902	+	PyErr_SetString ( SchedulerError, e.what() );
5903	+	return NULL;
5904	+	}catch (const std::exception& e) {
5905	+	PyErr_SetString ( BossError, e.what() );
5906	+	return NULL;
5907	+	}
5908	+	}
5909	+	resultobj = result;
5910	+	return resultobj;
5911	+	fail:
5912	+	return NULL;
5913	+	}
5914	+
5915	+
5916	+	static PyObject *_wrap_BossTask_programExec(PyObject *self, PyObject *args) {
5917	+	PyObject *resultobj;
5918	+	BossTask *arg1 = (BossTask *) 0 ;
5919	+	std::string *arg2 = 0 ;
5920	+	std::string *arg3 = 0 ;
5921	+	PyObject *result;
5922	+	std::string temp2 ;
5923	+	std::string temp3 ;
5924	+	PyObject * obj0 = 0 ;
5925	+	PyObject * obj1 = 0 ;
5926	+	PyObject * obj2 = 0 ;
5927	+
5928	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
5929	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5930	+	{
5931	+	if (PyString_Check(obj1)) {
5932	+	temp2 = std::string(PyString_AsString(obj1));
5933	+	arg2 = &temp2;
5934	+	}else {
5935	+	SWIG_exception(SWIG_TypeError, "string expected");
5936	+	}
5937	+	}
5938	+	{
5939	+	if (PyString_Check(obj2)) {
5940	+	temp3 = std::string(PyString_AsString(obj2));
5941	+	arg3 = &temp3;
5942	+	}else {
5943	+	SWIG_exception(SWIG_TypeError, "string expected");
5944	+	}
5945	+	}
5946	+	{
5947	+	try {
5948	+	result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5949	+
5950	+	}catch (const BossSchedFailure & e) {
5951	+	PyErr_SetString ( SchedulerError, e.what() );
5952	+	return NULL;
5953	+	}catch (const std::exception& e) {
5954	+	PyErr_SetString ( BossError, e.what() );
5955	+	return NULL;
5956	+	}
5957	+	}
5958	+	resultobj = result;
5959	+	return resultobj;
5960	+	fail:
5961	+	return NULL;
5962	+	}
5963	+
5964	+
5965	+	static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
5966	+	PyObject *resultobj;
5967	+	BossTask *arg1 = (BossTask *) 0 ;
5968	+	std::string *arg2 = 0 ;
5969	+	std::string *arg3 = 0 ;
5970	+	PyObject *result;
5971	+	std::string temp2 ;
5972	+	std::string temp3 ;
5973	+	PyObject * obj0 = 0 ;
5974	+	PyObject * obj1 = 0 ;
5975	+	PyObject * obj2 = 0 ;
5976	+
5977	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
5978	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5979	+	{
5980	+	if (PyString_Check(obj1)) {
5981	+	temp2 = std::string(PyString_AsString(obj1));
5982	+	arg2 = &temp2;
5983	+	}else {
5984	+	SWIG_exception(SWIG_TypeError, "string expected");
5985	+	}
5986	+	}
5987	+	{
5988	+	if (PyString_Check(obj2)) {
5989	+	temp3 = std::string(PyString_AsString(obj2));
5990	+	arg3 = &temp3;
5991	+	}else {
5992	+	SWIG_exception(SWIG_TypeError, "string expected");
5993	+	}
5994	+	}
5995	+	{
5996	+	try {
5997	+	result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5998	+
5999	+	}catch (const BossSchedFailure & e) {
6000	+	PyErr_SetString ( SchedulerError, e.what() );
6001	+	return NULL;
6002	+	}catch (const std::exception& e) {
6003	+	PyErr_SetString ( BossError, e.what() );
6004	+	return NULL;
6005	+	}
6006	+	}
6007	+	resultobj = result;
6008	+	return resultobj;
6009	+	fail:
6010	+	return NULL;
6011	+	}
6012	+
6013	+
6014		static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
6015		PyObject *obj;
6016		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 6417 | Line 6973 | static PyMethodDef SwigMethods[] = {
6973		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6974		{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6975		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6976	+	{ (char *)"BossSession_task_begin", _wrap_BossSession_task_begin, METH_VARARGS },
6977	+	{ (char *)"BossSession_task_end", _wrap_BossSession_task_end, METH_VARARGS },
6978	+	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
6979	+	{ (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
6980		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6981		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6982		{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
#	Line 6432 | Line 6992 | static PyMethodDef SwigMethods[] = {
6992		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
6993		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6994		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6435	–	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6436	–	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6437	–	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
6995		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6996		{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
6997	+	{ (char *)"BossSession_getTasksByTaskInfo", _wrap_BossSession_getTasksByTaskInfo, METH_VARARGS },
6998	+	{ (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
6999		{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7000		{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7001		{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
7002		{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
7003		{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
7004		{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7005	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7005	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7006		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6448	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6449	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7007		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
6451	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7008		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7009		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7010	+	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7011	+	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7012	+	{ (char *)"BossTask_jobsInMemory", _wrap_BossTask_jobsInMemory, METH_VARARGS },
7013	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7014	+	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7015	+	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
7016		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
7017		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7018		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7019		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7020	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7021		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6459	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6460	–	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7022		{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7023		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
7024		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6464	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7025		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7026		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7027		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
#	Line 6471 | Line 7031 | static PyMethodDef SwigMethods[] = {
7031		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7032		{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7033		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7034	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7035		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7036		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7037		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7038		{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7039		{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7040		{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7041	+	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7042	+	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7043	+	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7044	+	{ (char *)"BossTask_joblist", _wrap_BossTask_joblist, METH_VARARGS },
7045	+	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7046		{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7047		{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7048	+	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7049	+	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7050	+	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7051		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
7052		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7053		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 6503 | Line 7072 | static PyMethodDef SwigMethods[] = {
7072
7073		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7074
6506	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7075		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}};
7076	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7077		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}};
7078	<	static swig_type_info _swigt__p_std__vectorTBossTask_p_t[] = {{"_p_std__vectorTBossTask_p_t", 0, "std::vector<BossTask * > *", 0},{"_p_std__vectorTBossTask_p_t"},{0}};
7078	>	static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7079	>	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7080		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}};
6511	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7081		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7082		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7083	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7084	+	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7085		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7086		static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7087		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
#	Line 6519 | Line 7090 | static swig_type_info _swigt__p_BossSess
7090		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}};
7091		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}};
7092		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
6522	–	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}};
7093		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}};
7094	+	static swig_type_info _swigt__p_BossSession__task_iterator[] = {{"_p_BossSession__task_iterator", 0, "BossSession::task_iterator const *", 0},{"_p_BossSession__task_iterator"},{0}};
7095	+	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}};
7096		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7097
7098		static swig_type_info *swig_types_initial[] = {
6527	–	_swigt__p_XMLDoc,
7099		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
7100	+	_swigt__p_XMLDoc,
7101		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7102	<	_swigt__p_std__vectorTBossTask_p_t,
7102	>	_swigt__p_BossProgramExec,
7103	>	_swigt__p_BossChain,
7104		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6532	–	_swigt__p_std__ostream,
7105		_swigt__p_BossTask,
7106		_swigt__p_BossTaskException,
7107	+	_swigt__p_std__ostream,
7108	+	_swigt__p_BossProgram,
7109		_swigt__p_printOption,
7110		_swigt__p_BossAttributeContainer,
7111		_swigt__p_BossJob,
#	Line 6540 | Line 7114 | _swigt__p_BossSession,
7114		_swigt__p_std__vectorTstd__string_t,
7115		_swigt__p_std__mapTstd__string_std__string_t,
7116		_swigt__p_BossAdministratorSession,
6543	–	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7117		_swigt__p_BossTask__job_iterator,
7118	+	_swigt__p_BossSession__task_iterator,
7119	+	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7120		_swigt__p_jobStates,
7121		0
7122		};

Diff Legend

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