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.23 by gcodispo, Fri Mar 2 13:06:44 2007 UTC vs.
Revision 1.37 by gcodispo, Wed Jul 18 13:53:45 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,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	<	if ( !avoidCheck ) {
974	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
972	<	type, user, after, before, timeout );
973	<	}
974	<	PyObject * job_dict = PyList_New(0);
975	<	std::vector <std::string>
976	<	taskList = self->selectTasks( taskRange, before, after, user);
977	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
978	<	it!= taskList.end(); ++it ) {
979	<	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
980	<	}
981	<	return  job_dict;
982	<	}
983	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
984	<	std::string tmp;
985	<	BossAttributeContainer::const_iterator it_end = obj.end ();
986	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
987	<	it != it_end; ++it) {
988	<	// New code semantically isomorphic to the old one //Fabio
989	<
990	<	PyDict_SetItemString( dict, it->first.name().c_str(), PyString_FromString(it->second.value().c_str()) );
991	<	}
992	<	return dict;
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	<	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
976	>	void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
977	>	std::string tmp;
978	>	BossAttributeContainer::const_iterator it_end = obj.end ();
979	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
980	>	it != it_end; ++it) {
981	>
982	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
983	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
984	>	PyDict_SetItem( dict, key, val);
985	>	Py_DECREF(key);
986	>	Py_DECREF(val);
987	>	}
988	>	return;
989	>	}
990	>	void BossTask_jobDict(BossTask const *self,BossJob const *jobH,PyObject *job_dict){
991
992	<	PyObject * job_dict = PyDict_New();
992	>	//    PyObject * job_dict = PyDict_New();
993		std::string tmp;
994
995	<	BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
996	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
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	<	unsigned int size = it->size() +1;
1003	<	char * key = new char[ size ];
1004	<	strncpy( key, tmp.c_str(), size );
1005	<	tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1006	<	PyDict_SetItemString( job_dict, key,
1007	<	PyString_FromString( tmp.c_str() ) );
1008	<	delete [] key;
1002	>
1003	>	tmp = (*jobH)["JOB_SCHED_INFO."+(*it)];
1004	>	PyObject * key = PyString_FromString( it->c_str() );
1005	>	PyObject * val = PyString_FromString( tmp.c_str() );
1006	>	PyDict_SetItem( job_dict, key, val);
1007	>	Py_DECREF(key);
1008	>	Py_DECREF(val);
1009		}
1010	<	return job_dict;
1010	>	return;
1011		}
1012		PyObject *BossTask_jobsDict(BossTask *self){
1013
#	Line 1019 | Line 1015 | PyObject *BossTask_jobsDict(BossTask *se
1015		if ( self->job_begin () == self->job_end ()) self->load(ALL);
1016		for (BossTask::job_iterator jit = self->job_begin ();
1017		jit != self->job_end (); ++jit) {
1018	<	std::string id = (*jit)->chainId();
1019	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1020	<	PyObject * myid =  PyString_FromString(id.c_str() );
1021	<	PyDict_SetItem( job_dict, myid,tmp );
1018	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1019	>	PyObject * tmp_dict = PyDict_New();
1020	>	BossTask_jobDict( self, *jit, tmp_dict );
1021	>	PyDict_SetItem( job_dict, id, tmp_dict );
1022	>	Py_DECREF(id);
1023	>	Py_DECREF(tmp_dict);
1024	>	}
1025	>	return job_dict;
1026	>	}
1027	>	PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1028	>	if ( ! self->jobsInMemory() ) self->load( ALL, jobid );
1029	>	PyObject * job_dict = PyDict_New();
1030	>	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1031	>	return job_dict;
1032	>	}
1033	>	PyObject *BossTask_Chain(BossTask *self,std::string const &jobid){
1034	>
1035	>	PyObject * chain_dict = PyDict_New();
1036	>	BossAttributeContainer obj =
1037	>	self->chain( jobid ).getTableEntries("CHAIN");
1038	>	BossTask_appendToPyDict ( self, chain_dict, obj );
1039	>	return chain_dict;
1040	>	}
1041	>	PyObject *BossTask_jobStates(BossTask *self){
1042	>
1043	>	PyObject * job_dict = PyDict_New();
1044	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1045	>	for (BossTask::job_iterator jit = self->job_begin ();
1046	>	jit != self->job_end (); ++jit) {
1047	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1048	>	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1049	>	PyDict_SetItem( job_dict, id, status );
1050	>	Py_DECREF(id);
1051	>	Py_DECREF(status);
1052	>	}
1053	>	return job_dict;
1054	>	}
1055	>	PyObject *BossTask_joblist(BossTask *self){
1056	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1057	>	PyObject *  job_list = PyList_New( self->jobsInMemory() );
1058	>	unsigned int index = 0;
1059	>	for (BossTask::job_iterator jit = self->job_begin ();
1060	>	jit != self->job_end (); ++jit, ++index) {
1061	>	PyList_SetItem( job_list,
1062	>	index,
1063	>	PyString_FromString( ( (*jit)->chainId() ).c_str() )
1064	>	);
1065	>	}
1066	>	return job_list;
1067	>	}
1068	>	PyObject *BossTask_jobStatistic(BossTask *self){
1069	>
1070	>	PyObject * job_dict = PyDict_New();
1071	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1072	>	std::map< std::string, int > states;
1073	>	for (BossTask::job_iterator jit = self->job_begin ();
1074	>	jit != self->job_end (); ++jit) {
1075	>	++states[(**jit)["JOB.STATUS"]];
1076	>	}
1077	>
1078	>	std::map< std::string, int >::const_iterator end = states.end ();
1079	>	for (std::map< std::string, int >::const_iterator it = states.begin ();
1080	>	it != end; ++it) {
1081	>	PyObject * status = PyString_FromString( (it->first).c_str() );
1082	>	PyObject * jobs = PyString_FromFormat( "%d", it->second );
1083	>	PyDict_SetItem( job_dict, status, jobs );
1084	>	Py_DECREF(jobs);
1085	>	Py_DECREF(status);
1086		}
1087		return job_dict;
1088		}
#	Line 1067 | Line 1127 | PyObject *BossTask_jobPrograms(BossTask
1127		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1128		++programs_it  ) {
1129		std::string id = (programs_it->first)["PROGRAM.ID"];
1130	<	PyObject * tmp =  BossTask_progDict( self, programs_it );
1130	>	PyObject * tmp_dict =  BossTask_progDict( self, programs_it );
1131		PyObject * myid =  PyString_FromString(id.c_str() );
1132	<	PyDict_SetItem( job_dict, myid,tmp );
1132	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1133	>	Py_DECREF(myid);
1134	>	Py_DECREF(tmp_dict);
1135	>	}
1136	>	return job_dict;
1137	>	}
1138	>	PyObject *BossTask_program(BossTask *self,std::string const &jobid,std::string const &programId){
1139	>
1140	>	PyObject * job_dict = PyDict_New();
1141	>
1142	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1143	>	BossAttributeContainer obj =
1144	>	self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1145	>	BossTask_appendToPyDict ( self, job_dict, obj );
1146	>	return job_dict;
1147	>	}
1148	>	PyObject *BossTask_programExec(BossTask *self,std::string const &jobid,std::string const &programId){
1149	>
1150	>	PyObject * job_dict = PyDict_New();
1151	>
1152	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1153	>
1154	>	// PROGRAM_EXEC
1155	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1156	>	BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1157	>	BossTask_appendToPyDict ( self, job_dict, obj );
1158	>
1159	>	// SPECIFICS
1160	>	std::vector < BossAttributeContainer >::const_iterator it;
1161	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1162	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1163	>	BossTask_appendToPyDict ( self, job_dict, *it );
1164	>	}
1165	>	return job_dict;
1166	>	}
1167	>	PyObject *BossTask_specific(BossTask *self,std::string const &jobid,std::string const &programId){
1168	>
1169	>	PyObject * job_dict = PyDict_New();
1170	>
1171	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1172	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1173	>	BossAttributeContainer obj = programExec.getKeys ();
1174	>	BossTask_appendToPyDict ( self, job_dict, obj );
1175	>
1176	>	std::vector < BossAttributeContainer >::const_iterator it;
1177	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1178	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1179	>	BossTask_appendToPyDict ( self, job_dict, *it );
1180		}
1181		return job_dict;
1182		}
#	Line 2424 | Line 2531 | static PyObject *_wrap_BossSession_clear
2531		}
2532
2533
2534	+	static PyObject *_wrap_BossSession_task_begin(PyObject *self, PyObject *args) {
2535	+	PyObject *resultobj;
2536	+	BossSession *arg1 = (BossSession *) 0 ;
2537	+	BossSession::task_iterator result;
2538	+	PyObject * obj0 = 0 ;
2539	+
2540	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_begin",&obj0)) goto fail;
2541	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2542	+	{
2543	+	try {
2544	+	result = ((BossSession const *)arg1)->task_begin();
2545	+
2546	+	}catch (const BossSchedFailure & e) {
2547	+	PyErr_SetString ( SchedulerError, e.what() );
2548	+	return NULL;
2549	+	}catch (const std::exception& e) {
2550	+	PyErr_SetString ( BossError, e.what() );
2551	+	return NULL;
2552	+	}
2553	+	}
2554	+	{
2555	+	BossSession::task_iterator * resultptr;
2556	+	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2557	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2558	+	}
2559	+	return resultobj;
2560	+	fail:
2561	+	return NULL;
2562	+	}
2563	+
2564	+
2565	+	static PyObject *_wrap_BossSession_task_end(PyObject *self, PyObject *args) {
2566	+	PyObject *resultobj;
2567	+	BossSession *arg1 = (BossSession *) 0 ;
2568	+	BossSession::task_iterator result;
2569	+	PyObject * obj0 = 0 ;
2570	+
2571	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_end",&obj0)) goto fail;
2572	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2573	+	{
2574	+	try {
2575	+	result = ((BossSession const *)arg1)->task_end();
2576	+
2577	+	}catch (const BossSchedFailure & e) {
2578	+	PyErr_SetString ( SchedulerError, e.what() );
2579	+	return NULL;
2580	+	}catch (const std::exception& e) {
2581	+	PyErr_SetString ( BossError, e.what() );
2582	+	return NULL;
2583	+	}
2584	+	}
2585	+	{
2586	+	BossSession::task_iterator * resultptr;
2587	+	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2588	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2589	+	}
2590	+	return resultobj;
2591	+	fail:
2592	+	return NULL;
2593	+	}
2594	+
2595	+
2596	+	static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
2597	+	PyObject *resultobj;
2598	+	BossSession *arg1 = (BossSession *) 0 ;
2599	+	unsigned int result;
2600	+	PyObject * obj0 = 0 ;
2601	+
2602	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
2603	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2604	+	{
2605	+	try {
2606	+	result = (unsigned int)((BossSession const *)arg1)->tasksInMemory();
2607	+
2608	+	}catch (const BossSchedFailure & e) {
2609	+	PyErr_SetString ( SchedulerError, e.what() );
2610	+	return NULL;
2611	+	}catch (const std::exception& e) {
2612	+	PyErr_SetString ( BossError, e.what() );
2613	+	return NULL;
2614	+	}
2615	+	}
2616	+	resultobj = PyInt_FromLong((long)result);
2617	+	return resultobj;
2618	+	fail:
2619	+	return NULL;
2620	+	}
2621	+
2622	+
2623	+	static PyObject *_wrap_BossSession_locate(PyObject *self, PyObject *args) {
2624	+	PyObject *resultobj;
2625	+	BossSession *arg1 = (BossSession *) 0 ;
2626	+	unsigned int arg2 ;
2627	+	BossTask *result;
2628	+	PyObject * obj0 = 0 ;
2629	+	PyObject * obj1 = 0 ;
2630	+
2631	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
2632	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2633	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
2634	+	if (PyErr_Occurred()) SWIG_fail;
2635	+	{
2636	+	try {
2637	+	result = (BossTask *)((BossSession const *)arg1)->locate(arg2);
2638	+
2639	+	}catch (const BossSchedFailure & e) {
2640	+	PyErr_SetString ( SchedulerError, e.what() );
2641	+	return NULL;
2642	+	}catch (const std::exception& e) {
2643	+	PyErr_SetString ( BossError, e.what() );
2644	+	return NULL;
2645	+	}
2646	+	}
2647	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2648	+	return resultobj;
2649	+	fail:
2650	+	return NULL;
2651	+	}
2652	+
2653	+
2654		static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2655		PyObject *resultobj;
2656		BossSession *arg1 = (BossSession *) 0 ;
#	Line 2891 | Line 3118 | static PyObject *_wrap_BossSession_listM
3118		BossSession *arg1 = (BossSession *) 0 ;
3119		std::string *arg2 = 0 ;
3120		std::string *arg3 = 0 ;
3121	<	bool arg4 = (bool) false ;
3121	>	std::string const &arg4_defvalue = "" ;
3122	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3123		std::string const &arg5_defvalue = "" ;
3124		std::string *arg5 = (std::string *) &arg5_defvalue ;
3125	<	std::string const &arg6_defvalue = "" ;
2898	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
2899	<	unsigned int arg7 = (unsigned int) 0 ;
3125	>	unsigned int arg6 = (unsigned int) 0 ;
3126		std::vector<std::string > result;
3127		std::string temp2 ;
3128		std::string temp3 ;
3129	+	std::string temp4 ;
3130		std::string temp5 ;
2904	–	std::string temp6 ;
3131		PyObject * obj0 = 0 ;
3132		PyObject * obj1 = 0 ;
3133		PyObject * obj2 = 0 ;
3134		PyObject * obj3 = 0 ;
3135		PyObject * obj4 = 0 ;
3136		PyObject * obj5 = 0 ;
2911	–	PyObject * obj6 = 0 ;
3137
3138	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3138	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3139		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3140		{
3141		if (PyString_Check(obj1)) {
#	Line 2929 | Line 3154 | static PyObject *_wrap_BossSession_listM
3154		}
3155		}
3156		if (obj3) {
2932	–	arg4 = PyInt_AsLong(obj3) ? true : false;
2933	–	if (PyErr_Occurred()) SWIG_fail;
2934	–	}
2935	–	if (obj4) {
3157		{
3158	<	if (PyString_Check(obj4)) {
3159	<	temp5 = std::string(PyString_AsString(obj4));
3160	<	arg5 = &temp5;
3158	>	if (PyString_Check(obj3)) {
3159	>	temp4 = std::string(PyString_AsString(obj3));
3160	>	arg4 = &temp4;
3161		}else {
3162		SWIG_exception(SWIG_TypeError, "string expected");
3163		}
3164		}
3165		}
3166	<	if (obj5) {
3166	>	if (obj4) {
3167		{
3168	<	if (PyString_Check(obj5)) {
3169	<	temp6 = std::string(PyString_AsString(obj5));
3170	<	arg6 = &temp6;
3168	>	if (PyString_Check(obj4)) {
3169	>	temp5 = std::string(PyString_AsString(obj4));
3170	>	arg5 = &temp5;
3171		}else {
3172		SWIG_exception(SWIG_TypeError, "string expected");
3173		}
3174		}
3175		}
3176	<	if (obj6) {
3177	<	arg7 = (unsigned int) PyInt_AsLong(obj6);
3176	>	if (obj5) {
3177	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3178		if (PyErr_Occurred()) SWIG_fail;
3179		}
3180		{
3181		try {
3182	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
3182	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3183
3184		}catch (const BossSchedFailure & e) {
3185		PyErr_SetString ( SchedulerError, e.what() );
#	Line 2980 | Line 3201 | static PyObject *_wrap_BossSession_listM
3201		}
3202
3203
3204	<	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3204	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3205		PyObject *resultobj;
3206		BossSession *arg1 = (BossSession *) 0 ;
3207		int arg2 = (int) SCHEDULED ;
#	Line 2995 | Line 3216 | static PyObject *_wrap_BossSession_sched
3216		std::string arg8 = (std::string) "" ;
3217		std::string arg9 = (std::string) "" ;
3218		unsigned int arg10 = (unsigned int) 0 ;
3219	+	bool arg11 = (bool) false ;
3220		std::string temp3 ;
3221		std::string temp4 ;
3222		std::string temp5 ;
#	Line 3007 | Line 3229 | static PyObject *_wrap_BossSession_sched
3229		PyObject * obj7 = 0 ;
3230		PyObject * obj8 = 0 ;
3231		PyObject * obj9 = 0 ;
3232	+	PyObject * obj10 = 0 ;
3233
3234	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3234	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3235		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3236		if (obj2) {
3237		{
#	Line 3076 | Line 3299 | static PyObject *_wrap_BossSession_sched
3299		arg10 = (unsigned int) PyInt_AsLong(obj9);
3300		if (PyErr_Occurred()) SWIG_fail;
3301		}
3302	+	if (obj10) {
3303	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3304	+	if (PyErr_Occurred()) SWIG_fail;
3305	+	}
3306		{
3307		try {
3308	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3308	>	(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3309
3310		}catch (const BossSchedFailure & e) {
3311		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3095 | Line 3322 | static PyObject *_wrap_BossSession_sched
3322		}
3323
3324
3325	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3325	>	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3326		PyObject *resultobj;
3327		BossSession *arg1 = (BossSession *) 0 ;
3328	<	std::string const &arg2_defvalue = "all" ;
3329	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3103	<	std::string const &arg3_defvalue = "" ;
3104	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3105	<	std::string const &arg4_defvalue = "" ;
3106	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3107	<	std::string const &arg5_defvalue = "" ;
3108	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3109	<	std::vector<std::string > result;
3328	>	std::string *arg2 = 0 ;
3329	>	unsigned int result;
3330		std::string temp2 ;
3111	–	std::string temp3 ;
3112	–	std::string temp4 ;
3113	–	std::string temp5 ;
3331		PyObject * obj0 = 0 ;
3332		PyObject * obj1 = 0 ;
3116	–	PyObject * obj2 = 0 ;
3117	–	PyObject * obj3 = 0 ;
3118	–	PyObject * obj4 = 0 ;
3333
3334	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3334	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3335		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3336	<	if (obj1) {
3337	<	{
3338	<	if (PyString_Check(obj1)) {
3339	<	temp2 = std::string(PyString_AsString(obj1));
3340	<	arg2 = &temp2;
3341	<	}else {
3128	<	SWIG_exception(SWIG_TypeError, "string expected");
3129	<	}
3130	<	}
3131	<	}
3132	<	if (obj2) {
3133	<	{
3134	<	if (PyString_Check(obj2)) {
3135	<	temp3 = std::string(PyString_AsString(obj2));
3136	<	arg3 = &temp3;
3137	<	}else {
3138	<	SWIG_exception(SWIG_TypeError, "string expected");
3139	<	}
3140	<	}
3141	<	}
3142	<	if (obj3) {
3143	<	{
3144	<	if (PyString_Check(obj3)) {
3145	<	temp4 = std::string(PyString_AsString(obj3));
3146	<	arg4 = &temp4;
3147	<	}else {
3148	<	SWIG_exception(SWIG_TypeError, "string expected");
3149	<	}
3150	<	}
3151	<	}
3152	<	if (obj4) {
3153	<	{
3154	<	if (PyString_Check(obj4)) {
3155	<	temp5 = std::string(PyString_AsString(obj4));
3156	<	arg5 = &temp5;
3157	<	}else {
3158	<	SWIG_exception(SWIG_TypeError, "string expected");
3159	<	}
3336	>	{
3337	>	if (PyString_Check(obj1)) {
3338	>	temp2 = std::string(PyString_AsString(obj1));
3339	>	arg2 = &temp2;
3340	>	}else {
3341	>	SWIG_exception(SWIG_TypeError, "string expected");
3342		}
3343		}
3344		{
3345		try {
3346	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3346	>	result = (unsigned int)(arg1)->getTasksByName((std::string const &)*arg2);
3347
3348		}catch (const BossSchedFailure & e) {
3349		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3171 | Line 3353 | static PyObject *_wrap_BossSession_selec
3353		return NULL;
3354		}
3355		}
3356	<	{
3175	<	resultobj = PyTuple_New((&result)->size());
3176	<	for (unsigned int i=0; i<(&result)->size(); i++)
3177	<	PyTuple_SetItem(resultobj,i,
3178	<	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3179	<	}
3356	>	resultobj = PyInt_FromLong((long)result);
3357		return resultobj;
3358		fail:
3359		return NULL;
3360		}
3361
3362
3363	<	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3363	>	static PyObject *_wrap_BossSession_getTasksByTaskInfo(PyObject *self, PyObject *args) {
3364		PyObject *resultobj;
3365		BossSession *arg1 = (BossSession *) 0 ;
3366	<	int arg2 = (int) SCHEDULED ;
3367	<	std::string const &arg3_defvalue = "all" ;
3368	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3192	<	std::string const &arg4_defvalue = "all" ;
3193	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3194	<	std::string const &arg5_defvalue = "" ;
3195	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3196	<	std::string arg6 = (std::string) "" ;
3197	<	std::string arg7 = (std::string) "" ;
3198	<	std::string arg8 = (std::string) "" ;
3199	<	std::string arg9 = (std::string) "" ;
3200	<	unsigned int arg10 = (unsigned int) 0 ;
3201	<	bool arg11 = (bool) false ;
3202	<	SwigValueWrapper< std::vector<BossTask * > > result;
3203	<	std::string temp3 ;
3204	<	std::string temp4 ;
3205	<	std::string temp5 ;
3366	>	std::string *arg2 = 0 ;
3367	>	unsigned int result;
3368	>	std::string temp2 ;
3369		PyObject * obj0 = 0 ;
3370	<	PyObject * obj2 = 0 ;
3208	<	PyObject * obj3 = 0 ;
3209	<	PyObject * obj4 = 0 ;
3210	<	PyObject * obj5 = 0 ;
3211	<	PyObject * obj6 = 0 ;
3212	<	PyObject * obj7 = 0 ;
3213	<	PyObject * obj8 = 0 ;
3214	<	PyObject * obj9 = 0 ;
3215	<	PyObject * obj10 = 0 ;
3370	>	PyObject * obj1 = 0 ;
3371
3372	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3372	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByTaskInfo",&obj0,&obj1)) goto fail;
3373		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3374	<	if (obj2) {
3375	<	{
3376	<	if (PyString_Check(obj2)) {
3377	<	temp3 = std::string(PyString_AsString(obj2));
3378	<	arg3 = &temp3;
3224	<	}else {
3225	<	SWIG_exception(SWIG_TypeError, "string expected");
3226	<	}
3227	<	}
3228	<	}
3229	<	if (obj3) {
3230	<	{
3231	<	if (PyString_Check(obj3)) {
3232	<	temp4 = std::string(PyString_AsString(obj3));
3233	<	arg4 = &temp4;
3234	<	}else {
3235	<	SWIG_exception(SWIG_TypeError, "string expected");
3236	<	}
3237	<	}
3238	<	}
3239	<	if (obj4) {
3240	<	{
3241	<	if (PyString_Check(obj4)) {
3242	<	temp5 = std::string(PyString_AsString(obj4));
3243	<	arg5 = &temp5;
3244	<	}else {
3245	<	SWIG_exception(SWIG_TypeError, "string expected");
3246	<	}
3247	<	}
3248	<	}
3249	<	if (obj5) {
3250	<	{
3251	<	if (PyString_Check(obj5))
3252	<	arg6 = std::string(PyString_AsString(obj5));
3253	<	else
3254	<	SWIG_exception(SWIG_TypeError, "string expected");
3255	<	}
3256	<	}
3257	<	if (obj6) {
3258	<	{
3259	<	if (PyString_Check(obj6))
3260	<	arg7 = std::string(PyString_AsString(obj6));
3261	<	else
3374	>	{
3375	>	if (PyString_Check(obj1)) {
3376	>	temp2 = std::string(PyString_AsString(obj1));
3377	>	arg2 = &temp2;
3378	>	}else {
3379		SWIG_exception(SWIG_TypeError, "string expected");
3380		}
3381		}
3382	<	if (obj7) {
3383	<	{
3384	<	if (PyString_Check(obj7))
3385	<	arg8 = std::string(PyString_AsString(obj7));
3386	<	else
3387	<	SWIG_exception(SWIG_TypeError, "string expected");
3382	>	{
3383	>	try {
3384	>	result = (unsigned int)(arg1)->getTasksByTaskInfo((std::string const &)*arg2);
3385	>
3386	>	}catch (const BossSchedFailure & e) {
3387	>	PyErr_SetString ( SchedulerError, e.what() );
3388	>	return NULL;
3389	>	}catch (const std::exception& e) {
3390	>	PyErr_SetString ( BossError, e.what() );
3391	>	return NULL;
3392		}
3393		}
3394	<	if (obj8) {
3395	<	{
3396	<	if (PyString_Check(obj8))
3397	<	arg9 = std::string(PyString_AsString(obj8));
3398	<	else
3394	>	resultobj = PyInt_FromLong((long)result);
3395	>	return resultobj;
3396	>	fail:
3397	>	return NULL;
3398	>	}
3399	>
3400	>
3401	>	static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3402	>	PyObject *resultobj;
3403	>	BossSession *arg1 = (BossSession *) 0 ;
3404	>	std::string *arg2 = 0 ;
3405	>	unsigned int result;
3406	>	std::string temp2 ;
3407	>	PyObject * obj0 = 0 ;
3408	>	PyObject * obj1 = 0 ;
3409	>
3410	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3411	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3412	>	{
3413	>	if (PyString_Check(obj1)) {
3414	>	temp2 = std::string(PyString_AsString(obj1));
3415	>	arg2 = &temp2;
3416	>	}else {
3417		SWIG_exception(SWIG_TypeError, "string expected");
3418		}
3419		}
3281	–	if (obj9) {
3282	–	arg10 = (unsigned int) PyInt_AsLong(obj9);
3283	–	if (PyErr_Occurred()) SWIG_fail;
3284	–	}
3285	–	if (obj10) {
3286	–	arg11 = PyInt_AsLong(obj10) ? true : false;
3287	–	if (PyErr_Occurred()) SWIG_fail;
3288	–	}
3420		{
3421		try {
3422	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3422	>	result = (unsigned int)(arg1)->getTasksByJobName((std::string const &)*arg2);
3423
3424		}catch (const BossSchedFailure & e) {
3425		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3298 | Line 3429 | static PyObject *_wrap_BossSession_query
3429		return NULL;
3430		}
3431		}
3432	<	{
3302	<	std::vector<BossTask * > * resultptr;
3303	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3304	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3305	<	}
3432	>	resultobj = PyInt_FromLong((long)result);
3433		return resultobj;
3434		fail:
3435		return NULL;
#	Line 3460 | Line 3587 | static PyObject *_wrap_BossSession_sched
3587		std::string const &arg5_defvalue = "" ;
3588		std::string *arg5 = (std::string *) &arg5_defvalue ;
3589		unsigned int arg6 = (unsigned int) 0 ;
3463	–	bool arg7 = (bool) false ;
3590		PyObject *result;
3591		std::string temp2 ;
3592		std::string temp3 ;
#	Line 3472 | Line 3598 | static PyObject *_wrap_BossSession_sched
3598		PyObject * obj3 = 0 ;
3599		PyObject * obj4 = 0 ;
3600		PyObject * obj5 = 0 ;
3475	–	PyObject * obj6 = 0 ;
3601
3602	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3602	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3603		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3604		{
3605		if (PyString_Check(obj1)) {
#	Line 3516 | Line 3641 | static PyObject *_wrap_BossSession_sched
3641		arg6 = (unsigned int) PyInt_AsLong(obj5);
3642		if (PyErr_Occurred()) SWIG_fail;
3643		}
3519	–	if (obj6) {
3520	–	arg7 = PyInt_AsLong(obj6) ? true : false;
3521	–	if (PyErr_Occurred()) SWIG_fail;
3522	–	}
3644		{
3645		try {
3646	<	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3646	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3647
3648		}catch (const BossSchedFailure & e) {
3649		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3539 | Line 3660 | static PyObject *_wrap_BossSession_sched
3660		}
3661
3662
3663	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3663	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3664		PyObject *resultobj;
3665		BossSession *arg1 = (BossSession *) 0 ;
3666		int arg2 = (int) SCHEDULED ;
#	Line 3555 | Line 3676 | static PyObject *_wrap_BossSession_query
3676		std::string arg9 = (std::string) "" ;
3677		unsigned int arg10 = (unsigned int) 0 ;
3678		bool arg11 = (bool) false ;
3558	–	PyObject *result;
3679		std::string temp3 ;
3680		std::string temp4 ;
3681		std::string temp5 ;
#	Line 3570 | Line 3690 | static PyObject *_wrap_BossSession_query
3690		PyObject * obj9 = 0 ;
3691		PyObject * obj10 = 0 ;
3692
3693	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3693	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3694		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3695		if (obj2) {
3696		{
#	Line 3644 | Line 3764 | static PyObject *_wrap_BossSession_query
3764		}
3765		{
3766		try {
3767	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3767	>	BossSession_schedulerQuery(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3768
3769		}catch (const BossSchedFailure & e) {
3770		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3654 | Line 3774 | static PyObject *_wrap_BossSession_query
3774		return NULL;
3775		}
3776		}
3777	<	resultobj = result;
3777	>	Py_INCREF(Py_None); resultobj = Py_None;
3778		return resultobj;
3779		fail:
3780		return NULL;
#	Line 3668 | Line 3788 | static PyObject * BossSession_swigregist
3788		Py_INCREF(obj);
3789		return Py_BuildValue((char *)"");
3790		}
3791	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3791	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3792	>	PyObject *resultobj;
3793	>	char *arg1 ;
3794	>	BossTaskException *result;
3795	>
3796	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3797	>	{
3798	>	try {
3799	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3800	>
3801	>	}catch (const BossSchedFailure & e) {
3802	>	PyErr_SetString ( SchedulerError, e.what() );
3803	>	return NULL;
3804	>	}catch (const std::exception& e) {
3805	>	PyErr_SetString ( BossError, e.what() );
3806	>	return NULL;
3807	>	}
3808	>	}
3809	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3810	>	return resultobj;
3811	>	fail:
3812	>	return NULL;
3813	>	}
3814	>
3815	>
3816	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3817		PyObject *resultobj;
3818		BossTaskException *arg1 = (BossTaskException *) 0 ;
3674	–	char *arg2 ;
3819		PyObject * obj0 = 0 ;
3820
3821	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3821	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3822		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3823		{
3824	<	if (arg2) {
3825	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3826	<	strcpy((char *) arg1->key,arg2);
3827	<	}else {
3828	<	arg1->key = 0;
3824	>	try {
3825	>	delete arg1;
3826	>
3827	>	}catch (const BossSchedFailure & e) {
3828	>	PyErr_SetString ( SchedulerError, e.what() );
3829	>	return NULL;
3830	>	}catch (const std::exception& e) {
3831	>	PyErr_SetString ( BossError, e.what() );
3832	>	return NULL;
3833		}
3834		}
3835		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3691 | Line 3839 | static PyObject *_wrap_BossTaskException
3839		}
3840
3841
3842	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3842	>	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3843	>	PyObject *obj;
3844	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3845	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3846	>	Py_INCREF(obj);
3847	>	return Py_BuildValue((char *)"");
3848	>	}
3849	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3850		PyObject *resultobj;
3851	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3852	<	char *result;
3851	>	BossTask *arg1 = (BossTask *) 0 ;
3852	>	BossTask::job_iterator result;
3853		PyObject * obj0 = 0 ;
3854
3855	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3856	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3857	<	result = (char *) ((arg1)->key);
3855	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3856	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3857	>	{
3858	>	try {
3859	>	result = ((BossTask const *)arg1)->job_begin();
3860	>
3861	>	}catch (const BossSchedFailure & e) {
3862	>	PyErr_SetString ( SchedulerError, e.what() );
3863	>	return NULL;
3864	>	}catch (const std::exception& e) {
3865	>	PyErr_SetString ( BossError, e.what() );
3866	>	return NULL;
3867	>	}
3868	>	}
3869	>	{
3870	>	BossTask::job_iterator * resultptr;
3871	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3872	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3873	>	}
3874	>	return resultobj;
3875	>	fail:
3876	>	return NULL;
3877	>	}
3878	>
3879	>
3880	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3881	>	PyObject *resultobj;
3882	>	BossTask *arg1 = (BossTask *) 0 ;
3883	>	BossTask::job_iterator result;
3884	>	PyObject * obj0 = 0 ;
3885
3886	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3886	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3887	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3888	>	{
3889	>	try {
3890	>	result = ((BossTask const *)arg1)->job_end();
3891	>
3892	>	}catch (const BossSchedFailure & e) {
3893	>	PyErr_SetString ( SchedulerError, e.what() );
3894	>	return NULL;
3895	>	}catch (const std::exception& e) {
3896	>	PyErr_SetString ( BossError, e.what() );
3897	>	return NULL;
3898	>	}
3899	>	}
3900	>	{
3901	>	BossTask::job_iterator * resultptr;
3902	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3903	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3904	>	}
3905		return resultobj;
3906		fail:
3907		return NULL;
3908		}
3909
3910
3911	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3911	>	static PyObject *_wrap_BossTask_jobsInMemory(PyObject *self, PyObject *args) {
3912		PyObject *resultobj;
3913	<	char *arg1 ;
3914	<	BossTaskException *result;
3913	>	BossTask *arg1 = (BossTask *) 0 ;
3914	>	unsigned int result;
3915	>	PyObject * obj0 = 0 ;
3916
3917	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3917	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsInMemory",&obj0)) goto fail;
3918	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3919		{
3920		try {
3921	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3921	>	result = (unsigned int)((BossTask const *)arg1)->jobsInMemory();
3922
3923		}catch (const BossSchedFailure & e) {
3924		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3726 | Line 3928 | static PyObject *_wrap_new_BossTaskExcep
3928		return NULL;
3929		}
3930		}
3931	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3931	>	resultobj = PyInt_FromLong((long)result);
3932		return resultobj;
3933		fail:
3934		return NULL;
3935		}
3936
3937
3938	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3938	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3939		PyObject *resultobj;
3940	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3941	<	char *result;
3940	>	BossTask *arg1 = (BossTask *) 0 ;
3941	>	BossJob *arg2 = (BossJob *) 0 ;
3942	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
3943		PyObject * obj0 = 0 ;
3944	+	PyObject * obj1 = 0 ;
3945
3946	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3947	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3946	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
3947	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3948	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3949		{
3950		try {
3951	<	result = (char *)((BossTaskException const *)arg1)->what();
3951	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
3952
3953		}catch (const BossSchedFailure & e) {
3954		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3753 | Line 3958 | static PyObject *_wrap_BossTaskException
3958		return NULL;
3959		}
3960		}
3961	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3961	>	{
3962	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
3963	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
3964	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
3965	>	}
3966		return resultobj;
3967		fail:
3968		return NULL;
3969		}
3970
3971
3972	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3972	>	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
3973		PyObject *resultobj;
3974	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3974	>	BossTask *arg1 = (BossTask *) 0 ;
3975	>	BossJob *arg2 = (BossJob *) 0 ;
3976	>	std::string *arg3 = 0 ;
3977	>	BossProgram result;
3978	>	std::string temp3 ;
3979		PyObject * obj0 = 0 ;
3980	+	PyObject * obj1 = 0 ;
3981	+	PyObject * obj2 = 0 ;
3982
3983	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3984	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3983	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
3984	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3985	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3986	>	{
3987	>	if (PyString_Check(obj2)) {
3988	>	temp3 = std::string(PyString_AsString(obj2));
3989	>	arg3 = &temp3;
3990	>	}else {
3991	>	SWIG_exception(SWIG_TypeError, "string expected");
3992	>	}
3993	>	}
3994		{
3995		try {
3996	<	delete arg1;
3996	>	result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
3997
3998		}catch (const BossSchedFailure & e) {
3999		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3779 | Line 4003 | static PyObject *_wrap_delete_BossTaskEx
4003		return NULL;
4004		}
4005		}
4006	<	Py_INCREF(Py_None); resultobj = Py_None;
4006	>	{
4007	>	BossProgram * resultptr;
4008	>	resultptr = new BossProgram((BossProgram &) result);
4009	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4010	>	}
4011		return resultobj;
4012		fail:
4013		return NULL;
4014		}
4015
4016
4017	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
4018	<	PyObject *obj;
4019	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4020	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
4021	<	Py_INCREF(obj);
4022	<	return Py_BuildValue((char *)"");
4017	>	static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4018	>	PyObject *resultobj;
4019	>	BossTask *arg1 = (BossTask *) 0 ;
4020	>	BossJob *arg2 = (BossJob *) 0 ;
4021	>	std::string *arg3 = 0 ;
4022	>	BossProgramExec result;
4023	>	std::string temp3 ;
4024	>	PyObject * obj0 = 0 ;
4025	>	PyObject * obj1 = 0 ;
4026	>	PyObject * obj2 = 0 ;
4027	>
4028	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4029	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4030	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4031	>	{
4032	>	if (PyString_Check(obj2)) {
4033	>	temp3 = std::string(PyString_AsString(obj2));
4034	>	arg3 = &temp3;
4035	>	}else {
4036	>	SWIG_exception(SWIG_TypeError, "string expected");
4037	>	}
4038	>	}
4039	>	{
4040	>	try {
4041	>	result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4042	>
4043	>	}catch (const BossSchedFailure & e) {
4044	>	PyErr_SetString ( SchedulerError, e.what() );
4045	>	return NULL;
4046	>	}catch (const std::exception& e) {
4047	>	PyErr_SetString ( BossError, e.what() );
4048	>	return NULL;
4049	>	}
4050	>	}
4051	>	{
4052	>	BossProgramExec * resultptr;
4053	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4054	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4055	>	}
4056	>	return resultobj;
4057	>	fail:
4058	>	return NULL;
4059		}
4060	+
4061	+
4062		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
4063		PyObject *resultobj;
4064		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 4043 | Line 4309 | static PyObject *_wrap_BossTask_name(PyO
4309		}
4310
4311
4312	<	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4312	>	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4313		PyObject *resultobj;
4314		BossTask *arg1 = (BossTask *) 0 ;
4315	<	std::map<std::string,std::string > result;
4315	>	std::string *arg2 = 0 ;
4316	>	BossChain result;
4317	>	std::string temp2 ;
4318		PyObject * obj0 = 0 ;
4319	+	PyObject * obj1 = 0 ;
4320
4321	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4321	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4322		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4323		{
4324	<	try {
4325	<	result = ((BossTask const *)arg1)->taskMap();
4326	<
4327	<	}catch (const BossSchedFailure & e) {
4328	<	PyErr_SetString ( SchedulerError, e.what() );
4060	<	return NULL;
4061	<	}catch (const std::exception& e) {
4062	<	PyErr_SetString ( BossError, e.what() );
4063	<	return NULL;
4324	>	if (PyString_Check(obj1)) {
4325	>	temp2 = std::string(PyString_AsString(obj1));
4326	>	arg2 = &temp2;
4327	>	}else {
4328	>	SWIG_exception(SWIG_TypeError, "string expected");
4329		}
4330		}
4331		{
4067	–	resultobj = PyDict_New();
4068	–	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4069	–	PyDict_SetItem(resultobj,
4070	–	SwigString_FromString(i->first),
4071	–	SwigString_FromString(i->second));
4072	–	}
4073	–	}
4074	–	return resultobj;
4075	–	fail:
4076	–	return NULL;
4077	–	}
4078	–
4079	–
4080	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4081	–	PyObject *resultobj;
4082	–	BossTask *arg1 = (BossTask *) 0 ;
4083	–	BossTask::job_iterator result;
4084	–	PyObject * obj0 = 0 ;
4085	–
4086	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4087	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4088	–	{
4332		try {
4333	<	result = ((BossTask const *)arg1)->job_begin();
4333	>	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4334
4335		}catch (const BossSchedFailure & e) {
4336		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4098 | Line 4341 | static PyObject *_wrap_BossTask_job_begi
4341		}
4342		}
4343		{
4344	<	BossTask::job_iterator * resultptr;
4345	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4346	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4344	>	BossChain * resultptr;
4345	>	resultptr = new BossChain((BossChain &) result);
4346	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4347		}
4348		return resultobj;
4349		fail:
#	Line 4108 | Line 4351 | static PyObject *_wrap_BossTask_job_begi
4351		}
4352
4353
4354	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4354	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4355		PyObject *resultobj;
4356		BossTask *arg1 = (BossTask *) 0 ;
4357	<	BossTask::job_iterator result;
4357	>	std::map<std::string,std::string > result;
4358		PyObject * obj0 = 0 ;
4359
4360	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4360	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4361		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4362		{
4363		try {
4364	<	result = ((BossTask const *)arg1)->job_end();
4364	>	result = ((BossTask const *)arg1)->taskMap();
4365
4366		}catch (const BossSchedFailure & e) {
4367		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4129 | Line 4372 | static PyObject *_wrap_BossTask_job_end(
4372		}
4373		}
4374		{
4375	<	BossTask::job_iterator * resultptr;
4376	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4377	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4375	>	resultobj = PyDict_New();
4376	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4377	>	PyDict_SetItem(resultobj,
4378	>	SwigString_FromString(i->first),
4379	>	SwigString_FromString(i->second));
4380	>	}
4381		}
4382		return resultobj;
4383		fail:
#	Line 4354 | Line 4600 | static PyObject *_wrap_BossTask_programs
4600		}
4601
4602
4357	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4358	–	PyObject *resultobj;
4359	–	BossTask *arg1 = (BossTask *) 0 ;
4360	–	BossJob *arg2 = (BossJob *) 0 ;
4361	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4362	–	PyObject * obj0 = 0 ;
4363	–	PyObject * obj1 = 0 ;
4364	–
4365	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4366	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4367	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4368	–	{
4369	–	try {
4370	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4371	–
4372	–	}catch (const BossSchedFailure & e) {
4373	–	PyErr_SetString ( SchedulerError, e.what() );
4374	–	return NULL;
4375	–	}catch (const std::exception& e) {
4376	–	PyErr_SetString ( BossError, e.what() );
4377	–	return NULL;
4378	–	}
4379	–	}
4380	–	{
4381	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4382	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4383	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4384	–	}
4385	–	return resultobj;
4386	–	fail:
4387	–	return NULL;
4388	–	}
4389	–
4390	–
4603		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4604		PyObject *resultobj;
4605		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4901 | Line 5113 | static PyObject *_wrap_BossTask_getOutpu
5113		}
5114
5115
5116	+	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
5117	+	PyObject *resultobj;
5118	+	BossTask *arg1 = (BossTask *) 0 ;
5119	+	std::string *arg2 = 0 ;
5120	+	int result;
5121	+	std::string temp2 ;
5122	+	PyObject * obj0 = 0 ;
5123	+	PyObject * obj1 = 0 ;
5124	+
5125	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5126	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5127	+	{
5128	+	if (PyString_Check(obj1)) {
5129	+	temp2 = std::string(PyString_AsString(obj1));
5130	+	arg2 = &temp2;
5131	+	}else {
5132	+	SWIG_exception(SWIG_TypeError, "string expected");
5133	+	}
5134	+	}
5135	+	{
5136	+	try {
5137	+	result = (int)(arg1)->loadByName((std::string const &)*arg2);
5138	+
5139	+	}catch (const BossSchedFailure & e) {
5140	+	PyErr_SetString ( SchedulerError, e.what() );
5141	+	return NULL;
5142	+	}catch (const std::exception& e) {
5143	+	PyErr_SetString ( BossError, e.what() );
5144	+	return NULL;
5145	+	}
5146	+	}
5147	+	resultobj = PyInt_FromLong((long)result);
5148	+	return resultobj;
5149	+	fail:
5150	+	return NULL;
5151	+	}
5152	+
5153	+
5154		static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
5155		PyObject *resultobj;
5156		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4997 | Line 5247 | static PyObject *_wrap_BossTask_load(PyO
5247		}
5248
5249
5250	+	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5251	+	PyObject *resultobj;
5252	+	BossTask *arg1 = (BossTask *) 0 ;
5253	+	int arg2 = (int) SCHEDULED ;
5254	+	std::string const &arg3_defvalue = "all" ;
5255	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
5256	+	std::string const &arg4_defvalue = "" ;
5257	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
5258	+	std::string arg5 = (std::string) "" ;
5259	+	std::string arg6 = (std::string) "" ;
5260	+	std::string arg7 = (std::string) "" ;
5261	+	std::string arg8 = (std::string) "" ;
5262	+	unsigned int arg9 = (unsigned int) 0 ;
5263	+	int result;
5264	+	std::string temp3 ;
5265	+	std::string temp4 ;
5266	+	PyObject * obj0 = 0 ;
5267	+	PyObject * obj2 = 0 ;
5268	+	PyObject * obj3 = 0 ;
5269	+	PyObject * obj4 = 0 ;
5270	+	PyObject * obj5 = 0 ;
5271	+	PyObject * obj6 = 0 ;
5272	+	PyObject * obj7 = 0 ;
5273	+	PyObject * obj8 = 0 ;
5274	+
5275	+	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5276	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5277	+	if (obj2) {
5278	+	{
5279	+	if (PyString_Check(obj2)) {
5280	+	temp3 = std::string(PyString_AsString(obj2));
5281	+	arg3 = &temp3;
5282	+	}else {
5283	+	SWIG_exception(SWIG_TypeError, "string expected");
5284	+	}
5285	+	}
5286	+	}
5287	+	if (obj3) {
5288	+	{
5289	+	if (PyString_Check(obj3)) {
5290	+	temp4 = std::string(PyString_AsString(obj3));
5291	+	arg4 = &temp4;
5292	+	}else {
5293	+	SWIG_exception(SWIG_TypeError, "string expected");
5294	+	}
5295	+	}
5296	+	}
5297	+	if (obj4) {
5298	+	{
5299	+	if (PyString_Check(obj4))
5300	+	arg5 = std::string(PyString_AsString(obj4));
5301	+	else
5302	+	SWIG_exception(SWIG_TypeError, "string expected");
5303	+	}
5304	+	}
5305	+	if (obj5) {
5306	+	{
5307	+	if (PyString_Check(obj5))
5308	+	arg6 = std::string(PyString_AsString(obj5));
5309	+	else
5310	+	SWIG_exception(SWIG_TypeError, "string expected");
5311	+	}
5312	+	}
5313	+	if (obj6) {
5314	+	{
5315	+	if (PyString_Check(obj6))
5316	+	arg7 = std::string(PyString_AsString(obj6));
5317	+	else
5318	+	SWIG_exception(SWIG_TypeError, "string expected");
5319	+	}
5320	+	}
5321	+	if (obj7) {
5322	+	{
5323	+	if (PyString_Check(obj7))
5324	+	arg8 = std::string(PyString_AsString(obj7));
5325	+	else
5326	+	SWIG_exception(SWIG_TypeError, "string expected");
5327	+	}
5328	+	}
5329	+	if (obj8) {
5330	+	arg9 = (unsigned int) PyInt_AsLong(obj8);
5331	+	if (PyErr_Occurred()) SWIG_fail;
5332	+	}
5333	+	{
5334	+	try {
5335	+	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5336	+
5337	+	}catch (const BossSchedFailure & e) {
5338	+	PyErr_SetString ( SchedulerError, e.what() );
5339	+	return NULL;
5340	+	}catch (const std::exception& e) {
5341	+	PyErr_SetString ( BossError, e.what() );
5342	+	return NULL;
5343	+	}
5344	+	}
5345	+	resultobj = PyInt_FromLong((long)result);
5346	+	return resultobj;
5347	+	fail:
5348	+	return NULL;
5349	+	}
5350	+
5351	+
5352		static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
5353		PyObject *resultobj;
5354		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5199 | Line 5551 | static PyObject *_wrap_BossTask_appendTo
5551		BossTask *arg1 = (BossTask *) 0 ;
5552		PyObject *arg2 = (PyObject *) 0 ;
5553		BossAttributeContainer *arg3 = 0 ;
5202	–	PyObject *result;
5554		PyObject * obj0 = 0 ;
5555		PyObject * obj1 = 0 ;
5556		PyObject * obj2 = 0 ;
#	Line 5213 | Line 5564 | static PyObject *_wrap_BossTask_appendTo
5564		}
5565		{
5566		try {
5567	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5567	>	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5568
5569		}catch (const BossSchedFailure & e) {
5570		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5223 | Line 5574 | static PyObject *_wrap_BossTask_appendTo
5574		return NULL;
5575		}
5576		}
5577	<	resultobj = result;
5577	>	Py_INCREF(Py_None); resultobj = Py_None;
5578		return resultobj;
5579		fail:
5580		return NULL;
#	Line 5233 | Line 5584 | static PyObject *_wrap_BossTask_appendTo
5584		static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5585		PyObject *resultobj;
5586		BossTask *arg1 = (BossTask *) 0 ;
5587	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5588	<	PyObject *result;
5587	>	BossJob *arg2 = (BossJob *) 0 ;
5588	>	PyObject *arg3 = (PyObject *) 0 ;
5589		PyObject * obj0 = 0 ;
5590		PyObject * obj1 = 0 ;
5591	+	PyObject * obj2 = 0 ;
5592
5593	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5593	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5594		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5595	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5596	<	if (arg2 == NULL) {
5245	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5246	<	}
5595	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5596	>	arg3 = obj2;
5597		{
5598		try {
5599	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5599	>	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5600
5601		}catch (const BossSchedFailure & e) {
5602		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5256 | Line 5606 | static PyObject *_wrap_BossTask_jobDict(
5606		return NULL;
5607		}
5608		}
5609	<	resultobj = result;
5609	>	Py_INCREF(Py_None); resultobj = Py_None;
5610		return resultobj;
5611		fail:
5612		return NULL;
#	Line 5290 | Line 5640 | static PyObject *_wrap_BossTask_jobsDict
5640		}
5641
5642
5643	+	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5644	+	PyObject *resultobj;
5645	+	BossTask *arg1 = (BossTask *) 0 ;
5646	+	std::string *arg2 = 0 ;
5647	+	PyObject *result;
5648	+	std::string temp2 ;
5649	+	PyObject * obj0 = 0 ;
5650	+	PyObject * obj1 = 0 ;
5651	+
5652	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5653	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5654	+	{
5655	+	if (PyString_Check(obj1)) {
5656	+	temp2 = std::string(PyString_AsString(obj1));
5657	+	arg2 = &temp2;
5658	+	}else {
5659	+	SWIG_exception(SWIG_TypeError, "string expected");
5660	+	}
5661	+	}
5662	+	{
5663	+	try {
5664	+	result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5665	+
5666	+	}catch (const BossSchedFailure & e) {
5667	+	PyErr_SetString ( SchedulerError, e.what() );
5668	+	return NULL;
5669	+	}catch (const std::exception& e) {
5670	+	PyErr_SetString ( BossError, e.what() );
5671	+	return NULL;
5672	+	}
5673	+	}
5674	+	resultobj = result;
5675	+	return resultobj;
5676	+	fail:
5677	+	return NULL;
5678	+	}
5679	+
5680	+
5681	+	static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
5682	+	PyObject *resultobj;
5683	+	BossTask *arg1 = (BossTask *) 0 ;
5684	+	std::string *arg2 = 0 ;
5685	+	PyObject *result;
5686	+	std::string temp2 ;
5687	+	PyObject * obj0 = 0 ;
5688	+	PyObject * obj1 = 0 ;
5689	+
5690	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5691	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5692	+	{
5693	+	if (PyString_Check(obj1)) {
5694	+	temp2 = std::string(PyString_AsString(obj1));
5695	+	arg2 = &temp2;
5696	+	}else {
5697	+	SWIG_exception(SWIG_TypeError, "string expected");
5698	+	}
5699	+	}
5700	+	{
5701	+	try {
5702	+	result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
5703	+
5704	+	}catch (const BossSchedFailure & e) {
5705	+	PyErr_SetString ( SchedulerError, e.what() );
5706	+	return NULL;
5707	+	}catch (const std::exception& e) {
5708	+	PyErr_SetString ( BossError, e.what() );
5709	+	return NULL;
5710	+	}
5711	+	}
5712	+	resultobj = result;
5713	+	return resultobj;
5714	+	fail:
5715	+	return NULL;
5716	+	}
5717	+
5718	+
5719	+	static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5720	+	PyObject *resultobj;
5721	+	BossTask *arg1 = (BossTask *) 0 ;
5722	+	PyObject *result;
5723	+	PyObject * obj0 = 0 ;
5724	+
5725	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5726	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5727	+	{
5728	+	try {
5729	+	result = (PyObject *)BossTask_jobStates(arg1);
5730	+
5731	+	}catch (const BossSchedFailure & e) {
5732	+	PyErr_SetString ( SchedulerError, e.what() );
5733	+	return NULL;
5734	+	}catch (const std::exception& e) {
5735	+	PyErr_SetString ( BossError, e.what() );
5736	+	return NULL;
5737	+	}
5738	+	}
5739	+	resultobj = result;
5740	+	return resultobj;
5741	+	fail:
5742	+	return NULL;
5743	+	}
5744	+
5745	+
5746	+	static PyObject *_wrap_BossTask_joblist(PyObject *self, PyObject *args) {
5747	+	PyObject *resultobj;
5748	+	BossTask *arg1 = (BossTask *) 0 ;
5749	+	PyObject *result;
5750	+	PyObject * obj0 = 0 ;
5751	+
5752	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_joblist",&obj0)) goto fail;
5753	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5754	+	{
5755	+	try {
5756	+	result = (PyObject *)BossTask_joblist(arg1);
5757	+
5758	+	}catch (const BossSchedFailure & e) {
5759	+	PyErr_SetString ( SchedulerError, e.what() );
5760	+	return NULL;
5761	+	}catch (const std::exception& e) {
5762	+	PyErr_SetString ( BossError, e.what() );
5763	+	return NULL;
5764	+	}
5765	+	}
5766	+	resultobj = result;
5767	+	return resultobj;
5768	+	fail:
5769	+	return NULL;
5770	+	}
5771	+
5772	+
5773	+	static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5774	+	PyObject *resultobj;
5775	+	BossTask *arg1 = (BossTask *) 0 ;
5776	+	PyObject *result;
5777	+	PyObject * obj0 = 0 ;
5778	+
5779	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5780	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5781	+	{
5782	+	try {
5783	+	result = (PyObject *)BossTask_jobStatistic(arg1);
5784	+
5785	+	}catch (const BossSchedFailure & e) {
5786	+	PyErr_SetString ( SchedulerError, e.what() );
5787	+	return NULL;
5788	+	}catch (const std::exception& e) {
5789	+	PyErr_SetString ( BossError, e.what() );
5790	+	return NULL;
5791	+	}
5792	+	}
5793	+	resultobj = result;
5794	+	return resultobj;
5795	+	fail:
5796	+	return NULL;
5797	+	}
5798	+
5799	+
5800		static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5801		PyObject *resultobj;
5802		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5361 | Line 5868 | static PyObject *_wrap_BossTask_jobProgr
5868		}
5869
5870
5871	+	static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5872	+	PyObject *resultobj;
5873	+	BossTask *arg1 = (BossTask *) 0 ;
5874	+	std::string *arg2 = 0 ;
5875	+	std::string *arg3 = 0 ;
5876	+	PyObject *result;
5877	+	std::string temp2 ;
5878	+	std::string temp3 ;
5879	+	PyObject * obj0 = 0 ;
5880	+	PyObject * obj1 = 0 ;
5881	+	PyObject * obj2 = 0 ;
5882	+
5883	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5884	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5885	+	{
5886	+	if (PyString_Check(obj1)) {
5887	+	temp2 = std::string(PyString_AsString(obj1));
5888	+	arg2 = &temp2;
5889	+	}else {
5890	+	SWIG_exception(SWIG_TypeError, "string expected");
5891	+	}
5892	+	}
5893	+	{
5894	+	if (PyString_Check(obj2)) {
5895	+	temp3 = std::string(PyString_AsString(obj2));
5896	+	arg3 = &temp3;
5897	+	}else {
5898	+	SWIG_exception(SWIG_TypeError, "string expected");
5899	+	}
5900	+	}
5901	+	{
5902	+	try {
5903	+	result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5904	+
5905	+	}catch (const BossSchedFailure & e) {
5906	+	PyErr_SetString ( SchedulerError, e.what() );
5907	+	return NULL;
5908	+	}catch (const std::exception& e) {
5909	+	PyErr_SetString ( BossError, e.what() );
5910	+	return NULL;
5911	+	}
5912	+	}
5913	+	resultobj = result;
5914	+	return resultobj;
5915	+	fail:
5916	+	return NULL;
5917	+	}
5918	+
5919	+
5920	+	static PyObject *_wrap_BossTask_programExec(PyObject *self, PyObject *args) {
5921	+	PyObject *resultobj;
5922	+	BossTask *arg1 = (BossTask *) 0 ;
5923	+	std::string *arg2 = 0 ;
5924	+	std::string *arg3 = 0 ;
5925	+	PyObject *result;
5926	+	std::string temp2 ;
5927	+	std::string temp3 ;
5928	+	PyObject * obj0 = 0 ;
5929	+	PyObject * obj1 = 0 ;
5930	+	PyObject * obj2 = 0 ;
5931	+
5932	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
5933	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5934	+	{
5935	+	if (PyString_Check(obj1)) {
5936	+	temp2 = std::string(PyString_AsString(obj1));
5937	+	arg2 = &temp2;
5938	+	}else {
5939	+	SWIG_exception(SWIG_TypeError, "string expected");
5940	+	}
5941	+	}
5942	+	{
5943	+	if (PyString_Check(obj2)) {
5944	+	temp3 = std::string(PyString_AsString(obj2));
5945	+	arg3 = &temp3;
5946	+	}else {
5947	+	SWIG_exception(SWIG_TypeError, "string expected");
5948	+	}
5949	+	}
5950	+	{
5951	+	try {
5952	+	result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5953	+
5954	+	}catch (const BossSchedFailure & e) {
5955	+	PyErr_SetString ( SchedulerError, e.what() );
5956	+	return NULL;
5957	+	}catch (const std::exception& e) {
5958	+	PyErr_SetString ( BossError, e.what() );
5959	+	return NULL;
5960	+	}
5961	+	}
5962	+	resultobj = result;
5963	+	return resultobj;
5964	+	fail:
5965	+	return NULL;
5966	+	}
5967	+
5968	+
5969	+	static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
5970	+	PyObject *resultobj;
5971	+	BossTask *arg1 = (BossTask *) 0 ;
5972	+	std::string *arg2 = 0 ;
5973	+	std::string *arg3 = 0 ;
5974	+	PyObject *result;
5975	+	std::string temp2 ;
5976	+	std::string temp3 ;
5977	+	PyObject * obj0 = 0 ;
5978	+	PyObject * obj1 = 0 ;
5979	+	PyObject * obj2 = 0 ;
5980	+
5981	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
5982	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5983	+	{
5984	+	if (PyString_Check(obj1)) {
5985	+	temp2 = std::string(PyString_AsString(obj1));
5986	+	arg2 = &temp2;
5987	+	}else {
5988	+	SWIG_exception(SWIG_TypeError, "string expected");
5989	+	}
5990	+	}
5991	+	{
5992	+	if (PyString_Check(obj2)) {
5993	+	temp3 = std::string(PyString_AsString(obj2));
5994	+	arg3 = &temp3;
5995	+	}else {
5996	+	SWIG_exception(SWIG_TypeError, "string expected");
5997	+	}
5998	+	}
5999	+	{
6000	+	try {
6001	+	result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
6002	+
6003	+	}catch (const BossSchedFailure & e) {
6004	+	PyErr_SetString ( SchedulerError, e.what() );
6005	+	return NULL;
6006	+	}catch (const std::exception& e) {
6007	+	PyErr_SetString ( BossError, e.what() );
6008	+	return NULL;
6009	+	}
6010	+	}
6011	+	resultobj = result;
6012	+	return resultobj;
6013	+	fail:
6014	+	return NULL;
6015	+	}
6016	+
6017	+
6018		static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
6019		PyObject *obj;
6020		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 6323 | Line 6977 | static PyMethodDef SwigMethods[] = {
6977		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6978		{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6979		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6980	+	{ (char *)"BossSession_task_begin", _wrap_BossSession_task_begin, METH_VARARGS },
6981	+	{ (char *)"BossSession_task_end", _wrap_BossSession_task_end, METH_VARARGS },
6982	+	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
6983	+	{ (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
6984		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6985		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6986		{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
#	Line 6338 | Line 6996 | static PyMethodDef SwigMethods[] = {
6996		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
6997		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6998		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6341	–	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6342	–	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6999		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
7000	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
7001	+	{ (char *)"BossSession_getTasksByTaskInfo", _wrap_BossSession_getTasksByTaskInfo, METH_VARARGS },
7002	+	{ (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
7003		{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7004		{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7005		{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
7006		{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
7007		{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
7008		{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7009	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7009	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7010		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6352	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6353	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7011		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
6355	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7012		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7013		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7014	+	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7015	+	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7016	+	{ (char *)"BossTask_jobsInMemory", _wrap_BossTask_jobsInMemory, METH_VARARGS },
7017	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7018	+	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7019	+	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
7020		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
7021		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7022		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7023		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7024	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7025		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6363	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6364	–	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7026		{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7027		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
7028		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6368	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7029		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7030		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7031		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
#	Line 6373 | Line 7033 | static PyMethodDef SwigMethods[] = {
7033		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
7034		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
7035		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7036	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7037		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7038	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7039		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7040		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7041		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7042		{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7043		{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7044		{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7045	+	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7046	+	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7047	+	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7048	+	{ (char *)"BossTask_joblist", _wrap_BossTask_joblist, METH_VARARGS },
7049	+	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7050		{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7051		{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7052	+	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7053	+	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7054	+	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7055		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
7056		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7057		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 6406 | Line 7076 | static PyMethodDef SwigMethods[] = {
7076
7077		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7078
6409	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7079		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}};
7080	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7081		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}};
7082	<	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}};
7082	>	static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7083	>	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7084		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}};
6414	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7085		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7086		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7087	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7088	+	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7089		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7090		static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7091		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
#	Line 6422 | Line 7094 | static swig_type_info _swigt__p_BossSess
7094		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}};
7095		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}};
7096		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
6425	–	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}};
7097		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}};
7098	+	static swig_type_info _swigt__p_BossSession__task_iterator[] = {{"_p_BossSession__task_iterator", 0, "BossSession::task_iterator const *", 0},{"_p_BossSession__task_iterator"},{0}};
7099	+	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}};
7100		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7101
7102		static swig_type_info *swig_types_initial[] = {
6430	–	_swigt__p_XMLDoc,
7103		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
7104	+	_swigt__p_XMLDoc,
7105		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7106	<	_swigt__p_std__vectorTBossTask_p_t,
7106	>	_swigt__p_BossProgramExec,
7107	>	_swigt__p_BossChain,
7108		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6435	–	_swigt__p_std__ostream,
7109		_swigt__p_BossTask,
7110		_swigt__p_BossTaskException,
7111	+	_swigt__p_std__ostream,
7112	+	_swigt__p_BossProgram,
7113		_swigt__p_printOption,
7114		_swigt__p_BossAttributeContainer,
7115		_swigt__p_BossJob,
#	Line 6443 | Line 7118 | _swigt__p_BossSession,
7118		_swigt__p_std__vectorTstd__string_t,
7119		_swigt__p_std__mapTstd__string_std__string_t,
7120		_swigt__p_BossAdministratorSession,
6446	–	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7121		_swigt__p_BossTask__job_iterator,
7122	+	_swigt__p_BossSession__task_iterator,
7123	+	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7124		_swigt__p_jobStates,
7125		0
7126		};

Diff Legend

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