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.33 by gcodispo, Fri Jun 8 15:49:19 2007 UTC vs.
Revision 1.37 by gcodispo, Wed Jul 18 13:53:45 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]
662	<	#define  SWIGTYPE_p_BossChain swig_types[5]
663	<	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[6]
664	<	#define  SWIGTYPE_p_BossTask swig_types[7]
665	<	#define  SWIGTYPE_p_BossTaskException swig_types[8]
666	<	#define  SWIGTYPE_p_std__ostream swig_types[9]
667	<	#define  SWIGTYPE_p_BossProgram swig_types[10]
668	<	#define  SWIGTYPE_p_printOption swig_types[11]
669	<	#define  SWIGTYPE_p_BossAttributeContainer swig_types[12]
670	<	#define  SWIGTYPE_p_BossJob swig_types[13]
671	<	#define  SWIGTYPE_p_BossDatabase swig_types[14]
672	<	#define  SWIGTYPE_p_BossSession swig_types[15]
673	<	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[16]
674	<	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[17]
675	<	#define  SWIGTYPE_p_BossAdministratorSession swig_types[18]
676	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[19]
661	>	#define  SWIGTYPE_p_BossChain swig_types[4]
662	>	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[5]
663	>	#define  SWIGTYPE_p_BossTask swig_types[6]
664	>	#define  SWIGTYPE_p_BossTaskException swig_types[7]
665	>	#define  SWIGTYPE_p_std__ostream swig_types[8]
666	>	#define  SWIGTYPE_p_BossProgram swig_types[9]
667	>	#define  SWIGTYPE_p_printOption swig_types[10]
668	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[11]
669	>	#define  SWIGTYPE_p_BossJob swig_types[12]
670	>	#define  SWIGTYPE_p_BossDatabase swig_types[13]
671	>	#define  SWIGTYPE_p_BossSession swig_types[14]
672	>	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[15]
673	>	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[16]
674	>	#define  SWIGTYPE_p_BossAdministratorSession swig_types[17]
675	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[18]
676	>	#define  SWIGTYPE_p_BossSession__task_iterator swig_types[19]
677		#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[20]
678		#define  SWIGTYPE_p_jobStates swig_types[21]
679		static swig_type_info *swig_types[23];
#	Line 969 | Line 969 | PyObject *BossSession_schedListMatch(Bos
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;
975	<	if ( taskName.empty() ) {
976	<	taskList = self->selectTasks( taskRange, before, after, user);
977	<	} else {
978	<	taskList = self->selectTasksByName( taskName );
979	<	}
980	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
981	<	it!= taskList.end(); ++it ) {
982	<	PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
983	<	}
984	<	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 1035 | Line 1025 | PyObject *BossTask_jobsDict(BossTask *se
1025		return job_dict;
1026		}
1027		PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1028	<
1028	>	if ( ! self->jobsInMemory() ) self->load( ALL, jobid );
1029		PyObject * job_dict = PyDict_New();
1040	–	self->load( ALL, jobid );
1030		BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1031		return job_dict;
1032		}
#	Line 1063 | Line 1052 | PyObject *BossTask_jobStates(BossTask *s
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();
#	Line 2529 | 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 3079 | 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 3094 | 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 3106 | 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 3175 | Line 3299 | static PyObject *_wrap_BossSession_sched
3299		arg10 = (unsigned int) PyInt_AsLong(obj9);
3300		if (PyErr_Occurred()) SWIG_fail;
3301		}
3302	<	{
3303	<	try {
3304	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3181	<
3182	<	}catch (const BossSchedFailure & e) {
3183	<	PyErr_SetString ( SchedulerError, e.what() );
3184	<	return NULL;
3185	<	}catch (const std::exception& e) {
3186	<	PyErr_SetString ( BossError, e.what() );
3187	<	return NULL;
3188	<	}
3189	<	}
3190	<	Py_INCREF(Py_None); resultobj = Py_None;
3191	<	return resultobj;
3192	<	fail:
3193	<	return NULL;
3194	<	}
3195	<
3196	<
3197	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3198	<	PyObject *resultobj;
3199	<	BossSession *arg1 = (BossSession *) 0 ;
3200	<	std::string const &arg2_defvalue = "all" ;
3201	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3202	<	std::string const &arg3_defvalue = "" ;
3203	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3204	<	std::string const &arg4_defvalue = "" ;
3205	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3206	<	std::string const &arg5_defvalue = "" ;
3207	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3208	<	std::vector<std::string > result;
3209	<	std::string temp2 ;
3210	<	std::string temp3 ;
3211	<	std::string temp4 ;
3212	<	std::string temp5 ;
3213	<	PyObject * obj0 = 0 ;
3214	<	PyObject * obj1 = 0 ;
3215	<	PyObject * obj2 = 0 ;
3216	<	PyObject * obj3 = 0 ;
3217	<	PyObject * obj4 = 0 ;
3218	<
3219	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3220	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3221	<	if (obj1) {
3222	<	{
3223	<	if (PyString_Check(obj1)) {
3224	<	temp2 = std::string(PyString_AsString(obj1));
3225	<	arg2 = &temp2;
3226	<	}else {
3227	<	SWIG_exception(SWIG_TypeError, "string expected");
3228	<	}
3229	<	}
3230	<	}
3231	<	if (obj2) {
3232	<	{
3233	<	if (PyString_Check(obj2)) {
3234	<	temp3 = std::string(PyString_AsString(obj2));
3235	<	arg3 = &temp3;
3236	<	}else {
3237	<	SWIG_exception(SWIG_TypeError, "string expected");
3238	<	}
3239	<	}
3240	<	}
3241	<	if (obj3) {
3242	<	{
3243	<	if (PyString_Check(obj3)) {
3244	<	temp4 = std::string(PyString_AsString(obj3));
3245	<	arg4 = &temp4;
3246	<	}else {
3247	<	SWIG_exception(SWIG_TypeError, "string expected");
3248	<	}
3249	<	}
3250	<	}
3251	<	if (obj4) {
3252	<	{
3253	<	if (PyString_Check(obj4)) {
3254	<	temp5 = std::string(PyString_AsString(obj4));
3255	<	arg5 = &temp5;
3256	<	}else {
3257	<	SWIG_exception(SWIG_TypeError, "string expected");
3258	<	}
3259	<	}
3302	>	if (obj10) {
3303	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3304	>	if (PyErr_Occurred()) SWIG_fail;
3305		}
3306		{
3307		try {
3308	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
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 3270 | Line 3315 | static PyObject *_wrap_BossSession_selec
3315		return NULL;
3316		}
3317		}
3318	<	{
3274	<	resultobj = PyTuple_New((&result)->size());
3275	<	for (unsigned int i=0; i<(&result)->size(); i++)
3276	<	PyTuple_SetItem(resultobj,i,
3277	<	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3278	<	}
3318	>	Py_INCREF(Py_None); resultobj = Py_None;
3319		return resultobj;
3320		fail:
3321		return NULL;
3322		}
3323
3324
3325	<	static PyObject *_wrap_BossSession_selectTasksByName(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 *arg2 = 0 ;
3329	<	std::vector<std::string > result;
3329	>	unsigned int result;
3330		std::string temp2 ;
3331		PyObject * obj0 = 0 ;
3332		PyObject * obj1 = 0 ;
3333
3334	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) 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		{
3337		if (PyString_Check(obj1)) {
#	Line 3303 | Line 3343 | static PyObject *_wrap_BossSession_selec
3343		}
3344		{
3345		try {
3346	<	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3346	>	result = (unsigned int)(arg1)->getTasksByName((std::string const &)*arg2);
3347
3348		}catch (const BossSchedFailure & e) {
3349		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3313 | Line 3353 | static PyObject *_wrap_BossSession_selec
3353		return NULL;
3354		}
3355		}
3356	<	{
3317	<	resultobj = PyTuple_New((&result)->size());
3318	<	for (unsigned int i=0; i<(&result)->size(); i++)
3319	<	PyTuple_SetItem(resultobj,i,
3320	<	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3321	<	}
3322	<	return resultobj;
3323	<	fail:
3324	<	return NULL;
3325	<	}
3326	<
3327	<
3328	<	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3329	<	PyObject *resultobj;
3330	<	BossSession *arg1 = (BossSession *) 0 ;
3331	<	int arg2 = (int) SCHEDULED ;
3332	<	std::string const &arg3_defvalue = "all" ;
3333	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
3334	<	std::string const &arg4_defvalue = "all" ;
3335	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3336	<	std::string const &arg5_defvalue = "" ;
3337	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3338	<	std::string arg6 = (std::string) "" ;
3339	<	std::string arg7 = (std::string) "" ;
3340	<	std::string arg8 = (std::string) "" ;
3341	<	std::string arg9 = (std::string) "" ;
3342	<	unsigned int arg10 = (unsigned int) 0 ;
3343	<	bool arg11 = (bool) false ;
3344	<	SwigValueWrapper< std::vector<BossTask * > > result;
3345	<	std::string temp3 ;
3346	<	std::string temp4 ;
3347	<	std::string temp5 ;
3348	<	PyObject * obj0 = 0 ;
3349	<	PyObject * obj2 = 0 ;
3350	<	PyObject * obj3 = 0 ;
3351	<	PyObject * obj4 = 0 ;
3352	<	PyObject * obj5 = 0 ;
3353	<	PyObject * obj6 = 0 ;
3354	<	PyObject * obj7 = 0 ;
3355	<	PyObject * obj8 = 0 ;
3356	<	PyObject * obj9 = 0 ;
3357	<	PyObject * obj10 = 0 ;
3358	<
3359	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3360	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3361	<	if (obj2) {
3362	<	{
3363	<	if (PyString_Check(obj2)) {
3364	<	temp3 = std::string(PyString_AsString(obj2));
3365	<	arg3 = &temp3;
3366	<	}else {
3367	<	SWIG_exception(SWIG_TypeError, "string expected");
3368	<	}
3369	<	}
3370	<	}
3371	<	if (obj3) {
3372	<	{
3373	<	if (PyString_Check(obj3)) {
3374	<	temp4 = std::string(PyString_AsString(obj3));
3375	<	arg4 = &temp4;
3376	<	}else {
3377	<	SWIG_exception(SWIG_TypeError, "string expected");
3378	<	}
3379	<	}
3380	<	}
3381	<	if (obj4) {
3382	<	{
3383	<	if (PyString_Check(obj4)) {
3384	<	temp5 = std::string(PyString_AsString(obj4));
3385	<	arg5 = &temp5;
3386	<	}else {
3387	<	SWIG_exception(SWIG_TypeError, "string expected");
3388	<	}
3389	<	}
3390	<	}
3391	<	if (obj5) {
3392	<	{
3393	<	if (PyString_Check(obj5))
3394	<	arg6 = std::string(PyString_AsString(obj5));
3395	<	else
3396	<	SWIG_exception(SWIG_TypeError, "string expected");
3397	<	}
3398	<	}
3399	<	if (obj6) {
3400	<	{
3401	<	if (PyString_Check(obj6))
3402	<	arg7 = std::string(PyString_AsString(obj6));
3403	<	else
3404	<	SWIG_exception(SWIG_TypeError, "string expected");
3405	<	}
3406	<	}
3407	<	if (obj7) {
3408	<	{
3409	<	if (PyString_Check(obj7))
3410	<	arg8 = std::string(PyString_AsString(obj7));
3411	<	else
3412	<	SWIG_exception(SWIG_TypeError, "string expected");
3413	<	}
3414	<	}
3415	<	if (obj8) {
3416	<	{
3417	<	if (PyString_Check(obj8))
3418	<	arg9 = std::string(PyString_AsString(obj8));
3419	<	else
3420	<	SWIG_exception(SWIG_TypeError, "string expected");
3421	<	}
3422	<	}
3423	<	if (obj9) {
3424	<	arg10 = (unsigned int) PyInt_AsLong(obj9);
3425	<	if (PyErr_Occurred()) SWIG_fail;
3426	<	}
3427	<	if (obj10) {
3428	<	arg11 = PyInt_AsLong(obj10) ? true : false;
3429	<	if (PyErr_Occurred()) SWIG_fail;
3430	<	}
3431	<	{
3432	<	try {
3433	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3434	<
3435	<	}catch (const BossSchedFailure & e) {
3436	<	PyErr_SetString ( SchedulerError, e.what() );
3437	<	return NULL;
3438	<	}catch (const std::exception& e) {
3439	<	PyErr_SetString ( BossError, e.what() );
3440	<	return NULL;
3441	<	}
3442	<	}
3443	<	{
3444	<	std::vector<BossTask * > * resultptr;
3445	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3446	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3447	<	}
3356	>	resultobj = PyInt_FromLong((long)result);
3357		return resultobj;
3358		fail:
3359		return NULL;
3360		}
3361
3362
3363	<	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3363	>	static PyObject *_wrap_BossSession_getTasksByTaskInfo(PyObject *self, PyObject *args) {
3364		PyObject *resultobj;
3365		BossSession *arg1 = (BossSession *) 0 ;
3366		std::string *arg2 = 0 ;
3367	<	SwigValueWrapper< std::vector<BossTask * > > result;
3367	>	unsigned int result;
3368		std::string temp2 ;
3369		PyObject * obj0 = 0 ;
3370		PyObject * obj1 = 0 ;
3371
3372	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) 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		{
3375		if (PyString_Check(obj1)) {
#	Line 3472 | Line 3381 | static PyObject *_wrap_BossSession_getTa
3381		}
3382		{
3383		try {
3384	<	result = (arg1)->getTasksByName((std::string const &)*arg2);
3384	>	result = (unsigned int)(arg1)->getTasksByTaskInfo((std::string const &)*arg2);
3385
3386		}catch (const BossSchedFailure & e) {
3387		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3482 | Line 3391 | static PyObject *_wrap_BossSession_getTa
3391		return NULL;
3392		}
3393		}
3394	<	{
3486	<	std::vector<BossTask * > * resultptr;
3487	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3488	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3489	<	}
3394	>	resultobj = PyInt_FromLong((long)result);
3395		return resultobj;
3396		fail:
3397		return NULL;
#	Line 3497 | Line 3402 | static PyObject *_wrap_BossSession_getTa
3402		PyObject *resultobj;
3403		BossSession *arg1 = (BossSession *) 0 ;
3404		std::string *arg2 = 0 ;
3405	<	SwigValueWrapper< std::vector<BossTask * > > result;
3405	>	unsigned int result;
3406		std::string temp2 ;
3407		PyObject * obj0 = 0 ;
3408		PyObject * obj1 = 0 ;
#	Line 3514 | Line 3419 | static PyObject *_wrap_BossSession_getTa
3419		}
3420		{
3421		try {
3422	<	result = (arg1)->getTasksByJobName((std::string const &)*arg2);
3518	<
3519	<	}catch (const BossSchedFailure & e) {
3520	<	PyErr_SetString ( SchedulerError, e.what() );
3521	<	return NULL;
3522	<	}catch (const std::exception& e) {
3523	<	PyErr_SetString ( BossError, e.what() );
3524	<	return NULL;
3525	<	}
3526	<	}
3527	<	{
3528	<	std::vector<BossTask * > * resultptr;
3529	<	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3530	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3531	<	}
3532	<	return resultobj;
3533	<	fail:
3534	<	return NULL;
3535	<	}
3536	<
3537	<
3538	<	static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
3539	<	PyObject *resultobj;
3540	<	BossSession *arg1 = (BossSession *) 0 ;
3541	<	unsigned int result;
3542	<	PyObject * obj0 = 0 ;
3543	<
3544	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
3545	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3546	<	{
3547	<	try {
3548	<	result = (unsigned int)(arg1)->tasksInMemory();
3422	>	result = (unsigned int)(arg1)->getTasksByJobName((std::string const &)*arg2);
3423
3424		}catch (const BossSchedFailure & e) {
3425		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3562 | Line 3436 | static PyObject *_wrap_BossSession_tasks
3436		}
3437
3438
3565	–	static PyObject *_wrap_BossSession_locate(PyObject *self, PyObject *args) {
3566	–	PyObject *resultobj;
3567	–	BossSession *arg1 = (BossSession *) 0 ;
3568	–	unsigned int arg2 ;
3569	–	BossTask *result;
3570	–	PyObject * obj0 = 0 ;
3571	–	PyObject * obj1 = 0 ;
3572	–
3573	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
3574	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3575	–	arg2 = (unsigned int) PyInt_AsLong(obj1);
3576	–	if (PyErr_Occurred()) SWIG_fail;
3577	–	{
3578	–	try {
3579	–	result = (BossTask *)(arg1)->locate(arg2);
3580	–
3581	–	}catch (const BossSchedFailure & e) {
3582	–	PyErr_SetString ( SchedulerError, e.what() );
3583	–	return NULL;
3584	–	}catch (const std::exception& e) {
3585	–	PyErr_SetString ( BossError, e.what() );
3586	–	return NULL;
3587	–	}
3588	–	}
3589	–	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
3590	–	return resultobj;
3591	–	fail:
3592	–	return NULL;
3593	–	}
3594	–
3595	–
3439		static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3440		PyObject *resultobj;
3441		BossSession *arg1 = (BossSession *) 0 ;
#	Line 3817 | 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	<	std::string const &arg2_defvalue = "" ;
3824	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
3666	>	int arg2 = (int) SCHEDULED ;
3667		std::string const &arg3_defvalue = "all" ;
3668		std::string *arg3 = (std::string *) &arg3_defvalue ;
3669	<	std::string arg4 = (std::string) "" ;
3670	<	std::string arg5 = (std::string) "" ;
3669	>	std::string const &arg4_defvalue = "all" ;
3670	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3671	>	std::string const &arg5_defvalue = "" ;
3672	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3673		std::string arg6 = (std::string) "" ;
3674	<	PyObject *result;
3675	<	std::string temp2 ;
3674	>	std::string arg7 = (std::string) "" ;
3675	>	std::string arg8 = (std::string) "" ;
3676	>	std::string arg9 = (std::string) "" ;
3677	>	unsigned int arg10 = (unsigned int) 0 ;
3678	>	bool arg11 = (bool) false ;
3679		std::string temp3 ;
3680	+	std::string temp4 ;
3681	+	std::string temp5 ;
3682		PyObject * obj0 = 0 ;
3834	–	PyObject * obj1 = 0 ;
3683		PyObject * obj2 = 0 ;
3684		PyObject * obj3 = 0 ;
3685		PyObject * obj4 = 0 ;
3686		PyObject * obj5 = 0 ;
3687	+	PyObject * obj6 = 0 ;
3688	+	PyObject * obj7 = 0 ;
3689	+	PyObject * obj8 = 0 ;
3690	+	PyObject * obj9 = 0 ;
3691	+	PyObject * obj10 = 0 ;
3692
3693	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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 (obj1) {
3695	>	if (obj2) {
3696		{
3697	<	if (PyString_Check(obj1)) {
3698	<	temp2 = std::string(PyString_AsString(obj1));
3699	<	arg2 = &temp2;
3697	>	if (PyString_Check(obj2)) {
3698	>	temp3 = std::string(PyString_AsString(obj2));
3699	>	arg3 = &temp3;
3700		}else {
3701		SWIG_exception(SWIG_TypeError, "string expected");
3702		}
3703		}
3704		}
3705	<	if (obj2) {
3705	>	if (obj3) {
3706		{
3707	<	if (PyString_Check(obj2)) {
3708	<	temp3 = std::string(PyString_AsString(obj2));
3709	<	arg3 = &temp3;
3707	>	if (PyString_Check(obj3)) {
3708	>	temp4 = std::string(PyString_AsString(obj3));
3709	>	arg4 = &temp4;
3710		}else {
3711		SWIG_exception(SWIG_TypeError, "string expected");
3712		}
3713		}
3714		}
3715	<	if (obj3) {
3715	>	if (obj4) {
3716		{
3717	<	if (PyString_Check(obj3))
3718	<	arg4 = std::string(PyString_AsString(obj3));
3717	>	if (PyString_Check(obj4)) {
3718	>	temp5 = std::string(PyString_AsString(obj4));
3719	>	arg5 = &temp5;
3720	>	}else {
3721	>	SWIG_exception(SWIG_TypeError, "string expected");
3722	>	}
3723	>	}
3724	>	}
3725	>	if (obj5) {
3726	>	{
3727	>	if (PyString_Check(obj5))
3728	>	arg6 = std::string(PyString_AsString(obj5));
3729		else
3730		SWIG_exception(SWIG_TypeError, "string expected");
3731		}
3732		}
3733	<	if (obj4) {
3733	>	if (obj6) {
3734		{
3735	<	if (PyString_Check(obj4))
3736	<	arg5 = std::string(PyString_AsString(obj4));
3735	>	if (PyString_Check(obj6))
3736	>	arg7 = std::string(PyString_AsString(obj6));
3737		else
3738		SWIG_exception(SWIG_TypeError, "string expected");
3739		}
3740		}
3741	<	if (obj5) {
3741	>	if (obj7) {
3742		{
3743	<	if (PyString_Check(obj5))
3744	<	arg6 = std::string(PyString_AsString(obj5));
3743	>	if (PyString_Check(obj7))
3744	>	arg8 = std::string(PyString_AsString(obj7));
3745		else
3746		SWIG_exception(SWIG_TypeError, "string expected");
3747		}
3748		}
3749	+	if (obj8) {
3750	+	{
3751	+	if (PyString_Check(obj8))
3752	+	arg9 = std::string(PyString_AsString(obj8));
3753	+	else
3754	+	SWIG_exception(SWIG_TypeError, "string expected");
3755	+	}
3756	+	}
3757	+	if (obj9) {
3758	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3759	+	if (PyErr_Occurred()) SWIG_fail;
3760	+	}
3761	+	if (obj10) {
3762	+	arg11 = PyInt_AsLong(obj10) ? true : false;
3763	+	if (PyErr_Occurred()) SWIG_fail;
3764	+	}
3765		{
3766		try {
3767	<	result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
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 3895 | 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 4029 | Line 3908 | static PyObject *_wrap_BossTask_job_end(
3908		}
3909
3910
3911	+	static PyObject *_wrap_BossTask_jobsInMemory(PyObject *self, PyObject *args) {
3912	+	PyObject *resultobj;
3913	+	BossTask *arg1 = (BossTask *) 0 ;
3914	+	unsigned int result;
3915	+	PyObject * obj0 = 0 ;
3916	+
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 = (unsigned int)((BossTask const *)arg1)->jobsInMemory();
3922	+
3923	+	}catch (const BossSchedFailure & e) {
3924	+	PyErr_SetString ( SchedulerError, e.what() );
3925	+	return NULL;
3926	+	}catch (const std::exception& e) {
3927	+	PyErr_SetString ( BossError, e.what() );
3928	+	return NULL;
3929	+	}
3930	+	}
3931	+	resultobj = PyInt_FromLong((long)result);
3932	+	return resultobj;
3933	+	fail:
3934	+	return NULL;
3935	+	}
3936	+
3937	+
3938		static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3939		PyObject *resultobj;
3940		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5837 | Line 5743 | static PyObject *_wrap_BossTask_jobState
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 ;
#	Line 7044 | 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 7059 | 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 },
7062	–	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7063	–	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
7064	–	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, 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 },
7068	–	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
7069	–	{ (char *)"BossSession_locate", _wrap_BossSession_locate, 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 },
7011		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, 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 },
#	Line 7111 | Line 7045 | static PyMethodDef SwigMethods[] = {
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 },
#	Line 7145 | Line 7080 | static swig_type_info _swigt__p_std__vec
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_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7148	–	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}};
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}};
7085		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
#	Line 7161 | Line 7095 | static swig_type_info _swigt__p_std__vec
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}};
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
#	Line 7169 | Line 7104 | _swigt__p_std__vectorTstd__pairTBossProg
7104		_swigt__p_XMLDoc,
7105		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7106		_swigt__p_BossProgramExec,
7172	–	_swigt__p_std__vectorTBossTask_p_t,
7107		_swigt__p_BossChain,
7108		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
7109		_swigt__p_BossTask,
#	Line 7185 | Line 7119 | _swigt__p_std__vectorTstd__string_t,
7119		_swigt__p_std__mapTstd__string_std__string_t,
7120		_swigt__p_BossAdministratorSession,
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

Diff Legend

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