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.24 by gcodispo, Fri Mar 2 14:13:39 2007 UTC vs.
Revision 1.33 by gcodispo, Fri Jun 8 15:49:19 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]
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];
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]
677	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[20]
678	>	#define  SWIGTYPE_p_jobStates swig_types[21]
679	>	static swig_type_info *swig_types[23];
680
681		/* -------- TYPES TABLE (END) -------- */
682
#	Line 923 | Line 926 | static PyObject * SchedulerError;
926		#include "BossAdministratorSession.h"
927		#include "BossTask.h"
928		#include "BossJob.h"
929	+	#include "BossChain.h"
930		#include "BossTaskCore.h"
931		#include "BossAttributeContainer.h"
932		#include "BossDBObject.h"
#	Line 957 | Line 961 | PyObject *BossSession_schedulers(BossSes
961		std::vector<std::string> my_vec = self->showSchedulers();
962		return BossSession_show( self, my_vec );
963		}
964	<	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout,bool keepfile){
964	>	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,unsigned int timeout){
965		std::vector<std::string> my_vec = self->listMatch( scheduler,
966		schclassad,
963	–	keepfile,
967		taskid,
968		jobid,
969		timeout);
970		return BossSession_show( self, my_vec );
971		}
972	<	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,unsigned int timeout,bool avoidCheck){
973	<	if ( !avoidCheck ) {
974	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
975	<	type, user, after, before, timeout );
976	<	}
977	<	PyObject * job_dict = PyList_New(0);
978	<	std::vector <std::string>
976	<	taskList = self->selectTasks( taskRange, before, after, user);
977	<	for ( std::vector <std::string>::const_iterator it= taskList.begin();
978	<	it!= taskList.end(); ++it ) {
979	<	PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
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	<	return  job_dict;
981	<	}
982	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
984	<	std::string tmp;
985	<	BossAttributeContainer::const_iterator it_end = obj.end ();
986	<	for (BossAttributeContainer::const_iterator it = obj.begin ();
987	<	it != it_end; ++it) {
988	<	// New code semantically isomorphic to the old one //Fabio
989	<	tmp = (*it).first.name ();
990	<	unsigned int size = tmp.size() +1;
991	<	char * key = new char[ size ];
992	<	strncpy( key, tmp.c_str(), size );
993	<	tmp = (*it).second.value ();
994	<	PyObject * val = PyString_FromString( tmp.c_str() );
995	<	PyDict_SetItemString( dict, key, val );
996	<	delete [] key;
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 dict;
984	>	return  task_list;
985		}
986	<	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
986	>	void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
987	>	std::string tmp;
988	>	BossAttributeContainer::const_iterator it_end = obj.end ();
989	>	for (BossAttributeContainer::const_iterator it = obj.begin ();
990	>	it != it_end; ++it) {
991	>
992	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
993	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
994	>	PyDict_SetItem( dict, key, val);
995	>	Py_DECREF(key);
996	>	Py_DECREF(val);
997	>	}
998	>	return;
999	>	}
1000	>	void BossTask_jobDict(BossTask const *self,BossJob const *jobH,PyObject *job_dict){
1001
1002	<	PyObject * job_dict = PyDict_New();
1002	>	//    PyObject * job_dict = PyDict_New();
1003		std::string tmp;
1004
1005	<	BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1006	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1005	>	BossAttributeContainer obj = jobH->getTableEntries("JOB");
1006	>	BossTask_appendToPyDict ( self, job_dict, obj );
1007
1008	<	std::set<std::string> sch = (*jit)->getSchedulerElements();
1008	>	std::set<std::string> sch = jobH->getSchedulerElements();
1009		std::set<std::string>::const_iterator sch_end =  sch.end();
1010		for (std::set<std::string>::const_iterator it =sch.begin();
1011		it != sch_end; ++ it ) {
1012	<	unsigned int size = it->size() +1;
1013	<	char * key = new char[ size ];
1014	<	strncpy( key, tmp.c_str(), size );
1015	<	tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1016	<	PyDict_SetItemString( job_dict, key,
1017	<	PyString_FromString( tmp.c_str() ) );
1018	<	delete [] key;
1012	>
1013	>	tmp = (*jobH)["JOB_SCHED_INFO."+(*it)];
1014	>	PyObject * key = PyString_FromString( it->c_str() );
1015	>	PyObject * val = PyString_FromString( tmp.c_str() );
1016	>	PyDict_SetItem( job_dict, key, val);
1017	>	Py_DECREF(key);
1018	>	Py_DECREF(val);
1019		}
1020	<	return job_dict;
1020	>	return;
1021		}
1022		PyObject *BossTask_jobsDict(BossTask *self){
1023
#	Line 1025 | Line 1025 | PyObject *BossTask_jobsDict(BossTask *se
1025		if ( self->job_begin () == self->job_end ()) self->load(ALL);
1026		for (BossTask::job_iterator jit = self->job_begin ();
1027		jit != self->job_end (); ++jit) {
1028	<	std::string id = (*jit)->chainId();
1029	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1030	<	PyObject * myid =  PyString_FromString(id.c_str() );
1031	<	PyDict_SetItem( job_dict, myid,tmp );
1028	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1029	>	PyObject * tmp_dict = PyDict_New();
1030	>	BossTask_jobDict( self, *jit, tmp_dict );
1031	>	PyDict_SetItem( job_dict, id, tmp_dict );
1032	>	Py_DECREF(id);
1033	>	Py_DECREF(tmp_dict);
1034	>	}
1035	>	return job_dict;
1036	>	}
1037	>	PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1038	>
1039	>	PyObject * job_dict = PyDict_New();
1040	>	self->load( ALL, jobid );
1041	>	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1042	>	return job_dict;
1043	>	}
1044	>	PyObject *BossTask_Chain(BossTask *self,std::string const &jobid){
1045	>
1046	>	PyObject * chain_dict = PyDict_New();
1047	>	BossAttributeContainer obj =
1048	>	self->chain( jobid ).getTableEntries("CHAIN");
1049	>	BossTask_appendToPyDict ( self, chain_dict, obj );
1050	>	return chain_dict;
1051	>	}
1052	>	PyObject *BossTask_jobStates(BossTask *self){
1053	>
1054	>	PyObject * job_dict = PyDict_New();
1055	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1056	>	for (BossTask::job_iterator jit = self->job_begin ();
1057	>	jit != self->job_end (); ++jit) {
1058	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1059	>	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1060	>	PyDict_SetItem( job_dict, id, status );
1061	>	Py_DECREF(id);
1062	>	Py_DECREF(status);
1063	>	}
1064	>	return job_dict;
1065	>	}
1066	>	PyObject *BossTask_jobStatistic(BossTask *self){
1067	>
1068	>	PyObject * job_dict = PyDict_New();
1069	>	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1070	>	std::map< std::string, int > states;
1071	>	for (BossTask::job_iterator jit = self->job_begin ();
1072	>	jit != self->job_end (); ++jit) {
1073	>	++states[(**jit)["JOB.STATUS"]];
1074	>	}
1075	>
1076	>	std::map< std::string, int >::const_iterator end = states.end ();
1077	>	for (std::map< std::string, int >::const_iterator it = states.begin ();
1078	>	it != end; ++it) {
1079	>	PyObject * status = PyString_FromString( (it->first).c_str() );
1080	>	PyObject * jobs = PyString_FromFormat( "%d", it->second );
1081	>	PyDict_SetItem( job_dict, status, jobs );
1082	>	Py_DECREF(jobs);
1083	>	Py_DECREF(status);
1084		}
1085		return job_dict;
1086		}
#	Line 1073 | Line 1125 | PyObject *BossTask_jobPrograms(BossTask
1125		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1126		++programs_it  ) {
1127		std::string id = (programs_it->first)["PROGRAM.ID"];
1128	<	PyObject * tmp =  BossTask_progDict( self, programs_it );
1128	>	PyObject * tmp_dict =  BossTask_progDict( self, programs_it );
1129		PyObject * myid =  PyString_FromString(id.c_str() );
1130	<	PyDict_SetItem( job_dict, myid,tmp );
1130	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1131	>	Py_DECREF(myid);
1132	>	Py_DECREF(tmp_dict);
1133	>	}
1134	>	return job_dict;
1135	>	}
1136	>	PyObject *BossTask_program(BossTask *self,std::string const &jobid,std::string const &programId){
1137	>
1138	>	PyObject * job_dict = PyDict_New();
1139	>
1140	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1141	>	BossAttributeContainer obj =
1142	>	self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1143	>	BossTask_appendToPyDict ( self, job_dict, obj );
1144	>	return job_dict;
1145	>	}
1146	>	PyObject *BossTask_programExec(BossTask *self,std::string const &jobid,std::string const &programId){
1147	>
1148	>	PyObject * job_dict = PyDict_New();
1149	>
1150	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1151	>
1152	>	// PROGRAM_EXEC
1153	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1154	>	BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1155	>	BossTask_appendToPyDict ( self, job_dict, obj );
1156	>
1157	>	// SPECIFICS
1158	>	std::vector < BossAttributeContainer >::const_iterator it;
1159	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1160	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1161	>	BossTask_appendToPyDict ( self, job_dict, *it );
1162	>	}
1163	>	return job_dict;
1164	>	}
1165	>	PyObject *BossTask_specific(BossTask *self,std::string const &jobid,std::string const &programId){
1166	>
1167	>	PyObject * job_dict = PyDict_New();
1168	>
1169	>	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1170	>	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1171	>	BossAttributeContainer obj = programExec.getKeys ();
1172	>	BossTask_appendToPyDict ( self, job_dict, obj );
1173	>
1174	>	std::vector < BossAttributeContainer >::const_iterator it;
1175	>	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1176	>	for ( it = programExec.specBegin (); it != it_end; ++it) {
1177	>	BossTask_appendToPyDict ( self, job_dict, *it );
1178		}
1179		return job_dict;
1180		}
#	Line 2897 | Line 2996 | static PyObject *_wrap_BossSession_listM
2996		BossSession *arg1 = (BossSession *) 0 ;
2997		std::string *arg2 = 0 ;
2998		std::string *arg3 = 0 ;
2999	<	bool arg4 = (bool) false ;
2999	>	std::string const &arg4_defvalue = "" ;
3000	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3001		std::string const &arg5_defvalue = "" ;
3002		std::string *arg5 = (std::string *) &arg5_defvalue ;
3003	<	std::string const &arg6_defvalue = "" ;
2904	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
2905	<	unsigned int arg7 = (unsigned int) 0 ;
3003	>	unsigned int arg6 = (unsigned int) 0 ;
3004		std::vector<std::string > result;
3005		std::string temp2 ;
3006		std::string temp3 ;
3007	+	std::string temp4 ;
3008		std::string temp5 ;
2910	–	std::string temp6 ;
3009		PyObject * obj0 = 0 ;
3010		PyObject * obj1 = 0 ;
3011		PyObject * obj2 = 0 ;
3012		PyObject * obj3 = 0 ;
3013		PyObject * obj4 = 0 ;
3014		PyObject * obj5 = 0 ;
2917	–	PyObject * obj6 = 0 ;
3015
3016	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3016	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3017		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3018		{
3019		if (PyString_Check(obj1)) {
#	Line 2935 | Line 3032 | static PyObject *_wrap_BossSession_listM
3032		}
3033		}
3034		if (obj3) {
2938	–	arg4 = PyInt_AsLong(obj3) ? true : false;
2939	–	if (PyErr_Occurred()) SWIG_fail;
2940	–	}
2941	–	if (obj4) {
3035		{
3036	<	if (PyString_Check(obj4)) {
3037	<	temp5 = std::string(PyString_AsString(obj4));
3038	<	arg5 = &temp5;
3036	>	if (PyString_Check(obj3)) {
3037	>	temp4 = std::string(PyString_AsString(obj3));
3038	>	arg4 = &temp4;
3039		}else {
3040		SWIG_exception(SWIG_TypeError, "string expected");
3041		}
3042		}
3043		}
3044	<	if (obj5) {
3044	>	if (obj4) {
3045		{
3046	<	if (PyString_Check(obj5)) {
3047	<	temp6 = std::string(PyString_AsString(obj5));
3048	<	arg6 = &temp6;
3046	>	if (PyString_Check(obj4)) {
3047	>	temp5 = std::string(PyString_AsString(obj4));
3048	>	arg5 = &temp5;
3049		}else {
3050		SWIG_exception(SWIG_TypeError, "string expected");
3051		}
3052		}
3053		}
3054	<	if (obj6) {
3055	<	arg7 = (unsigned int) PyInt_AsLong(obj6);
3054	>	if (obj5) {
3055	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3056		if (PyErr_Occurred()) SWIG_fail;
3057		}
3058		{
3059		try {
3060	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
3060	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3061
3062		}catch (const BossSchedFailure & e) {
3063		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3189 | Line 3282 | static PyObject *_wrap_BossSession_selec
3282		}
3283
3284
3285	+	static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
3286	+	PyObject *resultobj;
3287	+	BossSession *arg1 = (BossSession *) 0 ;
3288	+	std::string *arg2 = 0 ;
3289	+	std::vector<std::string > result;
3290	+	std::string temp2 ;
3291	+	PyObject * obj0 = 0 ;
3292	+	PyObject * obj1 = 0 ;
3293	+
3294	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3295	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3296	+	{
3297	+	if (PyString_Check(obj1)) {
3298	+	temp2 = std::string(PyString_AsString(obj1));
3299	+	arg2 = &temp2;
3300	+	}else {
3301	+	SWIG_exception(SWIG_TypeError, "string expected");
3302	+	}
3303	+	}
3304	+	{
3305	+	try {
3306	+	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3307	+
3308	+	}catch (const BossSchedFailure & e) {
3309	+	PyErr_SetString ( SchedulerError, e.what() );
3310	+	return NULL;
3311	+	}catch (const std::exception& e) {
3312	+	PyErr_SetString ( BossError, e.what() );
3313	+	return NULL;
3314	+	}
3315	+	}
3316	+	{
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 ;
#	Line 3315 | Line 3451 | static PyObject *_wrap_BossSession_query
3451		}
3452
3453
3454	+	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3455	+	PyObject *resultobj;
3456	+	BossSession *arg1 = (BossSession *) 0 ;
3457	+	std::string *arg2 = 0 ;
3458	+	SwigValueWrapper< std::vector<BossTask * > > result;
3459	+	std::string temp2 ;
3460	+	PyObject * obj0 = 0 ;
3461	+	PyObject * obj1 = 0 ;
3462	+
3463	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3464	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3465	+	{
3466	+	if (PyString_Check(obj1)) {
3467	+	temp2 = std::string(PyString_AsString(obj1));
3468	+	arg2 = &temp2;
3469	+	}else {
3470	+	SWIG_exception(SWIG_TypeError, "string expected");
3471	+	}
3472	+	}
3473	+	{
3474	+	try {
3475	+	result = (arg1)->getTasksByName((std::string const &)*arg2);
3476	+
3477	+	}catch (const BossSchedFailure & e) {
3478	+	PyErr_SetString ( SchedulerError, e.what() );
3479	+	return NULL;
3480	+	}catch (const std::exception& e) {
3481	+	PyErr_SetString ( BossError, e.what() );
3482	+	return NULL;
3483	+	}
3484	+	}
3485	+	{
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	+	}
3490	+	return resultobj;
3491	+	fail:
3492	+	return NULL;
3493	+	}
3494	+
3495	+
3496	+	static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3497	+	PyObject *resultobj;
3498	+	BossSession *arg1 = (BossSession *) 0 ;
3499	+	std::string *arg2 = 0 ;
3500	+	SwigValueWrapper< std::vector<BossTask * > > result;
3501	+	std::string temp2 ;
3502	+	PyObject * obj0 = 0 ;
3503	+	PyObject * obj1 = 0 ;
3504	+
3505	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3506	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3507	+	{
3508	+	if (PyString_Check(obj1)) {
3509	+	temp2 = std::string(PyString_AsString(obj1));
3510	+	arg2 = &temp2;
3511	+	}else {
3512	+	SWIG_exception(SWIG_TypeError, "string expected");
3513	+	}
3514	+	}
3515	+	{
3516	+	try {
3517	+	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();
3549	+
3550	+	}catch (const BossSchedFailure & e) {
3551	+	PyErr_SetString ( SchedulerError, e.what() );
3552	+	return NULL;
3553	+	}catch (const std::exception& e) {
3554	+	PyErr_SetString ( BossError, e.what() );
3555	+	return NULL;
3556	+	}
3557	+	}
3558	+	resultobj = PyInt_FromLong((long)result);
3559	+	return resultobj;
3560	+	fail:
3561	+	return NULL;
3562	+	}
3563	+
3564	+
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	+
3596		static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3597		PyObject *resultobj;
3598		BossSession *arg1 = (BossSession *) 0 ;
#	Line 3466 | Line 3744 | static PyObject *_wrap_BossSession_sched
3744		std::string const &arg5_defvalue = "" ;
3745		std::string *arg5 = (std::string *) &arg5_defvalue ;
3746		unsigned int arg6 = (unsigned int) 0 ;
3469	–	bool arg7 = (bool) false ;
3747		PyObject *result;
3748		std::string temp2 ;
3749		std::string temp3 ;
#	Line 3478 | Line 3755 | static PyObject *_wrap_BossSession_sched
3755		PyObject * obj3 = 0 ;
3756		PyObject * obj4 = 0 ;
3757		PyObject * obj5 = 0 ;
3481	–	PyObject * obj6 = 0 ;
3758
3759	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3759	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3760		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3761		{
3762		if (PyString_Check(obj1)) {
#	Line 3522 | Line 3798 | static PyObject *_wrap_BossSession_sched
3798		arg6 = (unsigned int) PyInt_AsLong(obj5);
3799		if (PyErr_Occurred()) SWIG_fail;
3800		}
3525	–	if (obj6) {
3526	–	arg7 = PyInt_AsLong(obj6) ? true : false;
3527	–	if (PyErr_Occurred()) SWIG_fail;
3528	–	}
3801		{
3802		try {
3803	<	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3803	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3804
3805		}catch (const BossSchedFailure & e) {
3806		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3548 | Line 3820 | static PyObject *_wrap_BossSession_sched
3820		static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3821		PyObject *resultobj;
3822		BossSession *arg1 = (BossSession *) 0 ;
3823	<	int arg2 = (int) SCHEDULED ;
3823	>	std::string const &arg2_defvalue = "" ;
3824	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3825		std::string const &arg3_defvalue = "all" ;
3826		std::string *arg3 = (std::string *) &arg3_defvalue ;
3827	<	std::string const &arg4_defvalue = "all" ;
3828	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3556	<	std::string const &arg5_defvalue = "" ;
3557	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3827	>	std::string arg4 = (std::string) "" ;
3828	>	std::string arg5 = (std::string) "" ;
3829		std::string arg6 = (std::string) "" ;
3559	–	std::string arg7 = (std::string) "" ;
3560	–	std::string arg8 = (std::string) "" ;
3561	–	std::string arg9 = (std::string) "" ;
3562	–	unsigned int arg10 = (unsigned int) 0 ;
3563	–	bool arg11 = (bool) false ;
3830		PyObject *result;
3831	+	std::string temp2 ;
3832		std::string temp3 ;
3566	–	std::string temp4 ;
3567	–	std::string temp5 ;
3833		PyObject * obj0 = 0 ;
3834	+	PyObject * obj1 = 0 ;
3835		PyObject * obj2 = 0 ;
3836		PyObject * obj3 = 0 ;
3837		PyObject * obj4 = 0 ;
3838		PyObject * obj5 = 0 ;
3573	–	PyObject * obj6 = 0 ;
3574	–	PyObject * obj7 = 0 ;
3575	–	PyObject * obj8 = 0 ;
3576	–	PyObject * obj9 = 0 ;
3577	–	PyObject * obj10 = 0 ;
3839
3840	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3840	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3841		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3842	<	if (obj2) {
3582	<	{
3583	<	if (PyString_Check(obj2)) {
3584	<	temp3 = std::string(PyString_AsString(obj2));
3585	<	arg3 = &temp3;
3586	<	}else {
3587	<	SWIG_exception(SWIG_TypeError, "string expected");
3588	<	}
3589	<	}
3590	<	}
3591	<	if (obj3) {
3842	>	if (obj1) {
3843		{
3844	<	if (PyString_Check(obj3)) {
3845	<	temp4 = std::string(PyString_AsString(obj3));
3846	<	arg4 = &temp4;
3844	>	if (PyString_Check(obj1)) {
3845	>	temp2 = std::string(PyString_AsString(obj1));
3846	>	arg2 = &temp2;
3847		}else {
3848		SWIG_exception(SWIG_TypeError, "string expected");
3849		}
3850		}
3851		}
3852	<	if (obj4) {
3852	>	if (obj2) {
3853		{
3854	<	if (PyString_Check(obj4)) {
3855	<	temp5 = std::string(PyString_AsString(obj4));
3856	<	arg5 = &temp5;
3854	>	if (PyString_Check(obj2)) {
3855	>	temp3 = std::string(PyString_AsString(obj2));
3856	>	arg3 = &temp3;
3857		}else {
3858		SWIG_exception(SWIG_TypeError, "string expected");
3859		}
3860		}
3861		}
3862	<	if (obj5) {
3612	<	{
3613	<	if (PyString_Check(obj5))
3614	<	arg6 = std::string(PyString_AsString(obj5));
3615	<	else
3616	<	SWIG_exception(SWIG_TypeError, "string expected");
3617	<	}
3618	<	}
3619	<	if (obj6) {
3862	>	if (obj3) {
3863		{
3864	<	if (PyString_Check(obj6))
3865	<	arg7 = std::string(PyString_AsString(obj6));
3864	>	if (PyString_Check(obj3))
3865	>	arg4 = std::string(PyString_AsString(obj3));
3866		else
3867		SWIG_exception(SWIG_TypeError, "string expected");
3868		}
3869		}
3870	<	if (obj7) {
3870	>	if (obj4) {
3871		{
3872	<	if (PyString_Check(obj7))
3873	<	arg8 = std::string(PyString_AsString(obj7));
3872	>	if (PyString_Check(obj4))
3873	>	arg5 = std::string(PyString_AsString(obj4));
3874		else
3875		SWIG_exception(SWIG_TypeError, "string expected");
3876		}
3877		}
3878	<	if (obj8) {
3878	>	if (obj5) {
3879		{
3880	<	if (PyString_Check(obj8))
3881	<	arg9 = std::string(PyString_AsString(obj8));
3880	>	if (PyString_Check(obj5))
3881	>	arg6 = std::string(PyString_AsString(obj5));
3882		else
3883		SWIG_exception(SWIG_TypeError, "string expected");
3884		}
3885		}
3643	–	if (obj9) {
3644	–	arg10 = (unsigned int) PyInt_AsLong(obj9);
3645	–	if (PyErr_Occurred()) SWIG_fail;
3646	–	}
3647	–	if (obj10) {
3648	–	arg11 = PyInt_AsLong(obj10) ? true : false;
3649	–	if (PyErr_Occurred()) SWIG_fail;
3650	–	}
3886		{
3887		try {
3888	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3888	>	result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3889
3890		}catch (const BossSchedFailure & e) {
3891		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3674 | Line 3909 | static PyObject * BossSession_swigregist
3909		Py_INCREF(obj);
3910		return Py_BuildValue((char *)"");
3911		}
3912	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3912	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3913	>	PyObject *resultobj;
3914	>	char *arg1 ;
3915	>	BossTaskException *result;
3916	>
3917	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3918	>	{
3919	>	try {
3920	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3921	>
3922	>	}catch (const BossSchedFailure & e) {
3923	>	PyErr_SetString ( SchedulerError, e.what() );
3924	>	return NULL;
3925	>	}catch (const std::exception& e) {
3926	>	PyErr_SetString ( BossError, e.what() );
3927	>	return NULL;
3928	>	}
3929	>	}
3930	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3931	>	return resultobj;
3932	>	fail:
3933	>	return NULL;
3934	>	}
3935	>
3936	>
3937	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3938		PyObject *resultobj;
3939		BossTaskException *arg1 = (BossTaskException *) 0 ;
3680	–	char *arg2 ;
3940		PyObject * obj0 = 0 ;
3941
3942	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3942	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3943		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3944		{
3945	<	if (arg2) {
3946	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3947	<	strcpy((char *) arg1->key,arg2);
3948	<	}else {
3949	<	arg1->key = 0;
3945	>	try {
3946	>	delete arg1;
3947	>
3948	>	}catch (const BossSchedFailure & e) {
3949	>	PyErr_SetString ( SchedulerError, e.what() );
3950	>	return NULL;
3951	>	}catch (const std::exception& e) {
3952	>	PyErr_SetString ( BossError, e.what() );
3953	>	return NULL;
3954		}
3955		}
3956		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3697 | Line 3960 | static PyObject *_wrap_BossTaskException
3960		}
3961
3962
3963	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3963	>	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3964	>	PyObject *obj;
3965	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3966	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3967	>	Py_INCREF(obj);
3968	>	return Py_BuildValue((char *)"");
3969	>	}
3970	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3971		PyObject *resultobj;
3972	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3973	<	char *result;
3972	>	BossTask *arg1 = (BossTask *) 0 ;
3973	>	BossTask::job_iterator result;
3974		PyObject * obj0 = 0 ;
3975
3976	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3977	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3978	<	result = (char *) ((arg1)->key);
3979	<
3980	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3976	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3977	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3978	>	{
3979	>	try {
3980	>	result = ((BossTask const *)arg1)->job_begin();
3981	>
3982	>	}catch (const BossSchedFailure & e) {
3983	>	PyErr_SetString ( SchedulerError, e.what() );
3984	>	return NULL;
3985	>	}catch (const std::exception& e) {
3986	>	PyErr_SetString ( BossError, e.what() );
3987	>	return NULL;
3988	>	}
3989	>	}
3990	>	{
3991	>	BossTask::job_iterator * resultptr;
3992	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3993	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3994	>	}
3995		return resultobj;
3996		fail:
3997		return NULL;
3998		}
3999
4000
4001	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
4001	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4002		PyObject *resultobj;
4003	<	char *arg1 ;
4004	<	BossTaskException *result;
4003	>	BossTask *arg1 = (BossTask *) 0 ;
4004	>	BossTask::job_iterator result;
4005	>	PyObject * obj0 = 0 ;
4006
4007	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
4007	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4008	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4009		{
4010		try {
4011	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
4011	>	result = ((BossTask const *)arg1)->job_end();
4012
4013		}catch (const BossSchedFailure & e) {
4014		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3732 | Line 4018 | static PyObject *_wrap_new_BossTaskExcep
4018		return NULL;
4019		}
4020		}
4021	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
4021	>	{
4022	>	BossTask::job_iterator * resultptr;
4023	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4024	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4025	>	}
4026		return resultobj;
4027		fail:
4028		return NULL;
4029		}
4030
4031
4032	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
4032	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4033		PyObject *resultobj;
4034	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
4035	<	char *result;
4034	>	BossTask *arg1 = (BossTask *) 0 ;
4035	>	BossJob *arg2 = (BossJob *) 0 ;
4036	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4037		PyObject * obj0 = 0 ;
4038	+	PyObject * obj1 = 0 ;
4039
4040	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
4041	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4040	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4041	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4042	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4043		{
4044		try {
4045	<	result = (char *)((BossTaskException const *)arg1)->what();
4045	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4046
4047		}catch (const BossSchedFailure & e) {
4048		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3759 | Line 4052 | static PyObject *_wrap_BossTaskException
4052		return NULL;
4053		}
4054		}
4055	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
4055	>	{
4056	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4057	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4058	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4059	>	}
4060		return resultobj;
4061		fail:
4062		return NULL;
4063		}
4064
4065
4066	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
4066	>	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
4067		PyObject *resultobj;
4068	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
4068	>	BossTask *arg1 = (BossTask *) 0 ;
4069	>	BossJob *arg2 = (BossJob *) 0 ;
4070	>	std::string *arg3 = 0 ;
4071	>	BossProgram result;
4072	>	std::string temp3 ;
4073		PyObject * obj0 = 0 ;
4074	+	PyObject * obj1 = 0 ;
4075	+	PyObject * obj2 = 0 ;
4076
4077	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
4078	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4077	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
4078	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4079	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4080	>	{
4081	>	if (PyString_Check(obj2)) {
4082	>	temp3 = std::string(PyString_AsString(obj2));
4083	>	arg3 = &temp3;
4084	>	}else {
4085	>	SWIG_exception(SWIG_TypeError, "string expected");
4086	>	}
4087	>	}
4088		{
4089		try {
4090	<	delete arg1;
4090	>	result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
4091
4092		}catch (const BossSchedFailure & e) {
4093		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3785 | Line 4097 | static PyObject *_wrap_delete_BossTaskEx
4097		return NULL;
4098		}
4099		}
4100	<	Py_INCREF(Py_None); resultobj = Py_None;
4100	>	{
4101	>	BossProgram * resultptr;
4102	>	resultptr = new BossProgram((BossProgram &) result);
4103	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4104	>	}
4105		return resultobj;
4106		fail:
4107		return NULL;
4108		}
4109
4110
4111	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
4112	<	PyObject *obj;
4113	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4114	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
4115	<	Py_INCREF(obj);
4116	<	return Py_BuildValue((char *)"");
4111	>	static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4112	>	PyObject *resultobj;
4113	>	BossTask *arg1 = (BossTask *) 0 ;
4114	>	BossJob *arg2 = (BossJob *) 0 ;
4115	>	std::string *arg3 = 0 ;
4116	>	BossProgramExec result;
4117	>	std::string temp3 ;
4118	>	PyObject * obj0 = 0 ;
4119	>	PyObject * obj1 = 0 ;
4120	>	PyObject * obj2 = 0 ;
4121	>
4122	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4123	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4124	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4125	>	{
4126	>	if (PyString_Check(obj2)) {
4127	>	temp3 = std::string(PyString_AsString(obj2));
4128	>	arg3 = &temp3;
4129	>	}else {
4130	>	SWIG_exception(SWIG_TypeError, "string expected");
4131	>	}
4132	>	}
4133	>	{
4134	>	try {
4135	>	result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4136	>
4137	>	}catch (const BossSchedFailure & e) {
4138	>	PyErr_SetString ( SchedulerError, e.what() );
4139	>	return NULL;
4140	>	}catch (const std::exception& e) {
4141	>	PyErr_SetString ( BossError, e.what() );
4142	>	return NULL;
4143	>	}
4144	>	}
4145	>	{
4146	>	BossProgramExec * resultptr;
4147	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4148	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4149	>	}
4150	>	return resultobj;
4151	>	fail:
4152	>	return NULL;
4153		}
4154	+
4155	+
4156		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
4157		PyObject *resultobj;
4158		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 4049 | Line 4403 | static PyObject *_wrap_BossTask_name(PyO
4403		}
4404
4405
4406	<	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4406	>	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4407		PyObject *resultobj;
4408		BossTask *arg1 = (BossTask *) 0 ;
4409	<	std::map<std::string,std::string > result;
4409	>	std::string *arg2 = 0 ;
4410	>	BossChain result;
4411	>	std::string temp2 ;
4412		PyObject * obj0 = 0 ;
4413	+	PyObject * obj1 = 0 ;
4414
4415	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4415	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4416		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4417		{
4418	<	try {
4419	<	result = ((BossTask const *)arg1)->taskMap();
4420	<
4421	<	}catch (const BossSchedFailure & e) {
4422	<	PyErr_SetString ( SchedulerError, e.what() );
4066	<	return NULL;
4067	<	}catch (const std::exception& e) {
4068	<	PyErr_SetString ( BossError, e.what() );
4069	<	return NULL;
4070	<	}
4071	<	}
4072	<	{
4073	<	resultobj = PyDict_New();
4074	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4075	<	PyDict_SetItem(resultobj,
4076	<	SwigString_FromString(i->first),
4077	<	SwigString_FromString(i->second));
4418	>	if (PyString_Check(obj1)) {
4419	>	temp2 = std::string(PyString_AsString(obj1));
4420	>	arg2 = &temp2;
4421	>	}else {
4422	>	SWIG_exception(SWIG_TypeError, "string expected");
4423		}
4424		}
4080	–	return resultobj;
4081	–	fail:
4082	–	return NULL;
4083	–	}
4084	–
4085	–
4086	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4087	–	PyObject *resultobj;
4088	–	BossTask *arg1 = (BossTask *) 0 ;
4089	–	BossTask::job_iterator result;
4090	–	PyObject * obj0 = 0 ;
4091	–
4092	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4093	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4425		{
4426		try {
4427	<	result = ((BossTask const *)arg1)->job_begin();
4427	>	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4428
4429		}catch (const BossSchedFailure & e) {
4430		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4104 | Line 4435 | static PyObject *_wrap_BossTask_job_begi
4435		}
4436		}
4437		{
4438	<	BossTask::job_iterator * resultptr;
4439	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4440	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4438	>	BossChain * resultptr;
4439	>	resultptr = new BossChain((BossChain &) result);
4440	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4441		}
4442		return resultobj;
4443		fail:
#	Line 4114 | Line 4445 | static PyObject *_wrap_BossTask_job_begi
4445		}
4446
4447
4448	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4448	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4449		PyObject *resultobj;
4450		BossTask *arg1 = (BossTask *) 0 ;
4451	<	BossTask::job_iterator result;
4451	>	std::map<std::string,std::string > result;
4452		PyObject * obj0 = 0 ;
4453
4454	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4454	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4455		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4456		{
4457		try {
4458	<	result = ((BossTask const *)arg1)->job_end();
4458	>	result = ((BossTask const *)arg1)->taskMap();
4459
4460		}catch (const BossSchedFailure & e) {
4461		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4135 | Line 4466 | static PyObject *_wrap_BossTask_job_end(
4466		}
4467		}
4468		{
4469	<	BossTask::job_iterator * resultptr;
4470	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4471	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4469	>	resultobj = PyDict_New();
4470	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4471	>	PyDict_SetItem(resultobj,
4472	>	SwigString_FromString(i->first),
4473	>	SwigString_FromString(i->second));
4474	>	}
4475		}
4476		return resultobj;
4477		fail:
#	Line 4360 | Line 4694 | static PyObject *_wrap_BossTask_programs
4694		}
4695
4696
4363	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4364	–	PyObject *resultobj;
4365	–	BossTask *arg1 = (BossTask *) 0 ;
4366	–	BossJob *arg2 = (BossJob *) 0 ;
4367	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4368	–	PyObject * obj0 = 0 ;
4369	–	PyObject * obj1 = 0 ;
4370	–
4371	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4372	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4373	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4374	–	{
4375	–	try {
4376	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4377	–
4378	–	}catch (const BossSchedFailure & e) {
4379	–	PyErr_SetString ( SchedulerError, e.what() );
4380	–	return NULL;
4381	–	}catch (const std::exception& e) {
4382	–	PyErr_SetString ( BossError, e.what() );
4383	–	return NULL;
4384	–	}
4385	–	}
4386	–	{
4387	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4388	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4389	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4390	–	}
4391	–	return resultobj;
4392	–	fail:
4393	–	return NULL;
4394	–	}
4395	–
4396	–
4697		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4698		PyObject *resultobj;
4699		BossTask *arg1 = (BossTask *) 0 ;
#	Line 4907 | Line 5207 | static PyObject *_wrap_BossTask_getOutpu
5207		}
5208
5209
5210	+	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
5211	+	PyObject *resultobj;
5212	+	BossTask *arg1 = (BossTask *) 0 ;
5213	+	std::string *arg2 = 0 ;
5214	+	int result;
5215	+	std::string temp2 ;
5216	+	PyObject * obj0 = 0 ;
5217	+	PyObject * obj1 = 0 ;
5218	+
5219	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5220	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5221	+	{
5222	+	if (PyString_Check(obj1)) {
5223	+	temp2 = std::string(PyString_AsString(obj1));
5224	+	arg2 = &temp2;
5225	+	}else {
5226	+	SWIG_exception(SWIG_TypeError, "string expected");
5227	+	}
5228	+	}
5229	+	{
5230	+	try {
5231	+	result = (int)(arg1)->loadByName((std::string const &)*arg2);
5232	+
5233	+	}catch (const BossSchedFailure & e) {
5234	+	PyErr_SetString ( SchedulerError, e.what() );
5235	+	return NULL;
5236	+	}catch (const std::exception& e) {
5237	+	PyErr_SetString ( BossError, e.what() );
5238	+	return NULL;
5239	+	}
5240	+	}
5241	+	resultobj = PyInt_FromLong((long)result);
5242	+	return resultobj;
5243	+	fail:
5244	+	return NULL;
5245	+	}
5246	+
5247	+
5248		static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
5249		PyObject *resultobj;
5250		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5003 | Line 5341 | static PyObject *_wrap_BossTask_load(PyO
5341		}
5342
5343
5344	+	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5345	+	PyObject *resultobj;
5346	+	BossTask *arg1 = (BossTask *) 0 ;
5347	+	int arg2 = (int) SCHEDULED ;
5348	+	std::string const &arg3_defvalue = "all" ;
5349	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
5350	+	std::string const &arg4_defvalue = "" ;
5351	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
5352	+	std::string arg5 = (std::string) "" ;
5353	+	std::string arg6 = (std::string) "" ;
5354	+	std::string arg7 = (std::string) "" ;
5355	+	std::string arg8 = (std::string) "" ;
5356	+	unsigned int arg9 = (unsigned int) 0 ;
5357	+	int result;
5358	+	std::string temp3 ;
5359	+	std::string temp4 ;
5360	+	PyObject * obj0 = 0 ;
5361	+	PyObject * obj2 = 0 ;
5362	+	PyObject * obj3 = 0 ;
5363	+	PyObject * obj4 = 0 ;
5364	+	PyObject * obj5 = 0 ;
5365	+	PyObject * obj6 = 0 ;
5366	+	PyObject * obj7 = 0 ;
5367	+	PyObject * obj8 = 0 ;
5368	+
5369	+	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5370	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5371	+	if (obj2) {
5372	+	{
5373	+	if (PyString_Check(obj2)) {
5374	+	temp3 = std::string(PyString_AsString(obj2));
5375	+	arg3 = &temp3;
5376	+	}else {
5377	+	SWIG_exception(SWIG_TypeError, "string expected");
5378	+	}
5379	+	}
5380	+	}
5381	+	if (obj3) {
5382	+	{
5383	+	if (PyString_Check(obj3)) {
5384	+	temp4 = std::string(PyString_AsString(obj3));
5385	+	arg4 = &temp4;
5386	+	}else {
5387	+	SWIG_exception(SWIG_TypeError, "string expected");
5388	+	}
5389	+	}
5390	+	}
5391	+	if (obj4) {
5392	+	{
5393	+	if (PyString_Check(obj4))
5394	+	arg5 = std::string(PyString_AsString(obj4));
5395	+	else
5396	+	SWIG_exception(SWIG_TypeError, "string expected");
5397	+	}
5398	+	}
5399	+	if (obj5) {
5400	+	{
5401	+	if (PyString_Check(obj5))
5402	+	arg6 = std::string(PyString_AsString(obj5));
5403	+	else
5404	+	SWIG_exception(SWIG_TypeError, "string expected");
5405	+	}
5406	+	}
5407	+	if (obj6) {
5408	+	{
5409	+	if (PyString_Check(obj6))
5410	+	arg7 = std::string(PyString_AsString(obj6));
5411	+	else
5412	+	SWIG_exception(SWIG_TypeError, "string expected");
5413	+	}
5414	+	}
5415	+	if (obj7) {
5416	+	{
5417	+	if (PyString_Check(obj7))
5418	+	arg8 = std::string(PyString_AsString(obj7));
5419	+	else
5420	+	SWIG_exception(SWIG_TypeError, "string expected");
5421	+	}
5422	+	}
5423	+	if (obj8) {
5424	+	arg9 = (unsigned int) PyInt_AsLong(obj8);
5425	+	if (PyErr_Occurred()) SWIG_fail;
5426	+	}
5427	+	{
5428	+	try {
5429	+	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5430	+
5431	+	}catch (const BossSchedFailure & e) {
5432	+	PyErr_SetString ( SchedulerError, e.what() );
5433	+	return NULL;
5434	+	}catch (const std::exception& e) {
5435	+	PyErr_SetString ( BossError, e.what() );
5436	+	return NULL;
5437	+	}
5438	+	}
5439	+	resultobj = PyInt_FromLong((long)result);
5440	+	return resultobj;
5441	+	fail:
5442	+	return NULL;
5443	+	}
5444	+
5445	+
5446		static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
5447		PyObject *resultobj;
5448		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5205 | Line 5645 | static PyObject *_wrap_BossTask_appendTo
5645		BossTask *arg1 = (BossTask *) 0 ;
5646		PyObject *arg2 = (PyObject *) 0 ;
5647		BossAttributeContainer *arg3 = 0 ;
5208	–	PyObject *result;
5648		PyObject * obj0 = 0 ;
5649		PyObject * obj1 = 0 ;
5650		PyObject * obj2 = 0 ;
#	Line 5219 | Line 5658 | static PyObject *_wrap_BossTask_appendTo
5658		}
5659		{
5660		try {
5661	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5661	>	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5662
5663		}catch (const BossSchedFailure & e) {
5664		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5229 | Line 5668 | static PyObject *_wrap_BossTask_appendTo
5668		return NULL;
5669		}
5670		}
5671	<	resultobj = result;
5671	>	Py_INCREF(Py_None); resultobj = Py_None;
5672		return resultobj;
5673		fail:
5674		return NULL;
#	Line 5239 | Line 5678 | static PyObject *_wrap_BossTask_appendTo
5678		static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5679		PyObject *resultobj;
5680		BossTask *arg1 = (BossTask *) 0 ;
5681	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5682	<	PyObject *result;
5681	>	BossJob *arg2 = (BossJob *) 0 ;
5682	>	PyObject *arg3 = (PyObject *) 0 ;
5683		PyObject * obj0 = 0 ;
5684		PyObject * obj1 = 0 ;
5685	+	PyObject * obj2 = 0 ;
5686
5687	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5687	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5688		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5689	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5690	<	if (arg2 == NULL) {
5251	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5252	<	}
5689	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5690	>	arg3 = obj2;
5691		{
5692		try {
5693	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5693	>	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5694
5695		}catch (const BossSchedFailure & e) {
5696		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5262 | Line 5700 | static PyObject *_wrap_BossTask_jobDict(
5700		return NULL;
5701		}
5702		}
5703	<	resultobj = result;
5703	>	Py_INCREF(Py_None); resultobj = Py_None;
5704		return resultobj;
5705		fail:
5706		return NULL;
#	Line 5296 | Line 5734 | static PyObject *_wrap_BossTask_jobsDict
5734		}
5735
5736
5737	+	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5738	+	PyObject *resultobj;
5739	+	BossTask *arg1 = (BossTask *) 0 ;
5740	+	std::string *arg2 = 0 ;
5741	+	PyObject *result;
5742	+	std::string temp2 ;
5743	+	PyObject * obj0 = 0 ;
5744	+	PyObject * obj1 = 0 ;
5745	+
5746	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5747	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5748	+	{
5749	+	if (PyString_Check(obj1)) {
5750	+	temp2 = std::string(PyString_AsString(obj1));
5751	+	arg2 = &temp2;
5752	+	}else {
5753	+	SWIG_exception(SWIG_TypeError, "string expected");
5754	+	}
5755	+	}
5756	+	{
5757	+	try {
5758	+	result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5759	+
5760	+	}catch (const BossSchedFailure & e) {
5761	+	PyErr_SetString ( SchedulerError, e.what() );
5762	+	return NULL;
5763	+	}catch (const std::exception& e) {
5764	+	PyErr_SetString ( BossError, e.what() );
5765	+	return NULL;
5766	+	}
5767	+	}
5768	+	resultobj = result;
5769	+	return resultobj;
5770	+	fail:
5771	+	return NULL;
5772	+	}
5773	+
5774	+
5775	+	static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
5776	+	PyObject *resultobj;
5777	+	BossTask *arg1 = (BossTask *) 0 ;
5778	+	std::string *arg2 = 0 ;
5779	+	PyObject *result;
5780	+	std::string temp2 ;
5781	+	PyObject * obj0 = 0 ;
5782	+	PyObject * obj1 = 0 ;
5783	+
5784	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5785	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5786	+	{
5787	+	if (PyString_Check(obj1)) {
5788	+	temp2 = std::string(PyString_AsString(obj1));
5789	+	arg2 = &temp2;
5790	+	}else {
5791	+	SWIG_exception(SWIG_TypeError, "string expected");
5792	+	}
5793	+	}
5794	+	{
5795	+	try {
5796	+	result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
5797	+
5798	+	}catch (const BossSchedFailure & e) {
5799	+	PyErr_SetString ( SchedulerError, e.what() );
5800	+	return NULL;
5801	+	}catch (const std::exception& e) {
5802	+	PyErr_SetString ( BossError, e.what() );
5803	+	return NULL;
5804	+	}
5805	+	}
5806	+	resultobj = result;
5807	+	return resultobj;
5808	+	fail:
5809	+	return NULL;
5810	+	}
5811	+
5812	+
5813	+	static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5814	+	PyObject *resultobj;
5815	+	BossTask *arg1 = (BossTask *) 0 ;
5816	+	PyObject *result;
5817	+	PyObject * obj0 = 0 ;
5818	+
5819	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5820	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5821	+	{
5822	+	try {
5823	+	result = (PyObject *)BossTask_jobStates(arg1);
5824	+
5825	+	}catch (const BossSchedFailure & e) {
5826	+	PyErr_SetString ( SchedulerError, e.what() );
5827	+	return NULL;
5828	+	}catch (const std::exception& e) {
5829	+	PyErr_SetString ( BossError, e.what() );
5830	+	return NULL;
5831	+	}
5832	+	}
5833	+	resultobj = result;
5834	+	return resultobj;
5835	+	fail:
5836	+	return NULL;
5837	+	}
5838	+
5839	+
5840	+	static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5841	+	PyObject *resultobj;
5842	+	BossTask *arg1 = (BossTask *) 0 ;
5843	+	PyObject *result;
5844	+	PyObject * obj0 = 0 ;
5845	+
5846	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5847	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5848	+	{
5849	+	try {
5850	+	result = (PyObject *)BossTask_jobStatistic(arg1);
5851	+
5852	+	}catch (const BossSchedFailure & e) {
5853	+	PyErr_SetString ( SchedulerError, e.what() );
5854	+	return NULL;
5855	+	}catch (const std::exception& e) {
5856	+	PyErr_SetString ( BossError, e.what() );
5857	+	return NULL;
5858	+	}
5859	+	}
5860	+	resultobj = result;
5861	+	return resultobj;
5862	+	fail:
5863	+	return NULL;
5864	+	}
5865	+
5866	+
5867		static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5868		PyObject *resultobj;
5869		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5367 | Line 5935 | static PyObject *_wrap_BossTask_jobProgr
5935		}
5936
5937
5938	+	static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5939	+	PyObject *resultobj;
5940	+	BossTask *arg1 = (BossTask *) 0 ;
5941	+	std::string *arg2 = 0 ;
5942	+	std::string *arg3 = 0 ;
5943	+	PyObject *result;
5944	+	std::string temp2 ;
5945	+	std::string temp3 ;
5946	+	PyObject * obj0 = 0 ;
5947	+	PyObject * obj1 = 0 ;
5948	+	PyObject * obj2 = 0 ;
5949	+
5950	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5951	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5952	+	{
5953	+	if (PyString_Check(obj1)) {
5954	+	temp2 = std::string(PyString_AsString(obj1));
5955	+	arg2 = &temp2;
5956	+	}else {
5957	+	SWIG_exception(SWIG_TypeError, "string expected");
5958	+	}
5959	+	}
5960	+	{
5961	+	if (PyString_Check(obj2)) {
5962	+	temp3 = std::string(PyString_AsString(obj2));
5963	+	arg3 = &temp3;
5964	+	}else {
5965	+	SWIG_exception(SWIG_TypeError, "string expected");
5966	+	}
5967	+	}
5968	+	{
5969	+	try {
5970	+	result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5971	+
5972	+	}catch (const BossSchedFailure & e) {
5973	+	PyErr_SetString ( SchedulerError, e.what() );
5974	+	return NULL;
5975	+	}catch (const std::exception& e) {
5976	+	PyErr_SetString ( BossError, e.what() );
5977	+	return NULL;
5978	+	}
5979	+	}
5980	+	resultobj = result;
5981	+	return resultobj;
5982	+	fail:
5983	+	return NULL;
5984	+	}
5985	+
5986	+
5987	+	static PyObject *_wrap_BossTask_programExec(PyObject *self, PyObject *args) {
5988	+	PyObject *resultobj;
5989	+	BossTask *arg1 = (BossTask *) 0 ;
5990	+	std::string *arg2 = 0 ;
5991	+	std::string *arg3 = 0 ;
5992	+	PyObject *result;
5993	+	std::string temp2 ;
5994	+	std::string temp3 ;
5995	+	PyObject * obj0 = 0 ;
5996	+	PyObject * obj1 = 0 ;
5997	+	PyObject * obj2 = 0 ;
5998	+
5999	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
6000	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6001	+	{
6002	+	if (PyString_Check(obj1)) {
6003	+	temp2 = std::string(PyString_AsString(obj1));
6004	+	arg2 = &temp2;
6005	+	}else {
6006	+	SWIG_exception(SWIG_TypeError, "string expected");
6007	+	}
6008	+	}
6009	+	{
6010	+	if (PyString_Check(obj2)) {
6011	+	temp3 = std::string(PyString_AsString(obj2));
6012	+	arg3 = &temp3;
6013	+	}else {
6014	+	SWIG_exception(SWIG_TypeError, "string expected");
6015	+	}
6016	+	}
6017	+	{
6018	+	try {
6019	+	result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
6020	+
6021	+	}catch (const BossSchedFailure & e) {
6022	+	PyErr_SetString ( SchedulerError, e.what() );
6023	+	return NULL;
6024	+	}catch (const std::exception& e) {
6025	+	PyErr_SetString ( BossError, e.what() );
6026	+	return NULL;
6027	+	}
6028	+	}
6029	+	resultobj = result;
6030	+	return resultobj;
6031	+	fail:
6032	+	return NULL;
6033	+	}
6034	+
6035	+
6036	+	static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
6037	+	PyObject *resultobj;
6038	+	BossTask *arg1 = (BossTask *) 0 ;
6039	+	std::string *arg2 = 0 ;
6040	+	std::string *arg3 = 0 ;
6041	+	PyObject *result;
6042	+	std::string temp2 ;
6043	+	std::string temp3 ;
6044	+	PyObject * obj0 = 0 ;
6045	+	PyObject * obj1 = 0 ;
6046	+	PyObject * obj2 = 0 ;
6047	+
6048	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
6049	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6050	+	{
6051	+	if (PyString_Check(obj1)) {
6052	+	temp2 = std::string(PyString_AsString(obj1));
6053	+	arg2 = &temp2;
6054	+	}else {
6055	+	SWIG_exception(SWIG_TypeError, "string expected");
6056	+	}
6057	+	}
6058	+	{
6059	+	if (PyString_Check(obj2)) {
6060	+	temp3 = std::string(PyString_AsString(obj2));
6061	+	arg3 = &temp3;
6062	+	}else {
6063	+	SWIG_exception(SWIG_TypeError, "string expected");
6064	+	}
6065	+	}
6066	+	{
6067	+	try {
6068	+	result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
6069	+
6070	+	}catch (const BossSchedFailure & e) {
6071	+	PyErr_SetString ( SchedulerError, e.what() );
6072	+	return NULL;
6073	+	}catch (const std::exception& e) {
6074	+	PyErr_SetString ( BossError, e.what() );
6075	+	return NULL;
6076	+	}
6077	+	}
6078	+	resultobj = result;
6079	+	return resultobj;
6080	+	fail:
6081	+	return NULL;
6082	+	}
6083	+
6084	+
6085		static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
6086		PyObject *obj;
6087		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 6346 | Line 7061 | static PyMethodDef SwigMethods[] = {
7061		{ (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 },
7065		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
7066	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
7067	+	{ (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 },
7070		{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7071		{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7072		{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
#	Line 6355 | Line 7075 | static PyMethodDef SwigMethods[] = {
7075		{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7076		{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7077		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6358	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6359	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7078		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
6361	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7079		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7080		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7081	+	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7082	+	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7083	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7084	+	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7085	+	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
7086		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
7087		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7088		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7089		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7090	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7091		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6369	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6370	–	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7092		{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7093		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
7094		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6374	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7095		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7096		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7097		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
#	Line 6379 | Line 7099 | static PyMethodDef SwigMethods[] = {
7099		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
7100		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
7101		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7102	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7103		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7104	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7105		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7106		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7107		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7108		{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7109		{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7110		{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7111	+	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7112	+	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7113	+	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7114	+	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7115		{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7116		{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7117	+	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7118	+	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7119	+	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7120		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
7121		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7122		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 6412 | Line 7141 | static PyMethodDef SwigMethods[] = {
7141
7142		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7143
6415	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7144		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}};
7145	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7146		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}};
7147	+	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}};
7149	+	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7150		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}};
6420	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7151		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7152		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7153	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7154	+	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7155		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7156		static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7157		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
#	Line 6428 | Line 7160 | static swig_type_info _swigt__p_BossSess
7160		static swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0},{"_p_std__vectorTstd__string_t"},{0}};
7161		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}};
7162		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
6431	–	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}};
7163		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}};
7164	+	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}};
7165		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7166
7167		static swig_type_info *swig_types_initial[] = {
6436	–	_swigt__p_XMLDoc,
7168		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
7169	+	_swigt__p_XMLDoc,
7170		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7171	+	_swigt__p_BossProgramExec,
7172		_swigt__p_std__vectorTBossTask_p_t,
7173	+	_swigt__p_BossChain,
7174		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6441	–	_swigt__p_std__ostream,
7175		_swigt__p_BossTask,
7176		_swigt__p_BossTaskException,
7177	+	_swigt__p_std__ostream,
7178	+	_swigt__p_BossProgram,
7179		_swigt__p_printOption,
7180		_swigt__p_BossAttributeContainer,
7181		_swigt__p_BossJob,
#	Line 6449 | Line 7184 | _swigt__p_BossSession,
7184		_swigt__p_std__vectorTstd__string_t,
7185		_swigt__p_std__mapTstd__string_std__string_t,
7186		_swigt__p_BossAdministratorSession,
6452	–	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7187		_swigt__p_BossTask__job_iterator,
7188	+	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7189		_swigt__p_jobStates,
7190		0
7191		};

Diff Legend

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