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.19 by gcodispo, Wed Dec 13 18:26:33 2006 UTC vs.
Revision 1.29 by gcodispo, Fri Mar 9 15:40:00 2007 UTC

#	Line 654 | Line 654 | SWIG_InstallConstants(PyObject *d, swig_
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define  SWIGTYPE_p_XMLDoc swig_types[0]
658	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
657	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[0]
658	>	#define  SWIGTYPE_p_XMLDoc swig_types[1]
659		#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660	<	#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[3]
661	<	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662	<	#define  SWIGTYPE_p_std__ostream swig_types[5]
660	>	#define  SWIGTYPE_p_BossProgramExec swig_types[3]
661	>	#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[4]
662	>	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[5]
663		#define  SWIGTYPE_p_BossTask swig_types[6]
664		#define  SWIGTYPE_p_BossTaskException swig_types[7]
665	<	#define  SWIGTYPE_p_printOption swig_types[8]
666	<	#define  SWIGTYPE_p_BossAttributeContainer swig_types[9]
667	<	#define  SWIGTYPE_p_BossJob swig_types[10]
668	<	#define  SWIGTYPE_p_BossDatabase swig_types[11]
669	<	#define  SWIGTYPE_p_BossSession swig_types[12]
670	<	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671	<	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672	<	#define  SWIGTYPE_p_BossAdministratorSession swig_types[15]
673	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[17]
675	<	#define  SWIGTYPE_p_jobStates swig_types[18]
676	<	static swig_type_info *swig_types[20];
665	>	#define  SWIGTYPE_p_std__ostream swig_types[8]
666	>	#define  SWIGTYPE_p_BossProgram swig_types[9]
667	>	#define  SWIGTYPE_p_printOption swig_types[10]
668	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[11]
669	>	#define  SWIGTYPE_p_BossJob swig_types[12]
670	>	#define  SWIGTYPE_p_BossDatabase swig_types[13]
671	>	#define  SWIGTYPE_p_BossSession swig_types[14]
672	>	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[15]
673	>	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[16]
674	>	#define  SWIGTYPE_p_BossAdministratorSession swig_types[17]
675	>	#define  SWIGTYPE_p_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];
679
680		/* -------- TYPES TABLE (END) -------- */
681
#	Line 957 | Line 959 | PyObject *BossSession_schedulers(BossSes
959		std::vector<std::string> my_vec = self->showSchedulers();
960		return BossSession_show( self, my_vec );
961		}
962	<	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
962	>	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){
963		std::vector<std::string> my_vec = self->listMatch( scheduler,
964		schclassad,
965		keepfile,
966		taskid,
967	<	jobid);
967	>	jobid,
968	>	timeout);
969		return BossSession_show( self, my_vec );
970		}
971	<	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,bool avoidCheck){
972	<	if ( !avoidCheck ) {
973	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
974	<	type, user, after, before);
975	<	}
976	<	PyObject * job_dict = PyList_New(0);
977	<	std::vector <std::string>
975	<	taskList = self->selectTasks( taskRange, before, after, user);
976	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
977	<	it!= taskList.end(); ++it ) {
978	<	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
971	>	PyObject *BossSession_queryTasks(BossSession *self,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
972	>	PyObject * task_list = PyList_New(0);
973	>	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	<	return  job_dict;
980	<	}
981	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
983	<	std::string tmp;
984	<	BossAttributeContainer::const_iterator it_end = obj.end ();
985	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
986	<	it != it_end; ++it) {
987	<	tmp = (*it).first.name ();
988	<	char * key = new char[ tmp.size() ];
989	<	key = strdup(tmp.c_str());
990	<	tmp = (*it).second.value ();
991	<	PyObject * val = PyString_FromString( tmp.c_str() );
992	<	PyDict_SetItemString( dict, key, val );
993	<	delete [] key;
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 dict;
983	>	return  task_list;
984	>	}
985	>	void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
986	>	std::string tmp;
987	>	BossAttributeContainer::const_iterator it_end = obj.end ();
988	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
989	>	it != it_end; ++it) {
990	>
991	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
992	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
993	>	PyDict_SetItem( dict, key, val);
994	>	Py_DECREF(key);
995	>	Py_DECREF(val);
996		}
997	<	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
997	>	return;
998	>	}
999	>	void BossTask_jobDict(BossTask const *self,BossJob const *jobH,PyObject *job_dict){
1000
1001	<	PyObject * job_dict = PyDict_New();
1001	>	//    PyObject * job_dict = PyDict_New();
1002		std::string tmp;
1003
1004	<	BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1005	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1004	>	BossAttributeContainer obj = jobH->getTableEntries("JOB");
1005	>	BossTask_appendToPyDict ( self, job_dict, obj );
1006
1007	<	std::set<std::string> sch = (*jit)->getSchedulerElements();
1007	>	std::set<std::string> sch = jobH->getSchedulerElements();
1008		std::set<std::string>::const_iterator sch_end =  sch.end();
1009		for (std::set<std::string>::const_iterator it =sch.begin();
1010		it != sch_end; ++ it ) {
1011	<	tmp = (*it);
1012	<	char * key = new char[ tmp.size() ];
1013	<	key = strdup(tmp.c_str());
1012	<	tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1011	>
1012	>	tmp = (*jobH)["JOB_SCHED_INFO."+(*it)];
1013	>	PyObject * key = PyString_FromString( it->c_str() );
1014		PyObject * val = PyString_FromString( tmp.c_str() );
1015	<	PyDict_SetItemString( job_dict, key, val );
1016	<	delete [] key;
1015	>	PyDict_SetItem( job_dict, key, val);
1016	>	Py_DECREF(key);
1017	>	Py_DECREF(val);
1018		}
1019	<	return job_dict;
1019	>	return;
1020		}
1021		PyObject *BossTask_jobsDict(BossTask *self){
1022
#	Line 1022 | Line 1024 | PyObject *BossTask_jobsDict(BossTask *se
1024		if ( self->job_begin () == self->job_end ()) self->load(ALL);
1025		for (BossTask::job_iterator jit = self->job_begin ();
1026		jit != self->job_end (); ++jit) {
1027	<	std::string id = (*jit)->chainId();
1028	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1029	<	PyObject * myid =  PyString_FromString(id.c_str() );
1030	<	PyDict_SetItem( job_dict, myid,tmp );
1027	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1028	>	PyObject * tmp_dict = PyDict_New();
1029	>	BossTask_jobDict( self, *jit, tmp_dict );
1030	>	PyDict_SetItem( job_dict, id, tmp_dict );
1031	>	Py_DECREF(id);
1032	>	Py_DECREF(tmp_dict);
1033	>	}
1034	>	return job_dict;
1035	>	}
1036	>	PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1037	>
1038	>	PyObject * job_dict = PyDict_New();
1039	>	self->load( ALL, jobid );
1040	>	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1041	>	return job_dict;
1042	>	}
1043	>	PyObject *BossTask_jobStates(BossTask *self){
1044	>
1045	>	PyObject * job_dict = PyDict_New();
1046	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1047	>	for (BossTask::job_iterator jit = self->job_begin ();
1048	>	jit != self->job_end (); ++jit) {
1049	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1050	>	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1051	>	PyDict_SetItem( job_dict, id, status );
1052	>	Py_DECREF(id);
1053	>	Py_DECREF(status);
1054	>	}
1055	>	return job_dict;
1056	>	}
1057	>	PyObject *BossTask_jobStatistic(BossTask *self){
1058	>
1059	>	PyObject * job_dict = PyDict_New();
1060	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1061	>	std::map< std::string, int > states;
1062	>	for (BossTask::job_iterator jit = self->job_begin ();
1063	>	jit != self->job_end (); ++jit) {
1064	>	++states[(**jit)["JOB.STATUS"]];
1065	>	}
1066	>
1067	>	std::map< std::string, int >::const_iterator end = states.end ();
1068	>	for (std::map< std::string, int >::const_iterator it = states.begin ();
1069	>	it != end; ++it) {
1070	>	PyObject * status = PyString_FromString( (it->first).c_str() );
1071	>	PyObject * jobs = PyString_FromFormat( "%d", it->second );
1072	>	PyDict_SetItem( job_dict, status, jobs );
1073	>	Py_DECREF(jobs);
1074	>	Py_DECREF(status);
1075		}
1076		return job_dict;
1077		}
#	Line 1070 | Line 1116 | PyObject *BossTask_jobPrograms(BossTask
1116		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1117		++programs_it  ) {
1118		std::string id = (programs_it->first)["PROGRAM.ID"];
1119	<	PyObject * tmp =  BossTask_progDict( self, programs_it );
1119	>	PyObject * tmp_dict =  BossTask_progDict( self, programs_it );
1120		PyObject * myid =  PyString_FromString(id.c_str() );
1121	<	PyDict_SetItem( job_dict, myid,tmp );
1121	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1122	>	Py_DECREF(myid);
1123	>	Py_DECREF(tmp_dict);
1124	>	}
1125	>	return job_dict;
1126	>	}
1127	>	PyObject *BossTask_program(BossTask *self,std::string const &jobid,std::string const &programId){
1128	>
1129	>	PyObject * job_dict = PyDict_New();
1130	>
1131	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1132	>	BossAttributeContainer obj =
1133	>	self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1134	>	BossTask_appendToPyDict ( self, job_dict, obj );
1135	>	return job_dict;
1136	>	}
1137	>	PyObject *BossTask_programExec(BossTask *self,std::string const &jobid,std::string const &programId){
1138	>
1139	>	PyObject * job_dict = PyDict_New();
1140	>
1141	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1142	>
1143	>	// PROGRAM_EXEC
1144	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1145	>	BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1146	>	BossTask_appendToPyDict ( self, job_dict, obj );
1147	>
1148	>	// SPECIFICS
1149	>	std::vector < BossAttributeContainer >::const_iterator it;
1150	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1151	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1152	>	BossTask_appendToPyDict ( self, job_dict, *it );
1153	>	}
1154	>	return job_dict;
1155	>	}
1156	>	PyObject *BossTask_specific(BossTask *self,std::string const &jobid,std::string const &programId){
1157	>
1158	>	PyObject * job_dict = PyDict_New();
1159	>
1160	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1161	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1162	>
1163	>	std::vector < BossAttributeContainer >::const_iterator it;
1164	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1165	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1166	>	BossTask_appendToPyDict ( self, job_dict, *it );
1167		}
1168		return job_dict;
1169		}
#	Line 2899 | Line 2990 | static PyObject *_wrap_BossSession_listM
2990		std::string *arg5 = (std::string *) &arg5_defvalue ;
2991		std::string const &arg6_defvalue = "" ;
2992		std::string *arg6 = (std::string *) &arg6_defvalue ;
2993	+	unsigned int arg7 = (unsigned int) 0 ;
2994		std::vector<std::string > result;
2995		std::string temp2 ;
2996		std::string temp3 ;
#	Line 2910 | Line 3002 | static PyObject *_wrap_BossSession_listM
3002		PyObject * obj3 = 0 ;
3003		PyObject * obj4 = 0 ;
3004		PyObject * obj5 = 0 ;
3005	+	PyObject * obj6 = 0 ;
3006
3007	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3007	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3008		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3009		{
3010		if (PyString_Check(obj1)) {
#	Line 2953 | Line 3046 | static PyObject *_wrap_BossSession_listM
3046		}
3047		}
3048		}
3049	+	if (obj6) {
3050	+	arg7 = (unsigned int) PyInt_AsLong(obj6);
3051	+	if (PyErr_Occurred()) SWIG_fail;
3052	+	}
3053		{
3054		try {
3055	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
3055	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
3056
3057		}catch (const BossSchedFailure & e) {
3058		PyErr_SetString ( SchedulerError, e.what() );
#	Line 2991 | Line 3088 | static PyObject *_wrap_BossSession_sched
3088		std::string arg7 = (std::string) "" ;
3089		std::string arg8 = (std::string) "" ;
3090		std::string arg9 = (std::string) "" ;
3091	+	unsigned int arg10 = (unsigned int) 0 ;
3092		std::string temp3 ;
3093		std::string temp4 ;
3094		std::string temp5 ;
#	Line 3002 | Line 3100 | static PyObject *_wrap_BossSession_sched
3100		PyObject * obj6 = 0 ;
3101		PyObject * obj7 = 0 ;
3102		PyObject * obj8 = 0 ;
3103	+	PyObject * obj9 = 0 ;
3104
3105	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3105	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3106		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3107		if (obj2) {
3108		{
#	Line 3067 | Line 3166 | static PyObject *_wrap_BossSession_sched
3166		SWIG_exception(SWIG_TypeError, "string expected");
3167		}
3168		}
3169	+	if (obj9) {
3170	+	arg10 = (unsigned int) PyInt_AsLong(obj9);
3171	+	if (PyErr_Occurred()) SWIG_fail;
3172	+	}
3173		{
3174		try {
3175	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3175	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3176
3177		}catch (const BossSchedFailure & e) {
3178		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3174 | Line 3277 | static PyObject *_wrap_BossSession_selec
3277		}
3278
3279
3280	+	static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
3281	+	PyObject *resultobj;
3282	+	BossSession *arg1 = (BossSession *) 0 ;
3283	+	std::string *arg2 = 0 ;
3284	+	std::vector<std::string > result;
3285	+	std::string temp2 ;
3286	+	PyObject * obj0 = 0 ;
3287	+	PyObject * obj1 = 0 ;
3288	+
3289	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3290	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3291	+	{
3292	+	if (PyString_Check(obj1)) {
3293	+	temp2 = std::string(PyString_AsString(obj1));
3294	+	arg2 = &temp2;
3295	+	}else {
3296	+	SWIG_exception(SWIG_TypeError, "string expected");
3297	+	}
3298	+	}
3299	+	{
3300	+	try {
3301	+	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3302	+
3303	+	}catch (const BossSchedFailure & e) {
3304	+	PyErr_SetString ( SchedulerError, e.what() );
3305	+	return NULL;
3306	+	}catch (const std::exception& e) {
3307	+	PyErr_SetString ( BossError, e.what() );
3308	+	return NULL;
3309	+	}
3310	+	}
3311	+	{
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 ;
#	Line 3188 | Line 3334 | static PyObject *_wrap_BossSession_query
3334		std::string arg7 = (std::string) "" ;
3335		std::string arg8 = (std::string) "" ;
3336		std::string arg9 = (std::string) "" ;
3337	<	bool arg10 = (bool) false ;
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 ;
#	Line 3202 | Line 3349 | static PyObject *_wrap_BossSession_query
3349		PyObject * obj7 = 0 ;
3350		PyObject * obj8 = 0 ;
3351		PyObject * obj9 = 0 ;
3352	+	PyObject * obj10 = 0 ;
3353
3354	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
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		{
#	Line 3268 | Line 3416 | static PyObject *_wrap_BossSession_query
3416		}
3417		}
3418		if (obj9) {
3419	<	arg10 = PyInt_AsLong(obj9) ? true : false;
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);
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	>	}
3443	>	return resultobj;
3444	>	fail:
3445	>	return NULL;
3446	>	}
3447	>
3448	>
3449	>	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3450	>	PyObject *resultobj;
3451	>	BossSession *arg1 = (BossSession *) 0 ;
3452	>	std::string *arg2 = 0 ;
3453	>	SwigValueWrapper< std::vector<BossTask * > > result;
3454	>	std::string temp2 ;
3455	>	PyObject * obj0 = 0 ;
3456	>	PyObject * obj1 = 0 ;
3457	>
3458	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3459	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3460	>	{
3461	>	if (PyString_Check(obj1)) {
3462	>	temp2 = std::string(PyString_AsString(obj1));
3463	>	arg2 = &temp2;
3464	>	}else {
3465	>	SWIG_exception(SWIG_TypeError, "string expected");
3466	>	}
3467	>	}
3468	>	{
3469	>	try {
3470	>	result = (arg1)->getTasksByName((std::string const &)*arg2);
3471
3472		}catch (const BossSchedFailure & e) {
3473		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3444 | Line 3638 | static PyObject *_wrap_BossSession_sched
3638		std::string *arg4 = (std::string *) &arg4_defvalue ;
3639		std::string const &arg5_defvalue = "" ;
3640		std::string *arg5 = (std::string *) &arg5_defvalue ;
3641	<	bool arg6 = (bool) false ;
3641	>	unsigned int arg6 = (unsigned int) 0 ;
3642	>	bool arg7 = (bool) false ;
3643		PyObject *result;
3644		std::string temp2 ;
3645		std::string temp3 ;
#	Line 3456 | Line 3651 | static PyObject *_wrap_BossSession_sched
3651		PyObject * obj3 = 0 ;
3652		PyObject * obj4 = 0 ;
3653		PyObject * obj5 = 0 ;
3654	+	PyObject * obj6 = 0 ;
3655
3656	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3656	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3657		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3658		{
3659		if (PyString_Check(obj1)) {
#	Line 3496 | Line 3692 | static PyObject *_wrap_BossSession_sched
3692		}
3693		}
3694		if (obj5) {
3695	<	arg6 = PyInt_AsLong(obj5) ? true : false;
3695	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3696	>	if (PyErr_Occurred()) SWIG_fail;
3697	>	}
3698	>	if (obj6) {
3699	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3700		if (PyErr_Occurred()) SWIG_fail;
3701		}
3702		{
3703		try {
3704	<	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3704	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3705
3706		}catch (const BossSchedFailure & e) {
3707		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3521 | Line 3721 | static PyObject *_wrap_BossSession_sched
3721		static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3722		PyObject *resultobj;
3723		BossSession *arg1 = (BossSession *) 0 ;
3724	<	int arg2 = (int) SCHEDULED ;
3724	>	std::string const &arg2_defvalue = "" ;
3725	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3726		std::string const &arg3_defvalue = "all" ;
3727		std::string *arg3 = (std::string *) &arg3_defvalue ;
3728	<	std::string const &arg4_defvalue = "all" ;
3729	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3529	<	std::string const &arg5_defvalue = "" ;
3530	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3728	>	std::string arg4 = (std::string) "" ;
3729	>	std::string arg5 = (std::string) "" ;
3730		std::string arg6 = (std::string) "" ;
3532	–	std::string arg7 = (std::string) "" ;
3533	–	std::string arg8 = (std::string) "" ;
3534	–	std::string arg9 = (std::string) "" ;
3535	–	bool arg10 = (bool) false ;
3731		PyObject *result;
3732	+	std::string temp2 ;
3733		std::string temp3 ;
3538	–	std::string temp4 ;
3539	–	std::string temp5 ;
3734		PyObject * obj0 = 0 ;
3735	+	PyObject * obj1 = 0 ;
3736		PyObject * obj2 = 0 ;
3737		PyObject * obj3 = 0 ;
3738		PyObject * obj4 = 0 ;
3739		PyObject * obj5 = 0 ;
3545	–	PyObject * obj6 = 0 ;
3546	–	PyObject * obj7 = 0 ;
3547	–	PyObject * obj8 = 0 ;
3548	–	PyObject * obj9 = 0 ;
3740
3741	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3741	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3742		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3743	<	if (obj2) {
3553	<	{
3554	<	if (PyString_Check(obj2)) {
3555	<	temp3 = std::string(PyString_AsString(obj2));
3556	<	arg3 = &temp3;
3557	<	}else {
3558	<	SWIG_exception(SWIG_TypeError, "string expected");
3559	<	}
3560	<	}
3561	<	}
3562	<	if (obj3) {
3743	>	if (obj1) {
3744		{
3745	<	if (PyString_Check(obj3)) {
3746	<	temp4 = std::string(PyString_AsString(obj3));
3747	<	arg4 = &temp4;
3745	>	if (PyString_Check(obj1)) {
3746	>	temp2 = std::string(PyString_AsString(obj1));
3747	>	arg2 = &temp2;
3748		}else {
3749		SWIG_exception(SWIG_TypeError, "string expected");
3750		}
3751		}
3752		}
3753	<	if (obj4) {
3753	>	if (obj2) {
3754		{
3755	<	if (PyString_Check(obj4)) {
3756	<	temp5 = std::string(PyString_AsString(obj4));
3757	<	arg5 = &temp5;
3755	>	if (PyString_Check(obj2)) {
3756	>	temp3 = std::string(PyString_AsString(obj2));
3757	>	arg3 = &temp3;
3758		}else {
3759		SWIG_exception(SWIG_TypeError, "string expected");
3760		}
3761		}
3762		}
3763	<	if (obj5) {
3583	<	{
3584	<	if (PyString_Check(obj5))
3585	<	arg6 = std::string(PyString_AsString(obj5));
3586	<	else
3587	<	SWIG_exception(SWIG_TypeError, "string expected");
3588	<	}
3589	<	}
3590	<	if (obj6) {
3763	>	if (obj3) {
3764		{
3765	<	if (PyString_Check(obj6))
3766	<	arg7 = std::string(PyString_AsString(obj6));
3765	>	if (PyString_Check(obj3))
3766	>	arg4 = std::string(PyString_AsString(obj3));
3767		else
3768		SWIG_exception(SWIG_TypeError, "string expected");
3769		}
3770		}
3771	<	if (obj7) {
3771	>	if (obj4) {
3772		{
3773	<	if (PyString_Check(obj7))
3774	<	arg8 = std::string(PyString_AsString(obj7));
3773	>	if (PyString_Check(obj4))
3774	>	arg5 = std::string(PyString_AsString(obj4));
3775		else
3776		SWIG_exception(SWIG_TypeError, "string expected");
3777		}
3778		}
3779	<	if (obj8) {
3779	>	if (obj5) {
3780		{
3781	<	if (PyString_Check(obj8))
3782	<	arg9 = std::string(PyString_AsString(obj8));
3781	>	if (PyString_Check(obj5))
3782	>	arg6 = std::string(PyString_AsString(obj5));
3783		else
3784		SWIG_exception(SWIG_TypeError, "string expected");
3785		}
3786		}
3614	–	if (obj9) {
3615	–	arg10 = PyInt_AsLong(obj9) ? true : false;
3616	–	if (PyErr_Occurred()) SWIG_fail;
3617	–	}
3787		{
3788		try {
3789	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3789	>	result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3790
3791		}catch (const BossSchedFailure & e) {
3792		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3766 | Line 3935 | static PyObject * BossTaskException_swig
3935		Py_INCREF(obj);
3936		return Py_BuildValue((char *)"");
3937		}
3938	+	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3939	+	PyObject *resultobj;
3940	+	BossTask *arg1 = (BossTask *) 0 ;
3941	+	BossTask::job_iterator result;
3942	+	PyObject * obj0 = 0 ;
3943	+
3944	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3945	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3946	+	{
3947	+	try {
3948	+	result = ((BossTask const *)arg1)->job_begin();
3949	+
3950	+	}catch (const BossSchedFailure & e) {
3951	+	PyErr_SetString ( SchedulerError, e.what() );
3952	+	return NULL;
3953	+	}catch (const std::exception& e) {
3954	+	PyErr_SetString ( BossError, e.what() );
3955	+	return NULL;
3956	+	}
3957	+	}
3958	+	{
3959	+	BossTask::job_iterator * resultptr;
3960	+	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3961	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3962	+	}
3963	+	return resultobj;
3964	+	fail:
3965	+	return NULL;
3966	+	}
3967	+
3968	+
3969	+	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3970	+	PyObject *resultobj;
3971	+	BossTask *arg1 = (BossTask *) 0 ;
3972	+	BossTask::job_iterator result;
3973	+	PyObject * obj0 = 0 ;
3974	+
3975	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3976	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3977	+	{
3978	+	try {
3979	+	result = ((BossTask const *)arg1)->job_end();
3980	+
3981	+	}catch (const BossSchedFailure & e) {
3982	+	PyErr_SetString ( SchedulerError, e.what() );
3983	+	return NULL;
3984	+	}catch (const std::exception& e) {
3985	+	PyErr_SetString ( BossError, e.what() );
3986	+	return NULL;
3987	+	}
3988	+	}
3989	+	{
3990	+	BossTask::job_iterator * resultptr;
3991	+	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3992	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3993	+	}
3994	+	return resultobj;
3995	+	fail:
3996	+	return NULL;
3997	+	}
3998	+
3999	+
4000	+	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4001	+	PyObject *resultobj;
4002	+	BossTask *arg1 = (BossTask *) 0 ;
4003	+	BossJob *arg2 = (BossJob *) 0 ;
4004	+	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4005	+	PyObject * obj0 = 0 ;
4006	+	PyObject * obj1 = 0 ;
4007	+
4008	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4009	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4010	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4011	+	{
4012	+	try {
4013	+	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4014	+
4015	+	}catch (const BossSchedFailure & e) {
4016	+	PyErr_SetString ( SchedulerError, e.what() );
4017	+	return NULL;
4018	+	}catch (const std::exception& e) {
4019	+	PyErr_SetString ( BossError, e.what() );
4020	+	return NULL;
4021	+	}
4022	+	}
4023	+	{
4024	+	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4025	+	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4026	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4027	+	}
4028	+	return resultobj;
4029	+	fail:
4030	+	return NULL;
4031	+	}
4032	+
4033	+
4034	+	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
4035	+	PyObject *resultobj;
4036	+	BossTask *arg1 = (BossTask *) 0 ;
4037	+	BossJob *arg2 = (BossJob *) 0 ;
4038	+	std::string *arg3 = 0 ;
4039	+	BossProgram result;
4040	+	std::string temp3 ;
4041	+	PyObject * obj0 = 0 ;
4042	+	PyObject * obj1 = 0 ;
4043	+	PyObject * obj2 = 0 ;
4044	+
4045	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
4046	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4047	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4048	+	{
4049	+	if (PyString_Check(obj2)) {
4050	+	temp3 = std::string(PyString_AsString(obj2));
4051	+	arg3 = &temp3;
4052	+	}else {
4053	+	SWIG_exception(SWIG_TypeError, "string expected");
4054	+	}
4055	+	}
4056	+	{
4057	+	try {
4058	+	result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
4059	+
4060	+	}catch (const BossSchedFailure & e) {
4061	+	PyErr_SetString ( SchedulerError, e.what() );
4062	+	return NULL;
4063	+	}catch (const std::exception& e) {
4064	+	PyErr_SetString ( BossError, e.what() );
4065	+	return NULL;
4066	+	}
4067	+	}
4068	+	{
4069	+	BossProgram * resultptr;
4070	+	resultptr = new BossProgram((BossProgram &) result);
4071	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4072	+	}
4073	+	return resultobj;
4074	+	fail:
4075	+	return NULL;
4076	+	}
4077	+
4078	+
4079	+	static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4080	+	PyObject *resultobj;
4081	+	BossTask *arg1 = (BossTask *) 0 ;
4082	+	BossJob *arg2 = (BossJob *) 0 ;
4083	+	std::string *arg3 = 0 ;
4084	+	BossProgramExec result;
4085	+	std::string temp3 ;
4086	+	PyObject * obj0 = 0 ;
4087	+	PyObject * obj1 = 0 ;
4088	+	PyObject * obj2 = 0 ;
4089	+
4090	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4091	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4092	+	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4093	+	{
4094	+	if (PyString_Check(obj2)) {
4095	+	temp3 = std::string(PyString_AsString(obj2));
4096	+	arg3 = &temp3;
4097	+	}else {
4098	+	SWIG_exception(SWIG_TypeError, "string expected");
4099	+	}
4100	+	}
4101	+	{
4102	+	try {
4103	+	result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4104	+
4105	+	}catch (const BossSchedFailure & e) {
4106	+	PyErr_SetString ( SchedulerError, e.what() );
4107	+	return NULL;
4108	+	}catch (const std::exception& e) {
4109	+	PyErr_SetString ( BossError, e.what() );
4110	+	return NULL;
4111	+	}
4112	+	}
4113	+	{
4114	+	BossProgramExec * resultptr;
4115	+	resultptr = new BossProgramExec((BossProgramExec &) result);
4116	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4117	+	}
4118	+	return resultobj;
4119	+	fail:
4120	+	return NULL;
4121	+	}
4122	+
4123	+
4124		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
4125		PyObject *resultobj;
4126		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 4050 | Line 4405 | static PyObject *_wrap_BossTask_taskMap(
4405		}
4406
4407
4053	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4054	–	PyObject *resultobj;
4055	–	BossTask *arg1 = (BossTask *) 0 ;
4056	–	BossTask::job_iterator result;
4057	–	PyObject * obj0 = 0 ;
4058	–
4059	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4060	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4061	–	{
4062	–	try {
4063	–	result = ((BossTask const *)arg1)->job_begin();
4064	–
4065	–	}catch (const BossSchedFailure & e) {
4066	–	PyErr_SetString ( SchedulerError, e.what() );
4067	–	return NULL;
4068	–	}catch (const std::exception& e) {
4069	–	PyErr_SetString ( BossError, e.what() );
4070	–	return NULL;
4071	–	}
4072	–	}
4073	–	{
4074	–	BossTask::job_iterator * resultptr;
4075	–	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4076	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4077	–	}
4078	–	return resultobj;
4079	–	fail:
4080	–	return NULL;
4081	–	}
4082	–
4083	–
4084	–	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4085	–	PyObject *resultobj;
4086	–	BossTask *arg1 = (BossTask *) 0 ;
4087	–	BossTask::job_iterator result;
4088	–	PyObject * obj0 = 0 ;
4089	–
4090	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4091	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4092	–	{
4093	–	try {
4094	–	result = ((BossTask const *)arg1)->job_end();
4095	–
4096	–	}catch (const BossSchedFailure & e) {
4097	–	PyErr_SetString ( SchedulerError, e.what() );
4098	–	return NULL;
4099	–	}catch (const std::exception& e) {
4100	–	PyErr_SetString ( BossError, e.what() );
4101	–	return NULL;
4102	–	}
4103	–	}
4104	–	{
4105	–	BossTask::job_iterator * resultptr;
4106	–	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4107	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4108	–	}
4109	–	return resultobj;
4110	–	fail:
4111	–	return NULL;
4112	–	}
4113	–
4114	–
4408		static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4409		PyObject *resultobj;
4410		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4327 | Line 4620 | static PyObject *_wrap_BossTask_programs
4620		}
4621
4622
4330	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4331	–	PyObject *resultobj;
4332	–	BossTask *arg1 = (BossTask *) 0 ;
4333	–	BossJob *arg2 = (BossJob *) 0 ;
4334	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4335	–	PyObject * obj0 = 0 ;
4336	–	PyObject * obj1 = 0 ;
4337	–
4338	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4339	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4340	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4341	–	{
4342	–	try {
4343	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4344	–
4345	–	}catch (const BossSchedFailure & e) {
4346	–	PyErr_SetString ( SchedulerError, e.what() );
4347	–	return NULL;
4348	–	}catch (const std::exception& e) {
4349	–	PyErr_SetString ( BossError, e.what() );
4350	–	return NULL;
4351	–	}
4352	–	}
4353	–	{
4354	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4355	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4356	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4357	–	}
4358	–	return resultobj;
4359	–	fail:
4360	–	return NULL;
4361	–	}
4362	–
4363	–
4623		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4624		PyObject *resultobj;
4625		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4611 | Line 4870 | static PyObject *_wrap_BossTask_submit(P
4870		std::string *arg5 = (std::string *) &arg5_defvalue ;
4871		std::string const &arg6_defvalue = "" ;
4872		std::string *arg6 = (std::string *) &arg6_defvalue ;
4873	<	bool arg7 = (bool) false ;
4873	>	unsigned int arg7 = (unsigned int) 0 ;
4874	>	bool arg8 = (bool) false ;
4875		int result;
4876		std::string temp2 ;
4877		std::string temp3 ;
#	Line 4625 | Line 4885 | static PyObject *_wrap_BossTask_submit(P
4885		PyObject * obj4 = 0 ;
4886		PyObject * obj5 = 0 ;
4887		PyObject * obj6 = 0 ;
4888	+	PyObject * obj7 = 0 ;
4889
4890	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4890	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4891		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4892		if (obj1) {
4893		{
#	Line 4679 | Line 4940 | static PyObject *_wrap_BossTask_submit(P
4940		}
4941		}
4942		if (obj6) {
4943	<	arg7 = PyInt_AsLong(obj6) ? true : false;
4943	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4944	>	if (PyErr_Occurred()) SWIG_fail;
4945	>	}
4946	>	if (obj7) {
4947	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4948		if (PyErr_Occurred()) SWIG_fail;
4949		}
4950		{
4951		try {
4952	<	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
4952	>	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7,arg8);
4953
4954		}catch (const BossSchedFailure & e) {
4955		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4749 | Line 5014 | static PyObject *_wrap_BossTask_kill(PyO
5014		PyObject *resultobj;
5015		BossTask *arg1 = (BossTask *) 0 ;
5016		std::string *arg2 = 0 ;
5017	<	bool arg3 = (bool) false ;
5017	>	unsigned int arg3 = (unsigned int) 0 ;
5018	>	bool arg4 = (bool) false ;
5019		int result;
5020		std::string temp2 ;
5021		PyObject * obj0 = 0 ;
5022		PyObject * obj1 = 0 ;
5023		PyObject * obj2 = 0 ;
5024	+	PyObject * obj3 = 0 ;
5025
5026	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
5026	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
5027		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5028		{
5029		if (PyString_Check(obj1)) {
#	Line 4767 | Line 5034 | static PyObject *_wrap_BossTask_kill(PyO
5034		}
5035		}
5036		if (obj2) {
5037	<	arg3 = PyInt_AsLong(obj2) ? true : false;
5037	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
5038	>	if (PyErr_Occurred()) SWIG_fail;
5039	>	}
5040	>	if (obj3) {
5041	>	arg4 = PyInt_AsLong(obj3) ? true : false;
5042		if (PyErr_Occurred()) SWIG_fail;
5043		}
5044		{
5045		try {
5046	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
5046	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
5047
5048		}catch (const BossSchedFailure & e) {
5049		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4796 | Line 5067 | static PyObject *_wrap_BossTask_getOutpu
5067		std::string *arg2 = (std::string *) &arg2_defvalue ;
5068		std::string const &arg3_defvalue = "" ;
5069		std::string *arg3 = (std::string *) &arg3_defvalue ;
5070	<	bool arg4 = (bool) false ;
5070	>	unsigned int arg4 = (unsigned int) 0 ;
5071		bool arg5 = (bool) false ;
5072	+	bool arg6 = (bool) false ;
5073		int result;
5074		std::string temp2 ;
5075		std::string temp3 ;
#	Line 4806 | Line 5078 | static PyObject *_wrap_BossTask_getOutpu
5078		PyObject * obj2 = 0 ;
5079		PyObject * obj3 = 0 ;
5080		PyObject * obj4 = 0 ;
5081	+	PyObject * obj5 = 0 ;
5082
5083	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5083	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5084		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5085		if (obj1) {
5086		{
#	Line 4830 | Line 5103 | static PyObject *_wrap_BossTask_getOutpu
5103		}
5104		}
5105		if (obj3) {
5106	<	arg4 = PyInt_AsLong(obj3) ? true : false;
5106	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
5107		if (PyErr_Occurred()) SWIG_fail;
5108		}
5109		if (obj4) {
5110		arg5 = PyInt_AsLong(obj4) ? true : false;
5111		if (PyErr_Occurred()) SWIG_fail;
5112		}
5113	+	if (obj5) {
5114	+	arg6 = PyInt_AsLong(obj5) ? true : false;
5115	+	if (PyErr_Occurred()) SWIG_fail;
5116	+	}
5117		{
5118		try {
5119	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
5119	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
5120	>
5121	>	}catch (const BossSchedFailure & e) {
5122	>	PyErr_SetString ( SchedulerError, e.what() );
5123	>	return NULL;
5124	>	}catch (const std::exception& e) {
5125	>	PyErr_SetString ( BossError, e.what() );
5126	>	return NULL;
5127	>	}
5128	>	}
5129	>	resultobj = PyInt_FromLong((long)result);
5130	>	return resultobj;
5131	>	fail:
5132	>	return NULL;
5133	>	}
5134	>
5135	>
5136	>	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
5137	>	PyObject *resultobj;
5138	>	BossTask *arg1 = (BossTask *) 0 ;
5139	>	std::string *arg2 = 0 ;
5140	>	int result;
5141	>	std::string temp2 ;
5142	>	PyObject * obj0 = 0 ;
5143	>	PyObject * obj1 = 0 ;
5144	>
5145	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5146	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5147	>	{
5148	>	if (PyString_Check(obj1)) {
5149	>	temp2 = std::string(PyString_AsString(obj1));
5150	>	arg2 = &temp2;
5151	>	}else {
5152	>	SWIG_exception(SWIG_TypeError, "string expected");
5153	>	}
5154	>	}
5155	>	{
5156	>	try {
5157	>	result = (int)(arg1)->loadByName((std::string const &)*arg2);
5158
5159		}catch (const BossSchedFailure & e) {
5160		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4964 | Line 5279 | static PyObject *_wrap_BossTask_query(Py
5279		std::string arg6 = (std::string) "" ;
5280		std::string arg7 = (std::string) "" ;
5281		std::string arg8 = (std::string) "" ;
5282	<	bool arg9 = (bool) false ;
5282	>	unsigned int arg9 = (unsigned int) 0 ;
5283	>	bool arg10 = (bool) false ;
5284		int result;
5285		std::string temp3 ;
5286		std::string temp4 ;
#	Line 4976 | Line 5292 | static PyObject *_wrap_BossTask_query(Py
5292		PyObject * obj6 = 0 ;
5293		PyObject * obj7 = 0 ;
5294		PyObject * obj8 = 0 ;
5295	+	PyObject * obj9 = 0 ;
5296
5297	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5297	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5298		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5299		if (obj2) {
5300		{
#	Line 5032 | Line 5349 | static PyObject *_wrap_BossTask_query(Py
5349		}
5350		}
5351		if (obj8) {
5352	<	arg9 = PyInt_AsLong(obj8) ? true : false;
5352	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5353	>	if (PyErr_Occurred()) SWIG_fail;
5354	>	}
5355	>	if (obj9) {
5356	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5357		if (PyErr_Occurred()) SWIG_fail;
5358		}
5359		{
5360		try {
5361	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5361	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5362
5363		}catch (const BossSchedFailure & e) {
5364		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5148 | Line 5469 | static PyObject *_wrap_BossTask_appendTo
5469		BossTask *arg1 = (BossTask *) 0 ;
5470		PyObject *arg2 = (PyObject *) 0 ;
5471		BossAttributeContainer *arg3 = 0 ;
5151	–	PyObject *result;
5472		PyObject * obj0 = 0 ;
5473		PyObject * obj1 = 0 ;
5474		PyObject * obj2 = 0 ;
#	Line 5162 | Line 5482 | static PyObject *_wrap_BossTask_appendTo
5482		}
5483		{
5484		try {
5485	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5485	>	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5486
5487		}catch (const BossSchedFailure & e) {
5488		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5172 | Line 5492 | static PyObject *_wrap_BossTask_appendTo
5492		return NULL;
5493		}
5494		}
5495	<	resultobj = result;
5495	>	Py_INCREF(Py_None); resultobj = Py_None;
5496		return resultobj;
5497		fail:
5498		return NULL;
#	Line 5182 | Line 5502 | static PyObject *_wrap_BossTask_appendTo
5502		static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5503		PyObject *resultobj;
5504		BossTask *arg1 = (BossTask *) 0 ;
5505	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5506	<	PyObject *result;
5505	>	BossJob *arg2 = (BossJob *) 0 ;
5506	>	PyObject *arg3 = (PyObject *) 0 ;
5507		PyObject * obj0 = 0 ;
5508		PyObject * obj1 = 0 ;
5509	+	PyObject * obj2 = 0 ;
5510
5511	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5511	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5512		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5513	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5514	<	if (arg2 == NULL) {
5194	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5195	<	}
5513	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5514	>	arg3 = obj2;
5515		{
5516		try {
5517	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5517	>	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5518
5519		}catch (const BossSchedFailure & e) {
5520		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5205 | Line 5524 | static PyObject *_wrap_BossTask_jobDict(
5524		return NULL;
5525		}
5526		}
5527	<	resultobj = result;
5527	>	Py_INCREF(Py_None); resultobj = Py_None;
5528		return resultobj;
5529		fail:
5530		return NULL;
#	Line 5239 | Line 5558 | static PyObject *_wrap_BossTask_jobsDict
5558		}
5559
5560
5561	+	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5562	+	PyObject *resultobj;
5563	+	BossTask *arg1 = (BossTask *) 0 ;
5564	+	std::string *arg2 = 0 ;
5565	+	PyObject *result;
5566	+	std::string temp2 ;
5567	+	PyObject * obj0 = 0 ;
5568	+	PyObject * obj1 = 0 ;
5569	+
5570	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5571	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5572	+	{
5573	+	if (PyString_Check(obj1)) {
5574	+	temp2 = std::string(PyString_AsString(obj1));
5575	+	arg2 = &temp2;
5576	+	}else {
5577	+	SWIG_exception(SWIG_TypeError, "string expected");
5578	+	}
5579	+	}
5580	+	{
5581	+	try {
5582	+	result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5583	+
5584	+	}catch (const BossSchedFailure & e) {
5585	+	PyErr_SetString ( SchedulerError, e.what() );
5586	+	return NULL;
5587	+	}catch (const std::exception& e) {
5588	+	PyErr_SetString ( BossError, e.what() );
5589	+	return NULL;
5590	+	}
5591	+	}
5592	+	resultobj = result;
5593	+	return resultobj;
5594	+	fail:
5595	+	return NULL;
5596	+	}
5597	+
5598	+
5599	+	static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5600	+	PyObject *resultobj;
5601	+	BossTask *arg1 = (BossTask *) 0 ;
5602	+	PyObject *result;
5603	+	PyObject * obj0 = 0 ;
5604	+
5605	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5606	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5607	+	{
5608	+	try {
5609	+	result = (PyObject *)BossTask_jobStates(arg1);
5610	+
5611	+	}catch (const BossSchedFailure & e) {
5612	+	PyErr_SetString ( SchedulerError, e.what() );
5613	+	return NULL;
5614	+	}catch (const std::exception& e) {
5615	+	PyErr_SetString ( BossError, e.what() );
5616	+	return NULL;
5617	+	}
5618	+	}
5619	+	resultobj = result;
5620	+	return resultobj;
5621	+	fail:
5622	+	return NULL;
5623	+	}
5624	+
5625	+
5626	+	static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5627	+	PyObject *resultobj;
5628	+	BossTask *arg1 = (BossTask *) 0 ;
5629	+	PyObject *result;
5630	+	PyObject * obj0 = 0 ;
5631	+
5632	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5633	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5634	+	{
5635	+	try {
5636	+	result = (PyObject *)BossTask_jobStatistic(arg1);
5637	+
5638	+	}catch (const BossSchedFailure & e) {
5639	+	PyErr_SetString ( SchedulerError, e.what() );
5640	+	return NULL;
5641	+	}catch (const std::exception& e) {
5642	+	PyErr_SetString ( BossError, e.what() );
5643	+	return NULL;
5644	+	}
5645	+	}
5646	+	resultobj = result;
5647	+	return resultobj;
5648	+	fail:
5649	+	return NULL;
5650	+	}
5651	+
5652	+
5653		static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5654		PyObject *resultobj;
5655		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5310 | Line 5721 | static PyObject *_wrap_BossTask_jobProgr
5721		}
5722
5723
5724	+	static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5725	+	PyObject *resultobj;
5726	+	BossTask *arg1 = (BossTask *) 0 ;
5727	+	std::string *arg2 = 0 ;
5728	+	std::string *arg3 = 0 ;
5729	+	PyObject *result;
5730	+	std::string temp2 ;
5731	+	std::string temp3 ;
5732	+	PyObject * obj0 = 0 ;
5733	+	PyObject * obj1 = 0 ;
5734	+	PyObject * obj2 = 0 ;
5735	+
5736	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5737	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5738	+	{
5739	+	if (PyString_Check(obj1)) {
5740	+	temp2 = std::string(PyString_AsString(obj1));
5741	+	arg2 = &temp2;
5742	+	}else {
5743	+	SWIG_exception(SWIG_TypeError, "string expected");
5744	+	}
5745	+	}
5746	+	{
5747	+	if (PyString_Check(obj2)) {
5748	+	temp3 = std::string(PyString_AsString(obj2));
5749	+	arg3 = &temp3;
5750	+	}else {
5751	+	SWIG_exception(SWIG_TypeError, "string expected");
5752	+	}
5753	+	}
5754	+	{
5755	+	try {
5756	+	result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
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_programExec(PyObject *self, PyObject *args) {
5774	+	PyObject *resultobj;
5775	+	BossTask *arg1 = (BossTask *) 0 ;
5776	+	std::string *arg2 = 0 ;
5777	+	std::string *arg3 = 0 ;
5778	+	PyObject *result;
5779	+	std::string temp2 ;
5780	+	std::string temp3 ;
5781	+	PyObject * obj0 = 0 ;
5782	+	PyObject * obj1 = 0 ;
5783	+	PyObject * obj2 = 0 ;
5784	+
5785	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
5786	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5787	+	{
5788	+	if (PyString_Check(obj1)) {
5789	+	temp2 = std::string(PyString_AsString(obj1));
5790	+	arg2 = &temp2;
5791	+	}else {
5792	+	SWIG_exception(SWIG_TypeError, "string expected");
5793	+	}
5794	+	}
5795	+	{
5796	+	if (PyString_Check(obj2)) {
5797	+	temp3 = std::string(PyString_AsString(obj2));
5798	+	arg3 = &temp3;
5799	+	}else {
5800	+	SWIG_exception(SWIG_TypeError, "string expected");
5801	+	}
5802	+	}
5803	+	{
5804	+	try {
5805	+	result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5806	+
5807	+	}catch (const BossSchedFailure & e) {
5808	+	PyErr_SetString ( SchedulerError, e.what() );
5809	+	return NULL;
5810	+	}catch (const std::exception& e) {
5811	+	PyErr_SetString ( BossError, e.what() );
5812	+	return NULL;
5813	+	}
5814	+	}
5815	+	resultobj = result;
5816	+	return resultobj;
5817	+	fail:
5818	+	return NULL;
5819	+	}
5820	+
5821	+
5822	+	static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
5823	+	PyObject *resultobj;
5824	+	BossTask *arg1 = (BossTask *) 0 ;
5825	+	std::string *arg2 = 0 ;
5826	+	std::string *arg3 = 0 ;
5827	+	PyObject *result;
5828	+	std::string temp2 ;
5829	+	std::string temp3 ;
5830	+	PyObject * obj0 = 0 ;
5831	+	PyObject * obj1 = 0 ;
5832	+	PyObject * obj2 = 0 ;
5833	+
5834	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
5835	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5836	+	{
5837	+	if (PyString_Check(obj1)) {
5838	+	temp2 = std::string(PyString_AsString(obj1));
5839	+	arg2 = &temp2;
5840	+	}else {
5841	+	SWIG_exception(SWIG_TypeError, "string expected");
5842	+	}
5843	+	}
5844	+	{
5845	+	if (PyString_Check(obj2)) {
5846	+	temp3 = std::string(PyString_AsString(obj2));
5847	+	arg3 = &temp3;
5848	+	}else {
5849	+	SWIG_exception(SWIG_TypeError, "string expected");
5850	+	}
5851	+	}
5852	+	{
5853	+	try {
5854	+	result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5855	+
5856	+	}catch (const BossSchedFailure & e) {
5857	+	PyErr_SetString ( SchedulerError, e.what() );
5858	+	return NULL;
5859	+	}catch (const std::exception& e) {
5860	+	PyErr_SetString ( BossError, e.what() );
5861	+	return NULL;
5862	+	}
5863	+	}
5864	+	resultobj = result;
5865	+	return resultobj;
5866	+	fail:
5867	+	return NULL;
5868	+	}
5869	+
5870	+
5871		static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5872		PyObject *obj;
5873		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 6289 | Line 6847 | static PyMethodDef SwigMethods[] = {
6847		{ (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 },
6851		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6852	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
6853		{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6854		{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6855		{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
#	Line 6304 | Line 6864 | static PyMethodDef SwigMethods[] = {
6864		{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6865		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6866		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
6867	+	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6868	+	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6869	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6870	+	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
6871	+	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
6872		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6873		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6874		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
6875		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
6876		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6312	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6313	–	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6877		{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
6878		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6879		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6317	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6880		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
6881		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
6882		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
#	Line 6322 | Line 6884 | static PyMethodDef SwigMethods[] = {
6884		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6885		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6886		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6887	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
6888		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6889		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6890		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
#	Line 6329 | Line 6892 | static PyMethodDef SwigMethods[] = {
6892		{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6893		{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6894		{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6895	+	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
6896	+	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
6897	+	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
6898		{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6899		{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6900	+	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
6901	+	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
6902	+	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
6903		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6904		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6905		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 6355 | Line 6924 | static PyMethodDef SwigMethods[] = {
6924
6925		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6926
6358	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6927		static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t", 0, "std::vector<std::pair<BossProgram,BossProgramExec > > *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t"},{0}};
6928	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6929		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}};
6930	+	static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
6931		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}};
6932		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}};
6363	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6933		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6934		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
6935	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6936	+	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
6937		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6938		static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6939		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
#	Line 6376 | Line 6947 | static swig_type_info _swigt__p_BossTask
6947		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6948
6949		static swig_type_info *swig_types_initial[] = {
6379	–	_swigt__p_XMLDoc,
6950		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6951	+	_swigt__p_XMLDoc,
6952		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6953	+	_swigt__p_BossProgramExec,
6954		_swigt__p_std__vectorTBossTask_p_t,
6955		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6384	–	_swigt__p_std__ostream,
6956		_swigt__p_BossTask,
6957		_swigt__p_BossTaskException,
6958	+	_swigt__p_std__ostream,
6959	+	_swigt__p_BossProgram,
6960		_swigt__p_printOption,
6961		_swigt__p_BossAttributeContainer,
6962		_swigt__p_BossJob,
#	Line 6440 | Line 7013 | SWIGEXPORT(void) SWIG_init(void) {
7013
7014		// define custom exceptions
7015		PyObject *e;
7016	<	e = Py_InitModule("BossSession", NULL);
7016	>	PyMethodDef tp_methods = {
7017	>	NULL, NULL, 0, NULL
7018	>	};
7019	>	e = Py_InitModule("BossSession", &tp_methods);
7020		// generic BOSS exception
7021		BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
7022		Py_INCREF(BossError);

Diff Legend

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