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.26 by gcodispo, Thu Mar 8 11:06:25 2007 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_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	<	std::cout << "taskRange\n";
976	<	taskList = self->selectTasksByName( taskName );
977	<	}
978	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
979	<	it!= taskList.end(); ++it ) {
980	<	PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
981	<	}
982	<	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;
977	>
978		BossAttributeContainer::const_iterator it_end = obj.end ();
979		for (BossAttributeContainer::const_iterator it = obj.begin ();
980		it != it_end; ++it) {
#	Line 995 | 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 1025 | 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	+	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
1039	–	std::string tmp;
1040	–
1093		// PROGRAM
1094		BossAttributeContainer obj =
1095		(programs_it->first).getTableEntries("PROGRAM");
#	Line 1081 | Line 1133 | PyObject *BossTask_jobPrograms(BossTask
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
#	Line 2432 | Line 2529 | static PyObject *_wrap_BossSession_clear
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 ;
#	Line 2899 | Line 3116 | static PyObject *_wrap_BossSession_listM
3116		BossSession *arg1 = (BossSession *) 0 ;
3117		std::string *arg2 = 0 ;
3118		std::string *arg3 = 0 ;
3119	<	bool arg4 = (bool) false ;
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	<	std::string const &arg6_defvalue = "" ;
2906	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
2907	<	unsigned int arg7 = (unsigned int) 0 ;
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 ;
2912	–	std::string temp6 ;
3129		PyObject * obj0 = 0 ;
3130		PyObject * obj1 = 0 ;
3131		PyObject * obj2 = 0 ;
3132		PyObject * obj3 = 0 ;
3133		PyObject * obj4 = 0 ;
3134		PyObject * obj5 = 0 ;
2919	–	PyObject * obj6 = 0 ;
3135
3136	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
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)) {
#	Line 2937 | Line 3152 | static PyObject *_wrap_BossSession_listM
3152		}
3153		}
3154		if (obj3) {
2940	–	arg4 = PyInt_AsLong(obj3) ? true : false;
2941	–	if (PyErr_Occurred()) SWIG_fail;
2942	–	}
2943	–	if (obj4) {
3155		{
3156	<	if (PyString_Check(obj4)) {
3157	<	temp5 = std::string(PyString_AsString(obj4));
3158	<	arg5 = &temp5;
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 (obj5) {
3164	>	if (obj4) {
3165		{
3166	<	if (PyString_Check(obj5)) {
3167	<	temp6 = std::string(PyString_AsString(obj5));
3168	<	arg6 = &temp6;
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 (obj6) {
3175	<	arg7 = (unsigned int) PyInt_AsLong(obj6);
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,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
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() );
#	Line 2988 | Line 3199 | static PyObject *_wrap_BossSession_listM
3199		}
3200
3201
3202	<	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3202	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3203		PyObject *resultobj;
3204		BossSession *arg1 = (BossSession *) 0 ;
3205		int arg2 = (int) SCHEDULED ;
#	Line 3003 | Line 3214 | static PyObject *_wrap_BossSession_sched
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 ;
#	Line 3015 | Line 3227 | static PyObject *_wrap_BossSession_sched
3227		PyObject * obj7 = 0 ;
3228		PyObject * obj8 = 0 ;
3229		PyObject * obj9 = 0 ;
3230	+	PyObject * obj10 = 0 ;
3231
3232	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
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		{
#	Line 3084 | Line 3297 | static PyObject *_wrap_BossSession_sched
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		try {
3306	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
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() );
#	Line 3103 | Line 3320 | static PyObject *_wrap_BossSession_sched
3320		}
3321
3322
3323	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3323	>	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3324		PyObject *resultobj;
3325		BossSession *arg1 = (BossSession *) 0 ;
3326	<	std::string const &arg2_defvalue = "all" ;
3327	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3111	<	std::string const &arg3_defvalue = "" ;
3112	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3113	<	std::string const &arg4_defvalue = "" ;
3114	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3115	<	std::string const &arg5_defvalue = "" ;
3116	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3117	<	std::vector<std::string > result;
3326	>	std::string *arg2 = 0 ;
3327	>	unsigned int result;
3328		std::string temp2 ;
3119	–	std::string temp3 ;
3120	–	std::string temp4 ;
3121	–	std::string temp5 ;
3329		PyObject * obj0 = 0 ;
3330		PyObject * obj1 = 0 ;
3124	–	PyObject * obj2 = 0 ;
3125	–	PyObject * obj3 = 0 ;
3126	–	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 {
3136	<	SWIG_exception(SWIG_TypeError, "string expected");
3137	<	}
3138	<	}
3139	<	}
3140	<	if (obj2) {
3141	<	{
3142	<	if (PyString_Check(obj2)) {
3143	<	temp3 = std::string(PyString_AsString(obj2));
3144	<	arg3 = &temp3;
3145	<	}else {
3146	<	SWIG_exception(SWIG_TypeError, "string expected");
3147	<	}
3148	<	}
3149	<	}
3150	<	if (obj3) {
3151	<	{
3152	<	if (PyString_Check(obj3)) {
3153	<	temp4 = std::string(PyString_AsString(obj3));
3154	<	arg4 = &temp4;
3155	<	}else {
3156	<	SWIG_exception(SWIG_TypeError, "string expected");
3157	<	}
3158	<	}
3159	<	}
3160	<	if (obj4) {
3161	<	{
3162	<	if (PyString_Check(obj4)) {
3163	<	temp5 = std::string(PyString_AsString(obj4));
3164	<	arg5 = &temp5;
3165	<	}else {
3166	<	SWIG_exception(SWIG_TypeError, "string expected");
3167	<	}
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	>	result = (unsigned int)(arg1)->getTasksByName((std::string const &)*arg2);
3345
3346		}catch (const BossSchedFailure & e) {
3347		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3179 | Line 3351 | static PyObject *_wrap_BossSession_selec
3351		return NULL;
3352		}
3353		}
3354	<	{
3183	<	resultobj = PyTuple_New((&result)->size());
3184	<	for (unsigned int i=0; i<(&result)->size(); i++)
3185	<	PyTuple_SetItem(resultobj,i,
3186	<	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3187	<	}
3354	>	resultobj = PyInt_FromLong((long)result);
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 ;
3365	<	std::vector<std::string > result;
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_selectTasksByName",&obj0,&obj1)) goto fail;
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		if (PyString_Check(obj1)) {
#	Line 3212 | Line 3379 | static PyObject *_wrap_BossSession_selec
3379		}
3380		{
3381		try {
3382	<	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3382	>	result = (unsigned int)(arg1)->getTasksByTaskInfo((std::string const &)*arg2);
3383
3384		}catch (const BossSchedFailure & e) {
3385		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3222 | Line 3389 | static PyObject *_wrap_BossSession_selec
3389		return NULL;
3390		}
3391		}
3392	<	{
3226	<	resultobj = PyTuple_New((&result)->size());
3227	<	for (unsigned int i=0; i<(&result)->size(); i++)
3228	<	PyTuple_SetItem(resultobj,i,
3229	<	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3230	<	}
3231	<	return resultobj;
3232	<	fail:
3233	<	return NULL;
3234	<	}
3235	<
3236	<
3237	<	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3238	<	PyObject *resultobj;
3239	<	BossSession *arg1 = (BossSession *) 0 ;
3240	<	int arg2 = (int) SCHEDULED ;
3241	<	std::string const &arg3_defvalue = "all" ;
3242	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3243	<	std::string const &arg4_defvalue = "all" ;
3244	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3245	<	std::string const &arg5_defvalue = "" ;
3246	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3247	<	std::string arg6 = (std::string) "" ;
3248	<	std::string arg7 = (std::string) "" ;
3249	<	std::string arg8 = (std::string) "" ;
3250	<	std::string arg9 = (std::string) "" ;
3251	<	unsigned int arg10 = (unsigned int) 0 ;
3252	<	bool arg11 = (bool) false ;
3253	<	SwigValueWrapper< std::vector<BossTask * > > result;
3254	<	std::string temp3 ;
3255	<	std::string temp4 ;
3256	<	std::string temp5 ;
3257	<	PyObject * obj0 = 0 ;
3258	<	PyObject * obj2 = 0 ;
3259	<	PyObject * obj3 = 0 ;
3260	<	PyObject * obj4 = 0 ;
3261	<	PyObject * obj5 = 0 ;
3262	<	PyObject * obj6 = 0 ;
3263	<	PyObject * obj7 = 0 ;
3264	<	PyObject * obj8 = 0 ;
3265	<	PyObject * obj9 = 0 ;
3266	<	PyObject * obj10 = 0 ;
3267	<
3268	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3269	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3270	<	if (obj2) {
3271	<	{
3272	<	if (PyString_Check(obj2)) {
3273	<	temp3 = std::string(PyString_AsString(obj2));
3274	<	arg3 = &temp3;
3275	<	}else {
3276	<	SWIG_exception(SWIG_TypeError, "string expected");
3277	<	}
3278	<	}
3279	<	}
3280	<	if (obj3) {
3281	<	{
3282	<	if (PyString_Check(obj3)) {
3283	<	temp4 = std::string(PyString_AsString(obj3));
3284	<	arg4 = &temp4;
3285	<	}else {
3286	<	SWIG_exception(SWIG_TypeError, "string expected");
3287	<	}
3288	<	}
3289	<	}
3290	<	if (obj4) {
3291	<	{
3292	<	if (PyString_Check(obj4)) {
3293	<	temp5 = std::string(PyString_AsString(obj4));
3294	<	arg5 = &temp5;
3295	<	}else {
3296	<	SWIG_exception(SWIG_TypeError, "string expected");
3297	<	}
3298	<	}
3299	<	}
3300	<	if (obj5) {
3301	<	{
3302	<	if (PyString_Check(obj5))
3303	<	arg6 = std::string(PyString_AsString(obj5));
3304	<	else
3305	<	SWIG_exception(SWIG_TypeError, "string expected");
3306	<	}
3307	<	}
3308	<	if (obj6) {
3309	<	{
3310	<	if (PyString_Check(obj6))
3311	<	arg7 = std::string(PyString_AsString(obj6));
3312	<	else
3313	<	SWIG_exception(SWIG_TypeError, "string expected");
3314	<	}
3315	<	}
3316	<	if (obj7) {
3317	<	{
3318	<	if (PyString_Check(obj7))
3319	<	arg8 = std::string(PyString_AsString(obj7));
3320	<	else
3321	<	SWIG_exception(SWIG_TypeError, "string expected");
3322	<	}
3323	<	}
3324	<	if (obj8) {
3325	<	{
3326	<	if (PyString_Check(obj8))
3327	<	arg9 = std::string(PyString_AsString(obj8));
3328	<	else
3329	<	SWIG_exception(SWIG_TypeError, "string expected");
3330	<	}
3331	<	}
3332	<	if (obj9) {
3333	<	arg10 = (unsigned int) PyInt_AsLong(obj9);
3334	<	if (PyErr_Occurred()) SWIG_fail;
3335	<	}
3336	<	if (obj10) {
3337	<	arg11 = PyInt_AsLong(obj10) ? true : false;
3338	<	if (PyErr_Occurred()) SWIG_fail;
3339	<	}
3340	<	{
3341	<	try {
3342	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3343	<
3344	<	}catch (const BossSchedFailure & e) {
3345	<	PyErr_SetString ( SchedulerError, e.what() );
3346	<	return NULL;
3347	<	}catch (const std::exception& e) {
3348	<	PyErr_SetString ( BossError, e.what() );
3349	<	return NULL;
3350	<	}
3351	<	}
3352	<	{
3353	<	std::vector<BossTask * > * resultptr;
3354	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3355	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3356	<	}
3392	>	resultobj = PyInt_FromLong((long)result);
3393		return resultobj;
3394		fail:
3395		return NULL;
3396		}
3397
3398
3399	<	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3399	>	static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3400		PyObject *resultobj;
3401		BossSession *arg1 = (BossSession *) 0 ;
3402		std::string *arg2 = 0 ;
3403	<	SwigValueWrapper< std::vector<BossTask * > > result;
3403	>	unsigned int result;
3404		std::string temp2 ;
3405		PyObject * obj0 = 0 ;
3406		PyObject * obj1 = 0 ;
3407
3408	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
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)) {
#	Line 3381 | Line 3417 | static PyObject *_wrap_BossSession_getTa
3417		}
3418		{
3419		try {
3420	<	result = (arg1)->getTasksByName((std::string const &)*arg2);
3420	>	result = (unsigned int)(arg1)->getTasksByJobName((std::string const &)*arg2);
3421
3422		}catch (const BossSchedFailure & e) {
3423		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3391 | Line 3427 | static PyObject *_wrap_BossSession_getTa
3427		return NULL;
3428		}
3429		}
3430	<	{
3395	<	std::vector<BossTask * > * resultptr;
3396	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3397	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3398	<	}
3430	>	resultobj = PyInt_FromLong((long)result);
3431		return resultobj;
3432		fail:
3433		return NULL;
#	Line 3553 | Line 3585 | static PyObject *_wrap_BossSession_sched
3585		std::string const &arg5_defvalue = "" ;
3586		std::string *arg5 = (std::string *) &arg5_defvalue ;
3587		unsigned int arg6 = (unsigned int) 0 ;
3556	–	bool arg7 = (bool) false ;
3588		PyObject *result;
3589		std::string temp2 ;
3590		std::string temp3 ;
#	Line 3565 | Line 3596 | static PyObject *_wrap_BossSession_sched
3596		PyObject * obj3 = 0 ;
3597		PyObject * obj4 = 0 ;
3598		PyObject * obj5 = 0 ;
3568	–	PyObject * obj6 = 0 ;
3599
3600	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
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)) {
#	Line 3609 | Line 3639 | static PyObject *_wrap_BossSession_sched
3639		arg6 = (unsigned int) PyInt_AsLong(obj5);
3640		if (PyErr_Occurred()) SWIG_fail;
3641		}
3612	–	if (obj6) {
3613	–	arg7 = PyInt_AsLong(obj6) ? true : false;
3614	–	if (PyErr_Occurred()) SWIG_fail;
3615	–	}
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,arg7);
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() );
#	Line 3632 | Line 3658 | static PyObject *_wrap_BossSession_sched
3658		}
3659
3660
3661	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3661	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3662		PyObject *resultobj;
3663		BossSession *arg1 = (BossSession *) 0 ;
3664	<	std::string const &arg2_defvalue = "" ;
3639	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3664	>	int arg2 = (int) SCHEDULED ;
3665		std::string const &arg3_defvalue = "all" ;
3666		std::string *arg3 = (std::string *) &arg3_defvalue ;
3667	<	std::string arg4 = (std::string) "" ;
3668	<	std::string arg5 = (std::string) "" ;
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	<	PyObject *result;
3673	<	std::string temp2 ;
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 ;
3649	–	PyObject * obj1 = 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|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
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 (obj1) {
3693	>	if (obj2) {
3694		{
3695	<	if (PyString_Check(obj1)) {
3696	<	temp2 = std::string(PyString_AsString(obj1));
3697	<	arg2 = &temp2;
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 (obj2) {
3703	>	if (obj3) {
3704		{
3705	<	if (PyString_Check(obj2)) {
3706	<	temp3 = std::string(PyString_AsString(obj2));
3707	<	arg3 = &temp3;
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 (obj3) {
3713	>	if (obj4) {
3714		{
3715	<	if (PyString_Check(obj3))
3716	<	arg4 = std::string(PyString_AsString(obj3));
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 (obj4) {
3731	>	if (obj6) {
3732		{
3733	<	if (PyString_Check(obj4))
3734	<	arg5 = std::string(PyString_AsString(obj4));
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 (obj5) {
3739	>	if (obj7) {
3740		{
3741	<	if (PyString_Check(obj5))
3742	<	arg6 = std::string(PyString_AsString(obj5));
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	+	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	<	result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
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() );
#	Line 3710 | Line 3772 | static PyObject *_wrap_BossSession_query
3772		return NULL;
3773		}
3774		}
3775	<	resultobj = result;
3775	>	Py_INCREF(Py_None); resultobj = Py_None;
3776		return resultobj;
3777		fail:
3778		return NULL;
#	Line 3724 | Line 3786 | static PyObject * BossSession_swigregist
3786		Py_INCREF(obj);
3787		return Py_BuildValue((char *)"");
3788		}
3789	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
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 ;
3730	–	char *arg2 ;
3817		PyObject * obj0 = 0 ;
3818
3819	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
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	<	if (arg2) {
3823	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3824	<	strcpy((char *) arg1->key,arg2);
3825	<	}else {
3826	<	arg1->key = 0;
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;
#	Line 3747 | Line 3837 | static PyObject *_wrap_BossTaskException
3837		}
3838
3839
3840	<	static PyObject *_wrap_BossTaskException_key_get(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	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3850	<	char *result;
3849	>	BossTask *arg1 = (BossTask *) 0 ;
3850	>	BossTask::job_iterator result;
3851		PyObject * obj0 = 0 ;
3852
3853	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3854	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3855	<	result = (char *) ((arg1)->key);
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	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
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_new_BossTaskException(PyObject *self, PyObject *args) {
3909	>	static PyObject *_wrap_BossTask_jobsInMemory(PyObject *self, PyObject *args) {
3910		PyObject *resultobj;
3911	<	char *arg1 ;
3912	<	BossTaskException *result;
3911	>	BossTask *arg1 = (BossTask *) 0 ;
3912	>	unsigned int result;
3913	>	PyObject * obj0 = 0 ;
3914
3915	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
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 = (BossTaskException *)new BossTaskException((char const *)arg1);
3919	>	result = (unsigned int)((BossTask const *)arg1)->jobsInMemory();
3920
3921		}catch (const BossSchedFailure & e) {
3922		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3782 | Line 3926 | static PyObject *_wrap_new_BossTaskExcep
3926		return NULL;
3927		}
3928		}
3929	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3929	>	resultobj = PyInt_FromLong((long)result);
3930		return resultobj;
3931		fail:
3932		return NULL;
3933		}
3934
3935
3936	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3936	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3937		PyObject *resultobj;
3938	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3939	<	char *result;
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:BossTaskException_what",&obj0)) goto fail;
3945	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
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 = (char *)((BossTaskException const *)arg1)->what();
3949	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
3950
3951		}catch (const BossSchedFailure & e) {
3952		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3809 | Line 3956 | static PyObject *_wrap_BossTaskException
3956		return NULL;
3957		}
3958		}
3959	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
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_delete_BossTaskException(PyObject *self, PyObject *args) {
3970	>	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
3971		PyObject *resultobj;
3972	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
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 *)"O:delete_BossTaskException",&obj0)) goto fail;
3982	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
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		{
3993		try {
3994	<	delete arg1;
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() );
#	Line 3835 | Line 4001 | static PyObject *_wrap_delete_BossTaskEx
4001		return NULL;
4002		}
4003		}
4004	<	Py_INCREF(Py_None); resultobj = Py_None;
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 * BossTaskException_swigregister(PyObject *self, PyObject *args) {
4016	<	PyObject *obj;
4017	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4018	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
4019	<	Py_INCREF(obj);
4020	<	return Py_BuildValue((char *)"");
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	>	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:
4056	>	return NULL;
4057		}
4058	+
4059	+
4060		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
4061		PyObject *resultobj;
4062		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 4099 | Line 4307 | static PyObject *_wrap_BossTask_name(PyO
4307		}
4308
4309
4310	<	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4310	>	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4311		PyObject *resultobj;
4312		BossTask *arg1 = (BossTask *) 0 ;
4313	<	std::map<std::string,std::string > result;
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 *)"O:BossTask_taskMap",&obj0)) goto fail;
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	<	try {
4323	<	result = ((BossTask const *)arg1)->taskMap();
4324	<
4325	<	}catch (const BossSchedFailure & e) {
4326	<	PyErr_SetString ( SchedulerError, e.what() );
4116	<	return NULL;
4117	<	}catch (const std::exception& e) {
4118	<	PyErr_SetString ( BossError, e.what() );
4119	<	return NULL;
4120	<	}
4121	<	}
4122	<	{
4123	<	resultobj = PyDict_New();
4124	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4125	<	PyDict_SetItem(resultobj,
4126	<	SwigString_FromString(i->first),
4127	<	SwigString_FromString(i->second));
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		}
4130	–	return resultobj;
4131	–	fail:
4132	–	return NULL;
4133	–	}
4134	–
4135	–
4136	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4137	–	PyObject *resultobj;
4138	–	BossTask *arg1 = (BossTask *) 0 ;
4139	–	BossTask::job_iterator result;
4140	–	PyObject * obj0 = 0 ;
4141	–
4142	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4143	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4329		{
4330		try {
4331	<	result = ((BossTask const *)arg1)->job_begin();
4331	>	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4332
4333		}catch (const BossSchedFailure & e) {
4334		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4154 | Line 4339 | static PyObject *_wrap_BossTask_job_begi
4339		}
4340		}
4341		{
4342	<	BossTask::job_iterator * resultptr;
4343	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4344	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
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:
#	Line 4164 | Line 4349 | static PyObject *_wrap_BossTask_job_begi
4349		}
4350
4351
4352	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4352	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4353		PyObject *resultobj;
4354		BossTask *arg1 = (BossTask *) 0 ;
4355	<	BossTask::job_iterator result;
4355	>	std::map<std::string,std::string > result;
4356		PyObject * obj0 = 0 ;
4357
4358	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
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		try {
4362	<	result = ((BossTask const *)arg1)->job_end();
4362	>	result = ((BossTask const *)arg1)->taskMap();
4363
4364		}catch (const BossSchedFailure & e) {
4365		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4185 | Line 4370 | static PyObject *_wrap_BossTask_job_end(
4370		}
4371		}
4372		{
4373	<	BossTask::job_iterator * resultptr;
4374	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4375	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
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:
#	Line 4410 | Line 4598 | static PyObject *_wrap_BossTask_programs
4598		}
4599
4600
4413	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4414	–	PyObject *resultobj;
4415	–	BossTask *arg1 = (BossTask *) 0 ;
4416	–	BossJob *arg2 = (BossJob *) 0 ;
4417	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4418	–	PyObject * obj0 = 0 ;
4419	–	PyObject * obj1 = 0 ;
4420	–
4421	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4422	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4423	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4424	–	{
4425	–	try {
4426	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4427	–
4428	–	}catch (const BossSchedFailure & e) {
4429	–	PyErr_SetString ( SchedulerError, e.what() );
4430	–	return NULL;
4431	–	}catch (const std::exception& e) {
4432	–	PyErr_SetString ( BossError, e.what() );
4433	–	return NULL;
4434	–	}
4435	–	}
4436	–	{
4437	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4438	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4439	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4440	–	}
4441	–	return resultobj;
4442	–	fail:
4443	–	return NULL;
4444	–	}
4445	–
4446	–
4601		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4602		PyObject *resultobj;
4603		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4618 | Line 4772 | static PyObject *_wrap_BossTask_declare(
4772		static PyObject *_wrap_BossTask_remove(PyObject *self, PyObject *args) {
4773		PyObject *resultobj;
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:BossTask_remove",&obj0)) goto 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	+	arg2 = PyInt_AsLong(obj1) ? true : false;
4783	+	if (PyErr_Occurred()) SWIG_fail;
4784	+	}
4785		{
4786		try {
4787	<	(arg1)->remove();
4787	>	(arg1)->remove(arg2);
4788
4789		}catch (const BossSchedFailure & e) {
4790		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4646 | Line 4806 | static PyObject *_wrap_BossTask_archive(
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|O:BossTask_archive",&obj0,&obj1)) goto fail;
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		{
#	Line 4662 | Line 4824 | static PyObject *_wrap_BossTask_archive(
4824		}
4825		}
4826		}
4827	+	if (obj2) {
4828	+	arg3 = PyInt_AsLong(obj2) ? true : false;
4829	+	if (PyErr_Occurred()) SWIG_fail;
4830	+	}
4831		{
4832		try {
4833	<	(arg1)->archive((std::string const &)*arg2);
4833	>	(arg1)->archive((std::string const &)*arg2,arg3);
4834
4835		}catch (const BossSchedFailure & e) {
4836		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5091 | Line 5257 | static PyObject *_wrap_BossTask_load(PyO
5257		}
5258
5259
5260	+	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5261	+	PyObject *resultobj;
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 ;
#	Line 5326 | Line 5594 | static PyObject *_wrap_BossTask_appendTo
5594		static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5595		PyObject *resultobj;
5596		BossTask *arg1 = (BossTask *) 0 ;
5597	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5597	>	BossJob *arg2 = (BossJob *) 0 ;
5598		PyObject *arg3 = (PyObject *) 0 ;
5599		PyObject * obj0 = 0 ;
5600		PyObject * obj1 = 0 ;
#	Line 5334 | Line 5602 | static PyObject *_wrap_BossTask_jobDict(
5602
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_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5338	<	if (arg2 == NULL) {
5339	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5340	<	}
5605	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5606		arg3 = obj2;
5607		{
5608		try {
5609	<	BossTask_jobDict((BossTask const *)arg1,*arg2,arg3);
5609	>	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5610
5611		}catch (const BossSchedFailure & e) {
5612		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5385 | Line 5650 | static PyObject *_wrap_BossTask_jobsDict
5650		}
5651
5652
5653	+	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5654	+	PyObject *resultobj;
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 *)"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	+	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_BossTask_jobStates(PyObject *self, PyObject *args) {
5730	+	PyObject *resultobj;
5731	+	BossTask *arg1 = (BossTask *) 0 ;
5732	+	PyObject *result;
5733	+	PyObject * obj0 = 0 ;
5734	+
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	+	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_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5784	+	PyObject *resultobj;
5785	+	BossTask *arg1 = (BossTask *) 0 ;
5786	+	PyObject *result;
5787	+	PyObject * obj0 = 0 ;
5788	+
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 ;
#	Line 5456 | Line 5878 | static PyObject *_wrap_BossTask_jobProgr
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	+	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_BossTask_programExec(PyObject *self, PyObject *args) {
5931	+	PyObject *resultobj;
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 *)"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	+	{
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	+	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 * BossTask_swigregister(PyObject *self, PyObject *args) {
6029		PyObject *obj;
6030		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 6418 | Line 6987 | static PyMethodDef SwigMethods[] = {
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 },
#	Line 6433 | Line 7006 | static PyMethodDef SwigMethods[] = {
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 },
6436	–	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6437	–	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6438	–	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, 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_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7019	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7020		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6449	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6450	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7021		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
6452	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, 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 },
6460	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6461	–	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, 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 },
6465	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, 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 },
#	Line 6472 | Line 7045 | static PyMethodDef SwigMethods[] = {
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 },
#	Line 6504 | Line 7086 | static PyMethodDef SwigMethods[] = {
7086
7087		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7088
6507	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{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_std__vectorTBossTask_p_t[] = {{"_p_std__vectorTBossTask_p_t", 0, "std::vector<BossTask * > *", 0},{"_p_std__vectorTBossTask_p_t"},{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}};
6512	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{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}};
#	Line 6520 | Line 7104 | static swig_type_info _swigt__p_BossSess
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}};
6523	–	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}};
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[] = {
6528	–	_swigt__p_XMLDoc,
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_std__vectorTBossTask_p_t,
7116	>	_swigt__p_BossProgramExec,
7117	>	_swigt__p_BossChain,
7118		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6533	–	_swigt__p_std__ostream,
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,
#	Line 6541 | Line 7128 | _swigt__p_BossSession,
7128		_swigt__p_std__vectorTstd__string_t,
7129		_swigt__p_std__mapTstd__string_std__string_t,
7130		_swigt__p_BossAdministratorSession,
6544	–	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
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		};

Diff Legend

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