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.29 by gcodispo, Fri Mar 9 15:40:00 2007 UTC vs.
Revision 1.36 by gcodispo, Wed Jul 18 08:59:17 2007 UTC

#	Line 658 | Line 658 | SWIG_InstallConstants(PyObject *d, swig_
658		#define  SWIGTYPE_p_XMLDoc swig_types[1]
659		#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660		#define  SWIGTYPE_p_BossProgramExec swig_types[3]
661	<	#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[4]
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]
#	Line 672 | Line 672 | SWIG_InstallConstants(PyObject *d, swig_
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_std__vectorTBossJob_p_t__const_iterator swig_types[18]
676	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[19]
677	<	#define  SWIGTYPE_p_jobStates swig_types[20]
678	<	static swig_type_info *swig_types[22];
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 925 | 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 959 | 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,
965	–	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;
974	<	if ( taskName.empty() ) {
975	<	taskList = self->selectTasks( taskRange, before, after, user);
976	<	} else {
977	<	taskList = self->selectTasksByName( taskName );
978	<	}
979	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
980	<	it!= taskList.end(); ++it ) {
981	<	PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
982	<	}
983	<	return  task_list;
972	>	void BossSession_schedulerQuery(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,unsigned int timeout,bool avoidCheck){
973	>	self->query ( filter_opt, taskRange, jobRange, subn, type, user, after, before, timeout, avoidCheck );
974	>	return;
975		}
976		void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
977		std::string tmp;
#	Line 1034 | Line 1025 | PyObject *BossTask_jobsDict(BossTask *se
1025		return job_dict;
1026		}
1027		PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1037	–
1028		PyObject * job_dict = PyDict_New();
1039	–	self->load( ALL, jobid );
1029		BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1030		return job_dict;
1031		}
1032	+	PyObject *BossTask_Chain(BossTask *self,std::string const &jobid){
1033	+
1034	+	PyObject * chain_dict = PyDict_New();
1035	+	BossAttributeContainer obj =
1036	+	self->chain( jobid ).getTableEntries("CHAIN");
1037	+	BossTask_appendToPyDict ( self, chain_dict, obj );
1038	+	return chain_dict;
1039	+	}
1040		PyObject *BossTask_jobStates(BossTask *self){
1041
1042		PyObject * job_dict = PyDict_New();
#	Line 1054 | Line 1051 | PyObject *BossTask_jobStates(BossTask *s
1051		}
1052		return job_dict;
1053		}
1054	+	PyObject *BossTask_joblist(BossTask *self){
1055	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1056	+	PyObject *  job_list = PyList_New( self->jobsInMemory() );
1057	+	unsigned int index = 0;
1058	+	for (BossTask::job_iterator jit = self->job_begin ();
1059	+	jit != self->job_end (); ++jit, ++index) {
1060	+	PyList_SetItem( job_list,
1061	+	index,
1062	+	PyString_FromString( ( (*jit)->chainId() ).c_str() )
1063	+	);
1064	+	}
1065	+	return job_list;
1066	+	}
1067		PyObject *BossTask_jobStatistic(BossTask *self){
1068
1069		PyObject * job_dict = PyDict_New();
#	Line 1159 | Line 1169 | PyObject *BossTask_specific(BossTask *se
1169
1170		const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1171		BossProgramExec programExec = self->queryProgramExec( jH, programId );
1172	<
1172	>	BossAttributeContainer obj = programExec.getKeys ();
1173	>	BossTask_appendToPyDict ( self, job_dict, obj );
1174	>
1175		std::vector < BossAttributeContainer >::const_iterator it;
1176		std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1177		for ( it = programExec.specBegin (); it != it_end; ++it) {
#	Line 2518 | Line 2530 | static PyObject *_wrap_BossSession_clear
2530		}
2531
2532
2533	+	static PyObject *_wrap_BossSession_task_begin(PyObject *self, PyObject *args) {
2534	+	PyObject *resultobj;
2535	+	BossSession *arg1 = (BossSession *) 0 ;
2536	+	BossSession::task_iterator result;
2537	+	PyObject * obj0 = 0 ;
2538	+
2539	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_begin",&obj0)) goto fail;
2540	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2541	+	{
2542	+	try {
2543	+	result = ((BossSession const *)arg1)->task_begin();
2544	+
2545	+	}catch (const BossSchedFailure & e) {
2546	+	PyErr_SetString ( SchedulerError, e.what() );
2547	+	return NULL;
2548	+	}catch (const std::exception& e) {
2549	+	PyErr_SetString ( BossError, e.what() );
2550	+	return NULL;
2551	+	}
2552	+	}
2553	+	{
2554	+	BossSession::task_iterator * resultptr;
2555	+	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2556	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2557	+	}
2558	+	return resultobj;
2559	+	fail:
2560	+	return NULL;
2561	+	}
2562	+
2563	+
2564	+	static PyObject *_wrap_BossSession_task_end(PyObject *self, PyObject *args) {
2565	+	PyObject *resultobj;
2566	+	BossSession *arg1 = (BossSession *) 0 ;
2567	+	BossSession::task_iterator result;
2568	+	PyObject * obj0 = 0 ;
2569	+
2570	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_end",&obj0)) goto fail;
2571	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2572	+	{
2573	+	try {
2574	+	result = ((BossSession const *)arg1)->task_end();
2575	+
2576	+	}catch (const BossSchedFailure & e) {
2577	+	PyErr_SetString ( SchedulerError, e.what() );
2578	+	return NULL;
2579	+	}catch (const std::exception& e) {
2580	+	PyErr_SetString ( BossError, e.what() );
2581	+	return NULL;
2582	+	}
2583	+	}
2584	+	{
2585	+	BossSession::task_iterator * resultptr;
2586	+	resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2587	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2588	+	}
2589	+	return resultobj;
2590	+	fail:
2591	+	return NULL;
2592	+	}
2593	+
2594	+
2595	+	static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
2596	+	PyObject *resultobj;
2597	+	BossSession *arg1 = (BossSession *) 0 ;
2598	+	unsigned int result;
2599	+	PyObject * obj0 = 0 ;
2600	+
2601	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
2602	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2603	+	{
2604	+	try {
2605	+	result = (unsigned int)((BossSession const *)arg1)->tasksInMemory();
2606	+
2607	+	}catch (const BossSchedFailure & e) {
2608	+	PyErr_SetString ( SchedulerError, e.what() );
2609	+	return NULL;
2610	+	}catch (const std::exception& e) {
2611	+	PyErr_SetString ( BossError, e.what() );
2612	+	return NULL;
2613	+	}
2614	+	}
2615	+	resultobj = PyInt_FromLong((long)result);
2616	+	return resultobj;
2617	+	fail:
2618	+	return NULL;
2619	+	}
2620	+
2621	+
2622	+	static PyObject *_wrap_BossSession_locate(PyObject *self, PyObject *args) {
2623	+	PyObject *resultobj;
2624	+	BossSession *arg1 = (BossSession *) 0 ;
2625	+	unsigned int arg2 ;
2626	+	BossTask *result;
2627	+	PyObject * obj0 = 0 ;
2628	+	PyObject * obj1 = 0 ;
2629	+
2630	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
2631	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2632	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
2633	+	if (PyErr_Occurred()) SWIG_fail;
2634	+	{
2635	+	try {
2636	+	result = (BossTask *)((BossSession const *)arg1)->locate(arg2);
2637	+
2638	+	}catch (const BossSchedFailure & e) {
2639	+	PyErr_SetString ( SchedulerError, e.what() );
2640	+	return NULL;
2641	+	}catch (const std::exception& e) {
2642	+	PyErr_SetString ( BossError, e.what() );
2643	+	return NULL;
2644	+	}
2645	+	}
2646	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2647	+	return resultobj;
2648	+	fail:
2649	+	return NULL;
2650	+	}
2651	+
2652	+
2653		static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2654		PyObject *resultobj;
2655		BossSession *arg1 = (BossSession *) 0 ;
#	Line 2985 | Line 3117 | static PyObject *_wrap_BossSession_listM
3117		BossSession *arg1 = (BossSession *) 0 ;
3118		std::string *arg2 = 0 ;
3119		std::string *arg3 = 0 ;
3120	<	bool arg4 = (bool) false ;
3120	>	std::string const &arg4_defvalue = "" ;
3121	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3122		std::string const &arg5_defvalue = "" ;
3123		std::string *arg5 = (std::string *) &arg5_defvalue ;
3124	<	std::string const &arg6_defvalue = "" ;
2992	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
2993	<	unsigned int arg7 = (unsigned int) 0 ;
3124	>	unsigned int arg6 = (unsigned int) 0 ;
3125		std::vector<std::string > result;
3126		std::string temp2 ;
3127		std::string temp3 ;
3128	+	std::string temp4 ;
3129		std::string temp5 ;
2998	–	std::string temp6 ;
3130		PyObject * obj0 = 0 ;
3131		PyObject * obj1 = 0 ;
3132		PyObject * obj2 = 0 ;
3133		PyObject * obj3 = 0 ;
3134		PyObject * obj4 = 0 ;
3135		PyObject * obj5 = 0 ;
3005	–	PyObject * obj6 = 0 ;
3136
3137	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3137	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3138		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3139		{
3140		if (PyString_Check(obj1)) {
#	Line 3023 | Line 3153 | static PyObject *_wrap_BossSession_listM
3153		}
3154		}
3155		if (obj3) {
3026	–	arg4 = PyInt_AsLong(obj3) ? true : false;
3027	–	if (PyErr_Occurred()) SWIG_fail;
3028	–	}
3029	–	if (obj4) {
3156		{
3157	<	if (PyString_Check(obj4)) {
3158	<	temp5 = std::string(PyString_AsString(obj4));
3159	<	arg5 = &temp5;
3157	>	if (PyString_Check(obj3)) {
3158	>	temp4 = std::string(PyString_AsString(obj3));
3159	>	arg4 = &temp4;
3160		}else {
3161		SWIG_exception(SWIG_TypeError, "string expected");
3162		}
3163		}
3164		}
3165	<	if (obj5) {
3165	>	if (obj4) {
3166		{
3167	<	if (PyString_Check(obj5)) {
3168	<	temp6 = std::string(PyString_AsString(obj5));
3169	<	arg6 = &temp6;
3167	>	if (PyString_Check(obj4)) {
3168	>	temp5 = std::string(PyString_AsString(obj4));
3169	>	arg5 = &temp5;
3170		}else {
3171		SWIG_exception(SWIG_TypeError, "string expected");
3172		}
3173		}
3174		}
3175	<	if (obj6) {
3176	<	arg7 = (unsigned int) PyInt_AsLong(obj6);
3175	>	if (obj5) {
3176	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3177		if (PyErr_Occurred()) SWIG_fail;
3178		}
3179		{
3180		try {
3181	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
3181	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3182
3183		}catch (const BossSchedFailure & e) {
3184		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3074 | Line 3200 | static PyObject *_wrap_BossSession_listM
3200		}
3201
3202
3203	<	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3203	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3204		PyObject *resultobj;
3205		BossSession *arg1 = (BossSession *) 0 ;
3206		int arg2 = (int) SCHEDULED ;
#	Line 3089 | Line 3215 | static PyObject *_wrap_BossSession_sched
3215		std::string arg8 = (std::string) "" ;
3216		std::string arg9 = (std::string) "" ;
3217		unsigned int arg10 = (unsigned int) 0 ;
3218	+	bool arg11 = (bool) false ;
3219		std::string temp3 ;
3220		std::string temp4 ;
3221		std::string temp5 ;
#	Line 3101 | Line 3228 | static PyObject *_wrap_BossSession_sched
3228		PyObject * obj7 = 0 ;
3229		PyObject * obj8 = 0 ;
3230		PyObject * obj9 = 0 ;
3231	+	PyObject * obj10 = 0 ;
3232
3233	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3233	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3234		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3235		if (obj2) {
3236		{
#	Line 3170 | Line 3298 | static PyObject *_wrap_BossSession_sched
3298		arg10 = (unsigned int) PyInt_AsLong(obj9);
3299		if (PyErr_Occurred()) SWIG_fail;
3300		}
3301	+	if (obj10) {
3302	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3303	+	if (PyErr_Occurred()) SWIG_fail;
3304	+	}
3305		{
3306		try {
3307	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3307	>	(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3308
3309		}catch (const BossSchedFailure & e) {
3310		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3189 | Line 3321 | static PyObject *_wrap_BossSession_sched
3321		}
3322
3323
3324	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3324	>	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3325		PyObject *resultobj;
3326		BossSession *arg1 = (BossSession *) 0 ;
3327	<	std::string const &arg2_defvalue = "all" ;
3328	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3197	<	std::string const &arg3_defvalue = "" ;
3198	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3199	<	std::string const &arg4_defvalue = "" ;
3200	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3201	<	std::string const &arg5_defvalue = "" ;
3202	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3203	<	std::vector<std::string > result;
3327	>	std::string *arg2 = 0 ;
3328	>	unsigned int result;
3329		std::string temp2 ;
3205	–	std::string temp3 ;
3206	–	std::string temp4 ;
3207	–	std::string temp5 ;
3330		PyObject * obj0 = 0 ;
3331		PyObject * obj1 = 0 ;
3210	–	PyObject * obj2 = 0 ;
3211	–	PyObject * obj3 = 0 ;
3212	–	PyObject * obj4 = 0 ;
3332
3333	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3333	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3334		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3335	<	if (obj1) {
3336	<	{
3337	<	if (PyString_Check(obj1)) {
3338	<	temp2 = std::string(PyString_AsString(obj1));
3339	<	arg2 = &temp2;
3340	<	}else {
3222	<	SWIG_exception(SWIG_TypeError, "string expected");
3223	<	}
3224	<	}
3225	<	}
3226	<	if (obj2) {
3227	<	{
3228	<	if (PyString_Check(obj2)) {
3229	<	temp3 = std::string(PyString_AsString(obj2));
3230	<	arg3 = &temp3;
3231	<	}else {
3232	<	SWIG_exception(SWIG_TypeError, "string expected");
3233	<	}
3234	<	}
3235	<	}
3236	<	if (obj3) {
3237	<	{
3238	<	if (PyString_Check(obj3)) {
3239	<	temp4 = std::string(PyString_AsString(obj3));
3240	<	arg4 = &temp4;
3241	<	}else {
3242	<	SWIG_exception(SWIG_TypeError, "string expected");
3243	<	}
3244	<	}
3245	<	}
3246	<	if (obj4) {
3247	<	{
3248	<	if (PyString_Check(obj4)) {
3249	<	temp5 = std::string(PyString_AsString(obj4));
3250	<	arg5 = &temp5;
3251	<	}else {
3252	<	SWIG_exception(SWIG_TypeError, "string expected");
3253	<	}
3335	>	{
3336	>	if (PyString_Check(obj1)) {
3337	>	temp2 = std::string(PyString_AsString(obj1));
3338	>	arg2 = &temp2;
3339	>	}else {
3340	>	SWIG_exception(SWIG_TypeError, "string expected");
3341		}
3342		}
3343		{
3344		try {
3345	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3345	>	result = (unsigned int)(arg1)->getTasksByName((std::string const &)*arg2);
3346
3347		}catch (const BossSchedFailure & e) {
3348		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3265 | Line 3352 | static PyObject *_wrap_BossSession_selec
3352		return NULL;
3353		}
3354		}
3355	<	{
3269	<	resultobj = PyTuple_New((&result)->size());
3270	<	for (unsigned int i=0; i<(&result)->size(); i++)
3271	<	PyTuple_SetItem(resultobj,i,
3272	<	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3273	<	}
3355	>	resultobj = PyInt_FromLong((long)result);
3356		return resultobj;
3357		fail:
3358		return NULL;
3359		}
3360
3361
3362	<	static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
3362	>	static PyObject *_wrap_BossSession_getTasksByTaskInfo(PyObject *self, PyObject *args) {
3363		PyObject *resultobj;
3364		BossSession *arg1 = (BossSession *) 0 ;
3365		std::string *arg2 = 0 ;
3366	<	std::vector<std::string > result;
3366	>	unsigned int result;
3367		std::string temp2 ;
3368		PyObject * obj0 = 0 ;
3369		PyObject * obj1 = 0 ;
3370
3371	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3371	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByTaskInfo",&obj0,&obj1)) goto fail;
3372		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3373		{
3374		if (PyString_Check(obj1)) {
#	Line 3298 | Line 3380 | static PyObject *_wrap_BossSession_selec
3380		}
3381		{
3382		try {
3383	<	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3383	>	result = (unsigned int)(arg1)->getTasksByTaskInfo((std::string const &)*arg2);
3384
3385		}catch (const BossSchedFailure & e) {
3386		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3308 | Line 3390 | static PyObject *_wrap_BossSession_selec
3390		return NULL;
3391		}
3392		}
3393	<	{
3312	<	resultobj = PyTuple_New((&result)->size());
3313	<	for (unsigned int i=0; i<(&result)->size(); i++)
3314	<	PyTuple_SetItem(resultobj,i,
3315	<	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3316	<	}
3317	<	return resultobj;
3318	<	fail:
3319	<	return NULL;
3320	<	}
3321	<
3322	<
3323	<	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3324	<	PyObject *resultobj;
3325	<	BossSession *arg1 = (BossSession *) 0 ;
3326	<	int arg2 = (int) SCHEDULED ;
3327	<	std::string const &arg3_defvalue = "all" ;
3328	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3329	<	std::string const &arg4_defvalue = "all" ;
3330	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3331	<	std::string const &arg5_defvalue = "" ;
3332	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3333	<	std::string arg6 = (std::string) "" ;
3334	<	std::string arg7 = (std::string) "" ;
3335	<	std::string arg8 = (std::string) "" ;
3336	<	std::string arg9 = (std::string) "" ;
3337	<	unsigned int arg10 = (unsigned int) 0 ;
3338	<	bool arg11 = (bool) false ;
3339	<	SwigValueWrapper< std::vector<BossTask * > > result;
3340	<	std::string temp3 ;
3341	<	std::string temp4 ;
3342	<	std::string temp5 ;
3343	<	PyObject * obj0 = 0 ;
3344	<	PyObject * obj2 = 0 ;
3345	<	PyObject * obj3 = 0 ;
3346	<	PyObject * obj4 = 0 ;
3347	<	PyObject * obj5 = 0 ;
3348	<	PyObject * obj6 = 0 ;
3349	<	PyObject * obj7 = 0 ;
3350	<	PyObject * obj8 = 0 ;
3351	<	PyObject * obj9 = 0 ;
3352	<	PyObject * obj10 = 0 ;
3353	<
3354	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3355	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3356	<	if (obj2) {
3357	<	{
3358	<	if (PyString_Check(obj2)) {
3359	<	temp3 = std::string(PyString_AsString(obj2));
3360	<	arg3 = &temp3;
3361	<	}else {
3362	<	SWIG_exception(SWIG_TypeError, "string expected");
3363	<	}
3364	<	}
3365	<	}
3366	<	if (obj3) {
3367	<	{
3368	<	if (PyString_Check(obj3)) {
3369	<	temp4 = std::string(PyString_AsString(obj3));
3370	<	arg4 = &temp4;
3371	<	}else {
3372	<	SWIG_exception(SWIG_TypeError, "string expected");
3373	<	}
3374	<	}
3375	<	}
3376	<	if (obj4) {
3377	<	{
3378	<	if (PyString_Check(obj4)) {
3379	<	temp5 = std::string(PyString_AsString(obj4));
3380	<	arg5 = &temp5;
3381	<	}else {
3382	<	SWIG_exception(SWIG_TypeError, "string expected");
3383	<	}
3384	<	}
3385	<	}
3386	<	if (obj5) {
3387	<	{
3388	<	if (PyString_Check(obj5))
3389	<	arg6 = std::string(PyString_AsString(obj5));
3390	<	else
3391	<	SWIG_exception(SWIG_TypeError, "string expected");
3392	<	}
3393	<	}
3394	<	if (obj6) {
3395	<	{
3396	<	if (PyString_Check(obj6))
3397	<	arg7 = std::string(PyString_AsString(obj6));
3398	<	else
3399	<	SWIG_exception(SWIG_TypeError, "string expected");
3400	<	}
3401	<	}
3402	<	if (obj7) {
3403	<	{
3404	<	if (PyString_Check(obj7))
3405	<	arg8 = std::string(PyString_AsString(obj7));
3406	<	else
3407	<	SWIG_exception(SWIG_TypeError, "string expected");
3408	<	}
3409	<	}
3410	<	if (obj8) {
3411	<	{
3412	<	if (PyString_Check(obj8))
3413	<	arg9 = std::string(PyString_AsString(obj8));
3414	<	else
3415	<	SWIG_exception(SWIG_TypeError, "string expected");
3416	<	}
3417	<	}
3418	<	if (obj9) {
3419	<	arg10 = (unsigned int) PyInt_AsLong(obj9);
3420	<	if (PyErr_Occurred()) SWIG_fail;
3421	<	}
3422	<	if (obj10) {
3423	<	arg11 = PyInt_AsLong(obj10) ? true : false;
3424	<	if (PyErr_Occurred()) SWIG_fail;
3425	<	}
3426	<	{
3427	<	try {
3428	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3429	<
3430	<	}catch (const BossSchedFailure & e) {
3431	<	PyErr_SetString ( SchedulerError, e.what() );
3432	<	return NULL;
3433	<	}catch (const std::exception& e) {
3434	<	PyErr_SetString ( BossError, e.what() );
3435	<	return NULL;
3436	<	}
3437	<	}
3438	<	{
3439	<	std::vector<BossTask * > * resultptr;
3440	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3441	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3442	<	}
3393	>	resultobj = PyInt_FromLong((long)result);
3394		return resultobj;
3395		fail:
3396		return NULL;
3397		}
3398
3399
3400	<	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3400	>	static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3401		PyObject *resultobj;
3402		BossSession *arg1 = (BossSession *) 0 ;
3403		std::string *arg2 = 0 ;
3404	<	SwigValueWrapper< std::vector<BossTask * > > result;
3404	>	unsigned int result;
3405		std::string temp2 ;
3406		PyObject * obj0 = 0 ;
3407		PyObject * obj1 = 0 ;
3408
3409	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3409	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3410		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3411		{
3412		if (PyString_Check(obj1)) {
#	Line 3467 | Line 3418 | static PyObject *_wrap_BossSession_getTa
3418		}
3419		{
3420		try {
3421	<	result = (arg1)->getTasksByName((std::string const &)*arg2);
3421	>	result = (unsigned int)(arg1)->getTasksByJobName((std::string const &)*arg2);
3422
3423		}catch (const BossSchedFailure & e) {
3424		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3477 | Line 3428 | static PyObject *_wrap_BossSession_getTa
3428		return NULL;
3429		}
3430		}
3431	<	{
3481	<	std::vector<BossTask * > * resultptr;
3482	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3483	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3484	<	}
3431	>	resultobj = PyInt_FromLong((long)result);
3432		return resultobj;
3433		fail:
3434		return NULL;
#	Line 3639 | Line 3586 | static PyObject *_wrap_BossSession_sched
3586		std::string const &arg5_defvalue = "" ;
3587		std::string *arg5 = (std::string *) &arg5_defvalue ;
3588		unsigned int arg6 = (unsigned int) 0 ;
3642	–	bool arg7 = (bool) false ;
3589		PyObject *result;
3590		std::string temp2 ;
3591		std::string temp3 ;
#	Line 3651 | Line 3597 | static PyObject *_wrap_BossSession_sched
3597		PyObject * obj3 = 0 ;
3598		PyObject * obj4 = 0 ;
3599		PyObject * obj5 = 0 ;
3654	–	PyObject * obj6 = 0 ;
3600
3601	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3601	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3602		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3603		{
3604		if (PyString_Check(obj1)) {
#	Line 3695 | Line 3640 | static PyObject *_wrap_BossSession_sched
3640		arg6 = (unsigned int) PyInt_AsLong(obj5);
3641		if (PyErr_Occurred()) SWIG_fail;
3642		}
3698	–	if (obj6) {
3699	–	arg7 = PyInt_AsLong(obj6) ? true : false;
3700	–	if (PyErr_Occurred()) SWIG_fail;
3701	–	}
3643		{
3644		try {
3645	<	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3645	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3646
3647		}catch (const BossSchedFailure & e) {
3648		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3718 | Line 3659 | static PyObject *_wrap_BossSession_sched
3659		}
3660
3661
3662	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3662	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3663		PyObject *resultobj;
3664		BossSession *arg1 = (BossSession *) 0 ;
3665	<	std::string const &arg2_defvalue = "" ;
3725	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3665	>	int arg2 = (int) SCHEDULED ;
3666		std::string const &arg3_defvalue = "all" ;
3667		std::string *arg3 = (std::string *) &arg3_defvalue ;
3668	<	std::string arg4 = (std::string) "" ;
3669	<	std::string arg5 = (std::string) "" ;
3668	>	std::string const &arg4_defvalue = "all" ;
3669	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3670	>	std::string const &arg5_defvalue = "" ;
3671	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3672		std::string arg6 = (std::string) "" ;
3673	<	PyObject *result;
3674	<	std::string temp2 ;
3673	>	std::string arg7 = (std::string) "" ;
3674	>	std::string arg8 = (std::string) "" ;
3675	>	std::string arg9 = (std::string) "" ;
3676	>	unsigned int arg10 = (unsigned int) 0 ;
3677	>	bool arg11 = (bool) false ;
3678		std::string temp3 ;
3679	+	std::string temp4 ;
3680	+	std::string temp5 ;
3681		PyObject * obj0 = 0 ;
3735	–	PyObject * obj1 = 0 ;
3682		PyObject * obj2 = 0 ;
3683		PyObject * obj3 = 0 ;
3684		PyObject * obj4 = 0 ;
3685		PyObject * obj5 = 0 ;
3686	+	PyObject * obj6 = 0 ;
3687	+	PyObject * obj7 = 0 ;
3688	+	PyObject * obj8 = 0 ;
3689	+	PyObject * obj9 = 0 ;
3690	+	PyObject * obj10 = 0 ;
3691
3692	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3692	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3693		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3694	<	if (obj1) {
3694	>	if (obj2) {
3695		{
3696	<	if (PyString_Check(obj1)) {
3697	<	temp2 = std::string(PyString_AsString(obj1));
3698	<	arg2 = &temp2;
3696	>	if (PyString_Check(obj2)) {
3697	>	temp3 = std::string(PyString_AsString(obj2));
3698	>	arg3 = &temp3;
3699		}else {
3700		SWIG_exception(SWIG_TypeError, "string expected");
3701		}
3702		}
3703		}
3704	<	if (obj2) {
3704	>	if (obj3) {
3705		{
3706	<	if (PyString_Check(obj2)) {
3707	<	temp3 = std::string(PyString_AsString(obj2));
3708	<	arg3 = &temp3;
3706	>	if (PyString_Check(obj3)) {
3707	>	temp4 = std::string(PyString_AsString(obj3));
3708	>	arg4 = &temp4;
3709		}else {
3710		SWIG_exception(SWIG_TypeError, "string expected");
3711		}
3712		}
3713		}
3714	<	if (obj3) {
3714	>	if (obj4) {
3715		{
3716	<	if (PyString_Check(obj3))
3717	<	arg4 = std::string(PyString_AsString(obj3));
3716	>	if (PyString_Check(obj4)) {
3717	>	temp5 = std::string(PyString_AsString(obj4));
3718	>	arg5 = &temp5;
3719	>	}else {
3720	>	SWIG_exception(SWIG_TypeError, "string expected");
3721	>	}
3722	>	}
3723	>	}
3724	>	if (obj5) {
3725	>	{
3726	>	if (PyString_Check(obj5))
3727	>	arg6 = std::string(PyString_AsString(obj5));
3728		else
3729		SWIG_exception(SWIG_TypeError, "string expected");
3730		}
3731		}
3732	<	if (obj4) {
3732	>	if (obj6) {
3733		{
3734	<	if (PyString_Check(obj4))
3735	<	arg5 = std::string(PyString_AsString(obj4));
3734	>	if (PyString_Check(obj6))
3735	>	arg7 = std::string(PyString_AsString(obj6));
3736		else
3737		SWIG_exception(SWIG_TypeError, "string expected");
3738		}
3739		}
3740	<	if (obj5) {
3740	>	if (obj7) {
3741		{
3742	<	if (PyString_Check(obj5))
3743	<	arg6 = std::string(PyString_AsString(obj5));
3742	>	if (PyString_Check(obj7))
3743	>	arg8 = std::string(PyString_AsString(obj7));
3744		else
3745		SWIG_exception(SWIG_TypeError, "string expected");
3746		}
3747		}
3748	+	if (obj8) {
3749	+	{
3750	+	if (PyString_Check(obj8))
3751	+	arg9 = std::string(PyString_AsString(obj8));
3752	+	else
3753	+	SWIG_exception(SWIG_TypeError, "string expected");
3754	+	}
3755	+	}
3756	+	if (obj9) {
3757	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3758	+	if (PyErr_Occurred()) SWIG_fail;
3759	+	}
3760	+	if (obj10) {
3761	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3762	+	if (PyErr_Occurred()) SWIG_fail;
3763	+	}
3764		{
3765		try {
3766	<	result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3766	>	BossSession_schedulerQuery(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3767
3768		}catch (const BossSchedFailure & e) {
3769		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3796 | Line 3773 | static PyObject *_wrap_BossSession_query
3773		return NULL;
3774		}
3775		}
3776	<	resultobj = result;
3776	>	Py_INCREF(Py_None); resultobj = Py_None;
3777		return resultobj;
3778		fail:
3779		return NULL;
#	Line 3810 | Line 3787 | static PyObject * BossSession_swigregist
3787		Py_INCREF(obj);
3788		return Py_BuildValue((char *)"");
3789		}
3813	–	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3814	–	PyObject *resultobj;
3815	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
3816	–	char *arg2 ;
3817	–	PyObject * obj0 = 0 ;
3818	–
3819	–	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) 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;
3827	–	}
3828	–	}
3829	–	Py_INCREF(Py_None); resultobj = Py_None;
3830	–	return resultobj;
3831	–	fail:
3832	–	return NULL;
3833	–	}
3834	–
3835	–
3836	–	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3837	–	PyObject *resultobj;
3838	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
3839	–	char *result;
3840	–	PyObject * obj0 = 0 ;
3841	–
3842	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3843	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3844	–	result = (char *) ((arg1)->key);
3845	–
3846	–	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3847	–	return resultobj;
3848	–	fail:
3849	–	return NULL;
3850	–	}
3851	–
3852	–
3790		static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3791		PyObject *resultobj;
3792		char *arg1 ;
#	Line 3875 | Line 3812 | static PyObject *_wrap_new_BossTaskExcep
3812		}
3813
3814
3878	–	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3879	–	PyObject *resultobj;
3880	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
3881	–	char *result;
3882	–	PyObject * obj0 = 0 ;
3883	–
3884	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3885	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3886	–	{
3887	–	try {
3888	–	result = (char *)((BossTaskException const *)arg1)->what();
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	–	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3899	–	return resultobj;
3900	–	fail:
3901	–	return NULL;
3902	–	}
3903	–
3904	–
3815		static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3816		PyObject *resultobj;
3817		BossTaskException *arg1 = (BossTaskException *) 0 ;
#	Line 3997 | Line 3907 | static PyObject *_wrap_BossTask_job_end(
3907		}
3908
3909
3910	+	static PyObject *_wrap_BossTask_jobsInMemory(PyObject *self, PyObject *args) {
3911	+	PyObject *resultobj;
3912	+	BossTask *arg1 = (BossTask *) 0 ;
3913	+	unsigned int result;
3914	+	PyObject * obj0 = 0 ;
3915	+
3916	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsInMemory",&obj0)) goto fail;
3917	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3918	+	{
3919	+	try {
3920	+	result = (unsigned int)((BossTask const *)arg1)->jobsInMemory();
3921	+
3922	+	}catch (const BossSchedFailure & e) {
3923	+	PyErr_SetString ( SchedulerError, e.what() );
3924	+	return NULL;
3925	+	}catch (const std::exception& e) {
3926	+	PyErr_SetString ( BossError, e.what() );
3927	+	return NULL;
3928	+	}
3929	+	}
3930	+	resultobj = PyInt_FromLong((long)result);
3931	+	return resultobj;
3932	+	fail:
3933	+	return NULL;
3934	+	}
3935	+
3936	+
3937		static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3938		PyObject *resultobj;
3939		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4371 | Line 4308 | static PyObject *_wrap_BossTask_name(PyO
4308		}
4309
4310
4311	+	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4312	+	PyObject *resultobj;
4313	+	BossTask *arg1 = (BossTask *) 0 ;
4314	+	std::string *arg2 = 0 ;
4315	+	BossChain result;
4316	+	std::string temp2 ;
4317	+	PyObject * obj0 = 0 ;
4318	+	PyObject * obj1 = 0 ;
4319	+
4320	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4321	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4322	+	{
4323	+	if (PyString_Check(obj1)) {
4324	+	temp2 = std::string(PyString_AsString(obj1));
4325	+	arg2 = &temp2;
4326	+	}else {
4327	+	SWIG_exception(SWIG_TypeError, "string expected");
4328	+	}
4329	+	}
4330	+	{
4331	+	try {
4332	+	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4333	+
4334	+	}catch (const BossSchedFailure & e) {
4335	+	PyErr_SetString ( SchedulerError, e.what() );
4336	+	return NULL;
4337	+	}catch (const std::exception& e) {
4338	+	PyErr_SetString ( BossError, e.what() );
4339	+	return NULL;
4340	+	}
4341	+	}
4342	+	{
4343	+	BossChain * resultptr;
4344	+	resultptr = new BossChain((BossChain &) result);
4345	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4346	+	}
4347	+	return resultobj;
4348	+	fail:
4349	+	return NULL;
4350	+	}
4351	+
4352	+
4353		static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4354		PyObject *resultobj;
4355		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5267 | Line 5246 | static PyObject *_wrap_BossTask_load(PyO
5246		}
5247
5248
5249	+	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5250	+	PyObject *resultobj;
5251	+	BossTask *arg1 = (BossTask *) 0 ;
5252	+	int arg2 = (int) SCHEDULED ;
5253	+	std::string const &arg3_defvalue = "all" ;
5254	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
5255	+	std::string const &arg4_defvalue = "" ;
5256	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
5257	+	std::string arg5 = (std::string) "" ;
5258	+	std::string arg6 = (std::string) "" ;
5259	+	std::string arg7 = (std::string) "" ;
5260	+	std::string arg8 = (std::string) "" ;
5261	+	unsigned int arg9 = (unsigned int) 0 ;
5262	+	int result;
5263	+	std::string temp3 ;
5264	+	std::string temp4 ;
5265	+	PyObject * obj0 = 0 ;
5266	+	PyObject * obj2 = 0 ;
5267	+	PyObject * obj3 = 0 ;
5268	+	PyObject * obj4 = 0 ;
5269	+	PyObject * obj5 = 0 ;
5270	+	PyObject * obj6 = 0 ;
5271	+	PyObject * obj7 = 0 ;
5272	+	PyObject * obj8 = 0 ;
5273	+
5274	+	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5275	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5276	+	if (obj2) {
5277	+	{
5278	+	if (PyString_Check(obj2)) {
5279	+	temp3 = std::string(PyString_AsString(obj2));
5280	+	arg3 = &temp3;
5281	+	}else {
5282	+	SWIG_exception(SWIG_TypeError, "string expected");
5283	+	}
5284	+	}
5285	+	}
5286	+	if (obj3) {
5287	+	{
5288	+	if (PyString_Check(obj3)) {
5289	+	temp4 = std::string(PyString_AsString(obj3));
5290	+	arg4 = &temp4;
5291	+	}else {
5292	+	SWIG_exception(SWIG_TypeError, "string expected");
5293	+	}
5294	+	}
5295	+	}
5296	+	if (obj4) {
5297	+	{
5298	+	if (PyString_Check(obj4))
5299	+	arg5 = std::string(PyString_AsString(obj4));
5300	+	else
5301	+	SWIG_exception(SWIG_TypeError, "string expected");
5302	+	}
5303	+	}
5304	+	if (obj5) {
5305	+	{
5306	+	if (PyString_Check(obj5))
5307	+	arg6 = std::string(PyString_AsString(obj5));
5308	+	else
5309	+	SWIG_exception(SWIG_TypeError, "string expected");
5310	+	}
5311	+	}
5312	+	if (obj6) {
5313	+	{
5314	+	if (PyString_Check(obj6))
5315	+	arg7 = std::string(PyString_AsString(obj6));
5316	+	else
5317	+	SWIG_exception(SWIG_TypeError, "string expected");
5318	+	}
5319	+	}
5320	+	if (obj7) {
5321	+	{
5322	+	if (PyString_Check(obj7))
5323	+	arg8 = std::string(PyString_AsString(obj7));
5324	+	else
5325	+	SWIG_exception(SWIG_TypeError, "string expected");
5326	+	}
5327	+	}
5328	+	if (obj8) {
5329	+	arg9 = (unsigned int) PyInt_AsLong(obj8);
5330	+	if (PyErr_Occurred()) SWIG_fail;
5331	+	}
5332	+	{
5333	+	try {
5334	+	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5335	+
5336	+	}catch (const BossSchedFailure & e) {
5337	+	PyErr_SetString ( SchedulerError, e.what() );
5338	+	return NULL;
5339	+	}catch (const std::exception& e) {
5340	+	PyErr_SetString ( BossError, e.what() );
5341	+	return NULL;
5342	+	}
5343	+	}
5344	+	resultobj = PyInt_FromLong((long)result);
5345	+	return resultobj;
5346	+	fail:
5347	+	return NULL;
5348	+	}
5349	+
5350	+
5351		static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
5352		PyObject *resultobj;
5353		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5596 | Line 5677 | static PyObject *_wrap_BossTask_job(PyOb
5677		}
5678
5679
5680	+	static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
5681	+	PyObject *resultobj;
5682	+	BossTask *arg1 = (BossTask *) 0 ;
5683	+	std::string *arg2 = 0 ;
5684	+	PyObject *result;
5685	+	std::string temp2 ;
5686	+	PyObject * obj0 = 0 ;
5687	+	PyObject * obj1 = 0 ;
5688	+
5689	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5690	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5691	+	{
5692	+	if (PyString_Check(obj1)) {
5693	+	temp2 = std::string(PyString_AsString(obj1));
5694	+	arg2 = &temp2;
5695	+	}else {
5696	+	SWIG_exception(SWIG_TypeError, "string expected");
5697	+	}
5698	+	}
5699	+	{
5700	+	try {
5701	+	result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
5702	+
5703	+	}catch (const BossSchedFailure & e) {
5704	+	PyErr_SetString ( SchedulerError, e.what() );
5705	+	return NULL;
5706	+	}catch (const std::exception& e) {
5707	+	PyErr_SetString ( BossError, e.what() );
5708	+	return NULL;
5709	+	}
5710	+	}
5711	+	resultobj = result;
5712	+	return resultobj;
5713	+	fail:
5714	+	return NULL;
5715	+	}
5716	+
5717	+
5718		static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5719		PyObject *resultobj;
5720		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5623 | Line 5742 | static PyObject *_wrap_BossTask_jobState
5742		}
5743
5744
5745	+	static PyObject *_wrap_BossTask_joblist(PyObject *self, PyObject *args) {
5746	+	PyObject *resultobj;
5747	+	BossTask *arg1 = (BossTask *) 0 ;
5748	+	PyObject *result;
5749	+	PyObject * obj0 = 0 ;
5750	+
5751	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_joblist",&obj0)) goto fail;
5752	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5753	+	{
5754	+	try {
5755	+	result = (PyObject *)BossTask_joblist(arg1);
5756	+
5757	+	}catch (const BossSchedFailure & e) {
5758	+	PyErr_SetString ( SchedulerError, e.what() );
5759	+	return NULL;
5760	+	}catch (const std::exception& e) {
5761	+	PyErr_SetString ( BossError, e.what() );
5762	+	return NULL;
5763	+	}
5764	+	}
5765	+	resultobj = result;
5766	+	return resultobj;
5767	+	fail:
5768	+	return NULL;
5769	+	}
5770	+
5771	+
5772		static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5773		PyObject *resultobj;
5774		BossTask *arg1 = (BossTask *) 0 ;
#	Line 6830 | Line 6976 | static PyMethodDef SwigMethods[] = {
6976		{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6977		{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6978		{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6979	+	{ (char *)"BossSession_task_begin", _wrap_BossSession_task_begin, METH_VARARGS },
6980	+	{ (char *)"BossSession_task_end", _wrap_BossSession_task_end, METH_VARARGS },
6981	+	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
6982	+	{ (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
6983		{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6984		{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6985		{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
#	Line 6845 | Line 6995 | static PyMethodDef SwigMethods[] = {
6995		{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
6996		{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6997		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6848	–	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6849	–	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6850	–	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
6998		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6999		{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
7000	+	{ (char *)"BossSession_getTasksByTaskInfo", _wrap_BossSession_getTasksByTaskInfo, METH_VARARGS },
7001	+	{ (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
7002		{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7003		{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7004		{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
7005		{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
7006		{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
7007		{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7008	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7008	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7009		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6861	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6862	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7010		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
6864	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7011		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7012		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7013		{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7014		{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7015	+	{ (char *)"BossTask_jobsInMemory", _wrap_BossTask_jobsInMemory, METH_VARARGS },
7016		{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7017		{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7018		{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
#	Line 6873 | Line 7020 | static PyMethodDef SwigMethods[] = {
7020		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7021		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7022		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7023	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7024		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
7025		{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7026		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
#	Line 6886 | Line 7034 | static PyMethodDef SwigMethods[] = {
7034		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7035		{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7036		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7037	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7038		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7039		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7040		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
#	Line 6893 | Line 7042 | static PyMethodDef SwigMethods[] = {
7042		{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7043		{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7044		{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7045	+	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7046		{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7047	+	{ (char *)"BossTask_joblist", _wrap_BossTask_joblist, METH_VARARGS },
7048		{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7049		{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7050		{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
#	Line 6928 | Line 7079 | static swig_type_info _swigt__p_std__vec
7079		static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7080		static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator", 0, "std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator"},{0}};
7081		static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7082	<	static swig_type_info _swigt__p_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_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7083		static swig_type_info _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t[] = {{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t", 0, "std::map<std::string,std::map<std::string,std::string > > *", 0},{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t"},{0}};
7084		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7085		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
#	Line 6942 | Line 7093 | static swig_type_info _swigt__p_BossSess
7093		static swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0},{"_p_std__vectorTstd__string_t"},{0}};
7094		static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
7095		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
6945	–	static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
7096		static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
7097	+	static swig_type_info _swigt__p_BossSession__task_iterator[] = {{"_p_BossSession__task_iterator", 0, "BossSession::task_iterator const *", 0},{"_p_BossSession__task_iterator"},{0}};
7098	+	static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
7099		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7100
7101		static swig_type_info *swig_types_initial[] = {
#	Line 6951 | Line 7103 | _swigt__p_std__vectorTstd__pairTBossProg
7103		_swigt__p_XMLDoc,
7104		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7105		_swigt__p_BossProgramExec,
7106	<	_swigt__p_std__vectorTBossTask_p_t,
7106	>	_swigt__p_BossChain,
7107		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
7108		_swigt__p_BossTask,
7109		_swigt__p_BossTaskException,
#	Line 6965 | Line 7117 | _swigt__p_BossSession,
7117		_swigt__p_std__vectorTstd__string_t,
7118		_swigt__p_std__mapTstd__string_std__string_t,
7119		_swigt__p_BossAdministratorSession,
6968	–	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7120		_swigt__p_BossTask__job_iterator,
7121	+	_swigt__p_BossSession__task_iterator,
7122	+	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7123		_swigt__p_jobStates,
7124		0
7125		};

Diff Legend

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