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.26 by gcodispo, Thu Mar 8 11:06:25 2007 UTC vs.
Revision 1.32 by gcodispo, Fri May 18 16:10: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 972 | Line 976 | PyObject *BossSession_queryTasks(BossSes
976		if ( taskName.empty() ) {
977		taskList = self->selectTasks( taskRange, before, after, user);
978		} else {
975	–	std::cout << "taskRange\n";
979		taskList = self->selectTasksByName( taskName );
980		}
981		for ( std::vector <std::string>::const_iterator it= taskList.begin();
#	Line 995 | Line 998 | void BossTask_appendToPyDict(BossTask co
998		}
999		return;
1000		}
1001	<	void BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit,PyObject *job_dict){
1001	>	void BossTask_jobDict(BossTask const *self,BossJob const *jobH,PyObject *job_dict){
1002
1003		//    PyObject * job_dict = PyDict_New();
1004		std::string tmp;
1005
1006	<	BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1006	>	BossAttributeContainer obj = jobH->getTableEntries("JOB");
1007		BossTask_appendToPyDict ( self, job_dict, obj );
1008
1009	<	std::set<std::string> sch = (*jit)->getSchedulerElements();
1009	>	std::set<std::string> sch = jobH->getSchedulerElements();
1010		std::set<std::string>::const_iterator sch_end =  sch.end();
1011		for (std::set<std::string>::const_iterator it =sch.begin();
1012		it != sch_end; ++ it ) {
1013
1014	<	tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1014	>	tmp = (*jobH)["JOB_SCHED_INFO."+(*it)];
1015		PyObject * key = PyString_FromString( it->c_str() );
1016		PyObject * val = PyString_FromString( tmp.c_str() );
1017		PyDict_SetItem( job_dict, key, val);
#	Line 1025 | Line 1028 | PyObject *BossTask_jobsDict(BossTask *se
1028		jit != self->job_end (); ++jit) {
1029		PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1030		PyObject * tmp_dict = PyDict_New();
1031	<	BossTask_jobDict( self, jit, tmp_dict );
1031	>	BossTask_jobDict( self, *jit, tmp_dict );
1032		PyDict_SetItem( job_dict, id, tmp_dict );
1033		Py_DECREF(id);
1034		Py_DECREF(tmp_dict);
1035		}
1036		return job_dict;
1037		}
1038	+	PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1039	+
1040	+	PyObject * job_dict = PyDict_New();
1041	+	self->load( ALL, jobid );
1042	+	BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1043	+	return job_dict;
1044	+	}
1045	+	PyObject *BossTask_Chain(BossTask *self,std::string const &jobid){
1046	+
1047	+	PyObject * chain_dict = PyDict_New();
1048	+	BossAttributeContainer obj =
1049	+	self->chain( jobid ).getTableEntries("CHAIN");
1050	+	BossTask_appendToPyDict ( self, chain_dict, obj );
1051	+	return chain_dict;
1052	+	}
1053	+	PyObject *BossTask_jobStates(BossTask *self){
1054	+
1055	+	PyObject * job_dict = PyDict_New();
1056	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1057	+	for (BossTask::job_iterator jit = self->job_begin ();
1058	+	jit != self->job_end (); ++jit) {
1059	+	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1060	+	PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1061	+	PyDict_SetItem( job_dict, id, status );
1062	+	Py_DECREF(id);
1063	+	Py_DECREF(status);
1064	+	}
1065	+	return job_dict;
1066	+	}
1067	+	PyObject *BossTask_jobStatistic(BossTask *self){
1068	+
1069	+	PyObject * job_dict = PyDict_New();
1070	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1071	+	std::map< std::string, int > states;
1072	+	for (BossTask::job_iterator jit = self->job_begin ();
1073	+	jit != self->job_end (); ++jit) {
1074	+	++states[(**jit)["JOB.STATUS"]];
1075	+	}
1076	+
1077	+	std::map< std::string, int >::const_iterator end = states.end ();
1078	+	for (std::map< std::string, int >::const_iterator it = states.begin ();
1079	+	it != end; ++it) {
1080	+	PyObject * status = PyString_FromString( (it->first).c_str() );
1081	+	PyObject * jobs = PyString_FromFormat( "%d", it->second );
1082	+	PyDict_SetItem( job_dict, status, jobs );
1083	+	Py_DECREF(jobs);
1084	+	Py_DECREF(status);
1085	+	}
1086	+	return job_dict;
1087	+	}
1088		PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator &programs_it){
1089
1090		PyObject * job_dict = PyDict_New();
#	Line 1081 | Line 1134 | PyObject *BossTask_jobPrograms(BossTask
1134		}
1135		return job_dict;
1136		}
1137	+	PyObject *BossTask_program(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	+	BossAttributeContainer obj =
1143	+	self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1144	+	BossTask_appendToPyDict ( self, job_dict, obj );
1145	+	return job_dict;
1146	+	}
1147	+	PyObject *BossTask_programExec(BossTask *self,std::string const &jobid,std::string const &programId){
1148	+
1149	+	PyObject * job_dict = PyDict_New();
1150	+
1151	+	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1152	+
1153	+	// PROGRAM_EXEC
1154	+	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1155	+	BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1156	+	BossTask_appendToPyDict ( self, job_dict, obj );
1157	+
1158	+	// SPECIFICS
1159	+	std::vector < BossAttributeContainer >::const_iterator it;
1160	+	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1161	+	for ( it = programExec.specBegin (); it != it_end; ++it) {
1162	+	BossTask_appendToPyDict ( self, job_dict, *it );
1163	+	}
1164	+	return job_dict;
1165	+	}
1166	+	PyObject *BossTask_specific(BossTask *self,std::string const &jobid,std::string const &programId){
1167	+
1168	+	PyObject * job_dict = PyDict_New();
1169	+
1170	+	const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1171	+	BossProgramExec programExec = self->queryProgramExec( jH, programId );
1172	+	BossAttributeContainer obj = programExec.getKeys ();
1173	+	BossTask_appendToPyDict ( self, job_dict, obj );
1174	+
1175	+	std::vector < BossAttributeContainer >::const_iterator it;
1176	+	std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1177	+	for ( it = programExec.specBegin (); it != it_end; ++it) {
1178	+	BossTask_appendToPyDict ( self, job_dict, *it );
1179	+	}
1180	+	return job_dict;
1181	+	}
1182		#ifdef __cplusplus
1183		extern "C" {
1184		#endif
#	Line 3402 | Line 3500 | static PyObject *_wrap_BossSession_getTa
3500		}
3501
3502
3503	+	static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3504	+	PyObject *resultobj;
3505	+	BossSession *arg1 = (BossSession *) 0 ;
3506	+	std::string *arg2 = 0 ;
3507	+	SwigValueWrapper< std::vector<BossTask * > > result;
3508	+	std::string temp2 ;
3509	+	PyObject * obj0 = 0 ;
3510	+	PyObject * obj1 = 0 ;
3511	+
3512	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3513	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3514	+	{
3515	+	if (PyString_Check(obj1)) {
3516	+	temp2 = std::string(PyString_AsString(obj1));
3517	+	arg2 = &temp2;
3518	+	}else {
3519	+	SWIG_exception(SWIG_TypeError, "string expected");
3520	+	}
3521	+	}
3522	+	{
3523	+	try {
3524	+	result = (arg1)->getTasksByJobName((std::string const &)*arg2);
3525	+
3526	+	}catch (const BossSchedFailure & e) {
3527	+	PyErr_SetString ( SchedulerError, e.what() );
3528	+	return NULL;
3529	+	}catch (const std::exception& e) {
3530	+	PyErr_SetString ( BossError, e.what() );
3531	+	return NULL;
3532	+	}
3533	+	}
3534	+	{
3535	+	std::vector<BossTask * > * resultptr;
3536	+	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3537	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3538	+	}
3539	+	return resultobj;
3540	+	fail:
3541	+	return NULL;
3542	+	}
3543	+
3544	+
3545	+	static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
3546	+	PyObject *resultobj;
3547	+	BossSession *arg1 = (BossSession *) 0 ;
3548	+	unsigned int result;
3549	+	PyObject * obj0 = 0 ;
3550	+
3551	+	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
3552	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3553	+	{
3554	+	try {
3555	+	result = (unsigned int)(arg1)->tasksInMemory();
3556	+
3557	+	}catch (const BossSchedFailure & e) {
3558	+	PyErr_SetString ( SchedulerError, e.what() );
3559	+	return NULL;
3560	+	}catch (const std::exception& e) {
3561	+	PyErr_SetString ( BossError, e.what() );
3562	+	return NULL;
3563	+	}
3564	+	}
3565	+	resultobj = PyInt_FromLong((long)result);
3566	+	return resultobj;
3567	+	fail:
3568	+	return NULL;
3569	+	}
3570	+
3571	+
3572	+	static PyObject *_wrap_BossSession_locate(PyObject *self, PyObject *args) {
3573	+	PyObject *resultobj;
3574	+	BossSession *arg1 = (BossSession *) 0 ;
3575	+	unsigned int arg2 ;
3576	+	BossTask *result;
3577	+	PyObject * obj0 = 0 ;
3578	+	PyObject * obj1 = 0 ;
3579	+
3580	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
3581	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3582	+	arg2 = (unsigned int) PyInt_AsLong(obj1);
3583	+	if (PyErr_Occurred()) SWIG_fail;
3584	+	{
3585	+	try {
3586	+	result = (BossTask *)(arg1)->locate(arg2);
3587	+
3588	+	}catch (const BossSchedFailure & e) {
3589	+	PyErr_SetString ( SchedulerError, e.what() );
3590	+	return NULL;
3591	+	}catch (const std::exception& e) {
3592	+	PyErr_SetString ( BossError, e.what() );
3593	+	return NULL;
3594	+	}
3595	+	}
3596	+	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
3597	+	return resultobj;
3598	+	fail:
3599	+	return NULL;
3600	+	}
3601	+
3602	+
3603		static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3604		PyObject *resultobj;
3605		BossSession *arg1 = (BossSession *) 0 ;
#	Line 3724 | Line 3922 | static PyObject * BossSession_swigregist
3922		Py_INCREF(obj);
3923		return Py_BuildValue((char *)"");
3924		}
3925	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3925	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3926	>	PyObject *resultobj;
3927	>	char *arg1 ;
3928	>	BossTaskException *result;
3929	>
3930	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3931	>	{
3932	>	try {
3933	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3934	>
3935	>	}catch (const BossSchedFailure & e) {
3936	>	PyErr_SetString ( SchedulerError, e.what() );
3937	>	return NULL;
3938	>	}catch (const std::exception& e) {
3939	>	PyErr_SetString ( BossError, e.what() );
3940	>	return NULL;
3941	>	}
3942	>	}
3943	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3944	>	return resultobj;
3945	>	fail:
3946	>	return NULL;
3947	>	}
3948	>
3949	>
3950	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3951		PyObject *resultobj;
3952		BossTaskException *arg1 = (BossTaskException *) 0 ;
3730	–	char *arg2 ;
3953		PyObject * obj0 = 0 ;
3954
3955	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3955	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3956		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3957		{
3958	<	if (arg2) {
3959	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3960	<	strcpy((char *) arg1->key,arg2);
3961	<	}else {
3962	<	arg1->key = 0;
3958	>	try {
3959	>	delete arg1;
3960	>
3961	>	}catch (const BossSchedFailure & e) {
3962	>	PyErr_SetString ( SchedulerError, e.what() );
3963	>	return NULL;
3964	>	}catch (const std::exception& e) {
3965	>	PyErr_SetString ( BossError, e.what() );
3966	>	return NULL;
3967		}
3968		}
3969		Py_INCREF(Py_None); resultobj = Py_None;
#	Line 3747 | Line 3973 | static PyObject *_wrap_BossTaskException
3973		}
3974
3975
3976	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3976	>	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3977	>	PyObject *obj;
3978	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3979	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3980	>	Py_INCREF(obj);
3981	>	return Py_BuildValue((char *)"");
3982	>	}
3983	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3984		PyObject *resultobj;
3985	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
3986	<	char *result;
3985	>	BossTask *arg1 = (BossTask *) 0 ;
3986	>	BossTask::job_iterator result;
3987		PyObject * obj0 = 0 ;
3988
3989	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3990	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3991	<	result = (char *) ((arg1)->key);
3992	<
3993	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3989	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3990	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3991	>	{
3992	>	try {
3993	>	result = ((BossTask const *)arg1)->job_begin();
3994	>
3995	>	}catch (const BossSchedFailure & e) {
3996	>	PyErr_SetString ( SchedulerError, e.what() );
3997	>	return NULL;
3998	>	}catch (const std::exception& e) {
3999	>	PyErr_SetString ( BossError, e.what() );
4000	>	return NULL;
4001	>	}
4002	>	}
4003	>	{
4004	>	BossTask::job_iterator * resultptr;
4005	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4006	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4007	>	}
4008		return resultobj;
4009		fail:
4010		return NULL;
4011		}
4012
4013
4014	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
4014	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4015		PyObject *resultobj;
4016	<	char *arg1 ;
4017	<	BossTaskException *result;
4016	>	BossTask *arg1 = (BossTask *) 0 ;
4017	>	BossTask::job_iterator result;
4018	>	PyObject * obj0 = 0 ;
4019
4020	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
4020	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4021	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4022		{
4023		try {
4024	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
4024	>	result = ((BossTask const *)arg1)->job_end();
4025
4026		}catch (const BossSchedFailure & e) {
4027		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3782 | Line 4031 | static PyObject *_wrap_new_BossTaskExcep
4031		return NULL;
4032		}
4033		}
4034	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
4034	>	{
4035	>	BossTask::job_iterator * resultptr;
4036	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4037	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4038	>	}
4039		return resultobj;
4040		fail:
4041		return NULL;
4042		}
4043
4044
4045	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
4045	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4046		PyObject *resultobj;
4047	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
4048	<	char *result;
4047	>	BossTask *arg1 = (BossTask *) 0 ;
4048	>	BossJob *arg2 = (BossJob *) 0 ;
4049	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4050		PyObject * obj0 = 0 ;
4051	+	PyObject * obj1 = 0 ;
4052
4053	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
4054	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4053	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4054	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4055	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4056		{
4057		try {
4058	<	result = (char *)((BossTaskException const *)arg1)->what();
4058	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4059
4060		}catch (const BossSchedFailure & e) {
4061		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3809 | Line 4065 | static PyObject *_wrap_BossTaskException
4065		return NULL;
4066		}
4067		}
4068	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
4068	>	{
4069	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4070	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4071	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4072	>	}
4073		return resultobj;
4074		fail:
4075		return NULL;
4076		}
4077
4078
4079	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
4079	>	static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
4080		PyObject *resultobj;
4081	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
4081	>	BossTask *arg1 = (BossTask *) 0 ;
4082	>	BossJob *arg2 = (BossJob *) 0 ;
4083	>	std::string *arg3 = 0 ;
4084	>	BossProgram result;
4085	>	std::string temp3 ;
4086		PyObject * obj0 = 0 ;
4087	+	PyObject * obj1 = 0 ;
4088	+	PyObject * obj2 = 0 ;
4089
4090	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
4091	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4090	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&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	<	delete arg1;
4103	>	result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
4104
4105		}catch (const BossSchedFailure & e) {
4106		PyErr_SetString ( SchedulerError, e.what() );
#	Line 3835 | Line 4110 | static PyObject *_wrap_delete_BossTaskEx
4110		return NULL;
4111		}
4112		}
4113	<	Py_INCREF(Py_None); resultobj = Py_None;
4113	>	{
4114	>	BossProgram * resultptr;
4115	>	resultptr = new BossProgram((BossProgram &) result);
4116	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4117	>	}
4118		return resultobj;
4119		fail:
4120		return NULL;
4121		}
4122
4123
4124	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
4125	<	PyObject *obj;
4126	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4127	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
4128	<	Py_INCREF(obj);
4129	<	return Py_BuildValue((char *)"");
4124	>	static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4125	>	PyObject *resultobj;
4126	>	BossTask *arg1 = (BossTask *) 0 ;
4127	>	BossJob *arg2 = (BossJob *) 0 ;
4128	>	std::string *arg3 = 0 ;
4129	>	BossProgramExec result;
4130	>	std::string temp3 ;
4131	>	PyObject * obj0 = 0 ;
4132	>	PyObject * obj1 = 0 ;
4133	>	PyObject * obj2 = 0 ;
4134	>
4135	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4136	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4137	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4138	>	{
4139	>	if (PyString_Check(obj2)) {
4140	>	temp3 = std::string(PyString_AsString(obj2));
4141	>	arg3 = &temp3;
4142	>	}else {
4143	>	SWIG_exception(SWIG_TypeError, "string expected");
4144	>	}
4145	>	}
4146	>	{
4147	>	try {
4148	>	result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4149	>
4150	>	}catch (const BossSchedFailure & e) {
4151	>	PyErr_SetString ( SchedulerError, e.what() );
4152	>	return NULL;
4153	>	}catch (const std::exception& e) {
4154	>	PyErr_SetString ( BossError, e.what() );
4155	>	return NULL;
4156	>	}
4157	>	}
4158	>	{
4159	>	BossProgramExec * resultptr;
4160	>	resultptr = new BossProgramExec((BossProgramExec &) result);
4161	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4162	>	}
4163	>	return resultobj;
4164	>	fail:
4165	>	return NULL;
4166		}
4167	+
4168	+
4169		static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
4170		PyObject *resultobj;
4171		BossDatabase *arg1 = (BossDatabase *) 0 ;
#	Line 4099 | Line 4416 | static PyObject *_wrap_BossTask_name(PyO
4416		}
4417
4418
4419	<	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4419	>	static PyObject *_wrap_BossTask_chain(PyObject *self, PyObject *args) {
4420		PyObject *resultobj;
4421		BossTask *arg1 = (BossTask *) 0 ;
4422	<	std::map<std::string,std::string > result;
4422	>	std::string *arg2 = 0 ;
4423	>	BossChain result;
4424	>	std::string temp2 ;
4425		PyObject * obj0 = 0 ;
4426	+	PyObject * obj1 = 0 ;
4427
4428	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4428	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_chain",&obj0,&obj1)) goto fail;
4429		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4430		{
4431	<	try {
4432	<	result = ((BossTask const *)arg1)->taskMap();
4433	<
4434	<	}catch (const BossSchedFailure & e) {
4435	<	PyErr_SetString ( SchedulerError, e.what() );
4116	<	return NULL;
4117	<	}catch (const std::exception& e) {
4118	<	PyErr_SetString ( BossError, e.what() );
4119	<	return NULL;
4431	>	if (PyString_Check(obj1)) {
4432	>	temp2 = std::string(PyString_AsString(obj1));
4433	>	arg2 = &temp2;
4434	>	}else {
4435	>	SWIG_exception(SWIG_TypeError, "string expected");
4436		}
4437		}
4438		{
4123	–	resultobj = PyDict_New();
4124	–	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4125	–	PyDict_SetItem(resultobj,
4126	–	SwigString_FromString(i->first),
4127	–	SwigString_FromString(i->second));
4128	–	}
4129	–	}
4130	–	return resultobj;
4131	–	fail:
4132	–	return NULL;
4133	–	}
4134	–
4135	–
4136	–	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4137	–	PyObject *resultobj;
4138	–	BossTask *arg1 = (BossTask *) 0 ;
4139	–	BossTask::job_iterator result;
4140	–	PyObject * obj0 = 0 ;
4141	–
4142	–	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4143	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4144	–	{
4439		try {
4440	<	result = ((BossTask const *)arg1)->job_begin();
4440	>	result = ((BossTask const *)arg1)->chain((std::string const &)*arg2);
4441
4442		}catch (const BossSchedFailure & e) {
4443		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4154 | Line 4448 | static PyObject *_wrap_BossTask_job_begi
4448		}
4449		}
4450		{
4451	<	BossTask::job_iterator * resultptr;
4452	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4453	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4451	>	BossChain * resultptr;
4452	>	resultptr = new BossChain((BossChain &) result);
4453	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossChain, 1);
4454		}
4455		return resultobj;
4456		fail:
#	Line 4164 | Line 4458 | static PyObject *_wrap_BossTask_job_begi
4458		}
4459
4460
4461	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4461	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4462		PyObject *resultobj;
4463		BossTask *arg1 = (BossTask *) 0 ;
4464	<	BossTask::job_iterator result;
4464	>	std::map<std::string,std::string > result;
4465		PyObject * obj0 = 0 ;
4466
4467	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4467	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4468		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4469		{
4470		try {
4471	<	result = ((BossTask const *)arg1)->job_end();
4471	>	result = ((BossTask const *)arg1)->taskMap();
4472
4473		}catch (const BossSchedFailure & e) {
4474		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4185 | Line 4479 | static PyObject *_wrap_BossTask_job_end(
4479		}
4480		}
4481		{
4482	<	BossTask::job_iterator * resultptr;
4483	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4484	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4482	>	resultobj = PyDict_New();
4483	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4484	>	PyDict_SetItem(resultobj,
4485	>	SwigString_FromString(i->first),
4486	>	SwigString_FromString(i->second));
4487	>	}
4488		}
4489		return resultobj;
4490		fail:
#	Line 4410 | Line 4707 | static PyObject *_wrap_BossTask_programs
4707		}
4708
4709
4413	–	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4414	–	PyObject *resultobj;
4415	–	BossTask *arg1 = (BossTask *) 0 ;
4416	–	BossJob *arg2 = (BossJob *) 0 ;
4417	–	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4418	–	PyObject * obj0 = 0 ;
4419	–	PyObject * obj1 = 0 ;
4420	–
4421	–	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4422	–	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4423	–	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4424	–	{
4425	–	try {
4426	–	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4427	–
4428	–	}catch (const BossSchedFailure & e) {
4429	–	PyErr_SetString ( SchedulerError, e.what() );
4430	–	return NULL;
4431	–	}catch (const std::exception& e) {
4432	–	PyErr_SetString ( BossError, e.what() );
4433	–	return NULL;
4434	–	}
4435	–	}
4436	–	{
4437	–	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4438	–	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4439	–	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4440	–	}
4441	–	return resultobj;
4442	–	fail:
4443	–	return NULL;
4444	–	}
4445	–
4446	–
4710		static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4711		PyObject *resultobj;
4712		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5091 | Line 5354 | static PyObject *_wrap_BossTask_load(PyO
5354		}
5355
5356
5357	+	static PyObject *_wrap_BossTask_schedulerQuery(PyObject *self, PyObject *args) {
5358	+	PyObject *resultobj;
5359	+	BossTask *arg1 = (BossTask *) 0 ;
5360	+	int arg2 = (int) SCHEDULED ;
5361	+	std::string const &arg3_defvalue = "all" ;
5362	+	std::string *arg3 = (std::string *) &arg3_defvalue ;
5363	+	std::string const &arg4_defvalue = "" ;
5364	+	std::string *arg4 = (std::string *) &arg4_defvalue ;
5365	+	std::string arg5 = (std::string) "" ;
5366	+	std::string arg6 = (std::string) "" ;
5367	+	std::string arg7 = (std::string) "" ;
5368	+	std::string arg8 = (std::string) "" ;
5369	+	unsigned int arg9 = (unsigned int) 0 ;
5370	+	int result;
5371	+	std::string temp3 ;
5372	+	std::string temp4 ;
5373	+	PyObject * obj0 = 0 ;
5374	+	PyObject * obj2 = 0 ;
5375	+	PyObject * obj3 = 0 ;
5376	+	PyObject * obj4 = 0 ;
5377	+	PyObject * obj5 = 0 ;
5378	+	PyObject * obj6 = 0 ;
5379	+	PyObject * obj7 = 0 ;
5380	+	PyObject * obj8 = 0 ;
5381	+
5382	+	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5383	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5384	+	if (obj2) {
5385	+	{
5386	+	if (PyString_Check(obj2)) {
5387	+	temp3 = std::string(PyString_AsString(obj2));
5388	+	arg3 = &temp3;
5389	+	}else {
5390	+	SWIG_exception(SWIG_TypeError, "string expected");
5391	+	}
5392	+	}
5393	+	}
5394	+	if (obj3) {
5395	+	{
5396	+	if (PyString_Check(obj3)) {
5397	+	temp4 = std::string(PyString_AsString(obj3));
5398	+	arg4 = &temp4;
5399	+	}else {
5400	+	SWIG_exception(SWIG_TypeError, "string expected");
5401	+	}
5402	+	}
5403	+	}
5404	+	if (obj4) {
5405	+	{
5406	+	if (PyString_Check(obj4))
5407	+	arg5 = std::string(PyString_AsString(obj4));
5408	+	else
5409	+	SWIG_exception(SWIG_TypeError, "string expected");
5410	+	}
5411	+	}
5412	+	if (obj5) {
5413	+	{
5414	+	if (PyString_Check(obj5))
5415	+	arg6 = std::string(PyString_AsString(obj5));
5416	+	else
5417	+	SWIG_exception(SWIG_TypeError, "string expected");
5418	+	}
5419	+	}
5420	+	if (obj6) {
5421	+	{
5422	+	if (PyString_Check(obj6))
5423	+	arg7 = std::string(PyString_AsString(obj6));
5424	+	else
5425	+	SWIG_exception(SWIG_TypeError, "string expected");
5426	+	}
5427	+	}
5428	+	if (obj7) {
5429	+	{
5430	+	if (PyString_Check(obj7))
5431	+	arg8 = std::string(PyString_AsString(obj7));
5432	+	else
5433	+	SWIG_exception(SWIG_TypeError, "string expected");
5434	+	}
5435	+	}
5436	+	if (obj8) {
5437	+	arg9 = (unsigned int) PyInt_AsLong(obj8);
5438	+	if (PyErr_Occurred()) SWIG_fail;
5439	+	}
5440	+	{
5441	+	try {
5442	+	result = (int)(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5443	+
5444	+	}catch (const BossSchedFailure & e) {
5445	+	PyErr_SetString ( SchedulerError, e.what() );
5446	+	return NULL;
5447	+	}catch (const std::exception& e) {
5448	+	PyErr_SetString ( BossError, e.what() );
5449	+	return NULL;
5450	+	}
5451	+	}
5452	+	resultobj = PyInt_FromLong((long)result);
5453	+	return resultobj;
5454	+	fail:
5455	+	return NULL;
5456	+	}
5457	+
5458	+
5459		static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
5460		PyObject *resultobj;
5461		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5326 | Line 5691 | static PyObject *_wrap_BossTask_appendTo
5691		static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5692		PyObject *resultobj;
5693		BossTask *arg1 = (BossTask *) 0 ;
5694	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5694	>	BossJob *arg2 = (BossJob *) 0 ;
5695		PyObject *arg3 = (PyObject *) 0 ;
5696		PyObject * obj0 = 0 ;
5697		PyObject * obj1 = 0 ;
#	Line 5334 | Line 5699 | static PyObject *_wrap_BossTask_jobDict(
5699
5700		if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5701		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5702	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5338	<	if (arg2 == NULL) {
5339	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5340	<	}
5702	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5703		arg3 = obj2;
5704		{
5705		try {
5706	<	BossTask_jobDict((BossTask const *)arg1,*arg2,arg3);
5706	>	BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5707
5708		}catch (const BossSchedFailure & e) {
5709		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5385 | Line 5747 | static PyObject *_wrap_BossTask_jobsDict
5747		}
5748
5749
5750	+	static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5751	+	PyObject *resultobj;
5752	+	BossTask *arg1 = (BossTask *) 0 ;
5753	+	std::string *arg2 = 0 ;
5754	+	PyObject *result;
5755	+	std::string temp2 ;
5756	+	PyObject * obj0 = 0 ;
5757	+	PyObject * obj1 = 0 ;
5758	+
5759	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5760	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5761	+	{
5762	+	if (PyString_Check(obj1)) {
5763	+	temp2 = std::string(PyString_AsString(obj1));
5764	+	arg2 = &temp2;
5765	+	}else {
5766	+	SWIG_exception(SWIG_TypeError, "string expected");
5767	+	}
5768	+	}
5769	+	{
5770	+	try {
5771	+	result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5772	+
5773	+	}catch (const BossSchedFailure & e) {
5774	+	PyErr_SetString ( SchedulerError, e.what() );
5775	+	return NULL;
5776	+	}catch (const std::exception& e) {
5777	+	PyErr_SetString ( BossError, e.what() );
5778	+	return NULL;
5779	+	}
5780	+	}
5781	+	resultobj = result;
5782	+	return resultobj;
5783	+	fail:
5784	+	return NULL;
5785	+	}
5786	+
5787	+
5788	+	static PyObject *_wrap_BossTask_Chain(PyObject *self, PyObject *args) {
5789	+	PyObject *resultobj;
5790	+	BossTask *arg1 = (BossTask *) 0 ;
5791	+	std::string *arg2 = 0 ;
5792	+	PyObject *result;
5793	+	std::string temp2 ;
5794	+	PyObject * obj0 = 0 ;
5795	+	PyObject * obj1 = 0 ;
5796	+
5797	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_Chain",&obj0,&obj1)) goto fail;
5798	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5799	+	{
5800	+	if (PyString_Check(obj1)) {
5801	+	temp2 = std::string(PyString_AsString(obj1));
5802	+	arg2 = &temp2;
5803	+	}else {
5804	+	SWIG_exception(SWIG_TypeError, "string expected");
5805	+	}
5806	+	}
5807	+	{
5808	+	try {
5809	+	result = (PyObject *)BossTask_Chain(arg1,(std::string const &)*arg2);
5810	+
5811	+	}catch (const BossSchedFailure & e) {
5812	+	PyErr_SetString ( SchedulerError, e.what() );
5813	+	return NULL;
5814	+	}catch (const std::exception& e) {
5815	+	PyErr_SetString ( BossError, e.what() );
5816	+	return NULL;
5817	+	}
5818	+	}
5819	+	resultobj = result;
5820	+	return resultobj;
5821	+	fail:
5822	+	return NULL;
5823	+	}
5824	+
5825	+
5826	+	static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5827	+	PyObject *resultobj;
5828	+	BossTask *arg1 = (BossTask *) 0 ;
5829	+	PyObject *result;
5830	+	PyObject * obj0 = 0 ;
5831	+
5832	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5833	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5834	+	{
5835	+	try {
5836	+	result = (PyObject *)BossTask_jobStates(arg1);
5837	+
5838	+	}catch (const BossSchedFailure & e) {
5839	+	PyErr_SetString ( SchedulerError, e.what() );
5840	+	return NULL;
5841	+	}catch (const std::exception& e) {
5842	+	PyErr_SetString ( BossError, e.what() );
5843	+	return NULL;
5844	+	}
5845	+	}
5846	+	resultobj = result;
5847	+	return resultobj;
5848	+	fail:
5849	+	return NULL;
5850	+	}
5851	+
5852	+
5853	+	static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5854	+	PyObject *resultobj;
5855	+	BossTask *arg1 = (BossTask *) 0 ;
5856	+	PyObject *result;
5857	+	PyObject * obj0 = 0 ;
5858	+
5859	+	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5860	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5861	+	{
5862	+	try {
5863	+	result = (PyObject *)BossTask_jobStatistic(arg1);
5864	+
5865	+	}catch (const BossSchedFailure & e) {
5866	+	PyErr_SetString ( SchedulerError, e.what() );
5867	+	return NULL;
5868	+	}catch (const std::exception& e) {
5869	+	PyErr_SetString ( BossError, e.what() );
5870	+	return NULL;
5871	+	}
5872	+	}
5873	+	resultobj = result;
5874	+	return resultobj;
5875	+	fail:
5876	+	return NULL;
5877	+	}
5878	+
5879	+
5880		static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5881		PyObject *resultobj;
5882		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5456 | Line 5948 | static PyObject *_wrap_BossTask_jobProgr
5948		}
5949
5950
5951	+	static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5952	+	PyObject *resultobj;
5953	+	BossTask *arg1 = (BossTask *) 0 ;
5954	+	std::string *arg2 = 0 ;
5955	+	std::string *arg3 = 0 ;
5956	+	PyObject *result;
5957	+	std::string temp2 ;
5958	+	std::string temp3 ;
5959	+	PyObject * obj0 = 0 ;
5960	+	PyObject * obj1 = 0 ;
5961	+	PyObject * obj2 = 0 ;
5962	+
5963	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5964	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5965	+	{
5966	+	if (PyString_Check(obj1)) {
5967	+	temp2 = std::string(PyString_AsString(obj1));
5968	+	arg2 = &temp2;
5969	+	}else {
5970	+	SWIG_exception(SWIG_TypeError, "string expected");
5971	+	}
5972	+	}
5973	+	{
5974	+	if (PyString_Check(obj2)) {
5975	+	temp3 = std::string(PyString_AsString(obj2));
5976	+	arg3 = &temp3;
5977	+	}else {
5978	+	SWIG_exception(SWIG_TypeError, "string expected");
5979	+	}
5980	+	}
5981	+	{
5982	+	try {
5983	+	result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5984	+
5985	+	}catch (const BossSchedFailure & e) {
5986	+	PyErr_SetString ( SchedulerError, e.what() );
5987	+	return NULL;
5988	+	}catch (const std::exception& e) {
5989	+	PyErr_SetString ( BossError, e.what() );
5990	+	return NULL;
5991	+	}
5992	+	}
5993	+	resultobj = result;
5994	+	return resultobj;
5995	+	fail:
5996	+	return NULL;
5997	+	}
5998	+
5999	+
6000	+	static PyObject *_wrap_BossTask_programExec(PyObject *self, PyObject *args) {
6001	+	PyObject *resultobj;
6002	+	BossTask *arg1 = (BossTask *) 0 ;
6003	+	std::string *arg2 = 0 ;
6004	+	std::string *arg3 = 0 ;
6005	+	PyObject *result;
6006	+	std::string temp2 ;
6007	+	std::string temp3 ;
6008	+	PyObject * obj0 = 0 ;
6009	+	PyObject * obj1 = 0 ;
6010	+	PyObject * obj2 = 0 ;
6011	+
6012	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
6013	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6014	+	{
6015	+	if (PyString_Check(obj1)) {
6016	+	temp2 = std::string(PyString_AsString(obj1));
6017	+	arg2 = &temp2;
6018	+	}else {
6019	+	SWIG_exception(SWIG_TypeError, "string expected");
6020	+	}
6021	+	}
6022	+	{
6023	+	if (PyString_Check(obj2)) {
6024	+	temp3 = std::string(PyString_AsString(obj2));
6025	+	arg3 = &temp3;
6026	+	}else {
6027	+	SWIG_exception(SWIG_TypeError, "string expected");
6028	+	}
6029	+	}
6030	+	{
6031	+	try {
6032	+	result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
6033	+
6034	+	}catch (const BossSchedFailure & e) {
6035	+	PyErr_SetString ( SchedulerError, e.what() );
6036	+	return NULL;
6037	+	}catch (const std::exception& e) {
6038	+	PyErr_SetString ( BossError, e.what() );
6039	+	return NULL;
6040	+	}
6041	+	}
6042	+	resultobj = result;
6043	+	return resultobj;
6044	+	fail:
6045	+	return NULL;
6046	+	}
6047	+
6048	+
6049	+	static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
6050	+	PyObject *resultobj;
6051	+	BossTask *arg1 = (BossTask *) 0 ;
6052	+	std::string *arg2 = 0 ;
6053	+	std::string *arg3 = 0 ;
6054	+	PyObject *result;
6055	+	std::string temp2 ;
6056	+	std::string temp3 ;
6057	+	PyObject * obj0 = 0 ;
6058	+	PyObject * obj1 = 0 ;
6059	+	PyObject * obj2 = 0 ;
6060	+
6061	+	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
6062	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6063	+	{
6064	+	if (PyString_Check(obj1)) {
6065	+	temp2 = std::string(PyString_AsString(obj1));
6066	+	arg2 = &temp2;
6067	+	}else {
6068	+	SWIG_exception(SWIG_TypeError, "string expected");
6069	+	}
6070	+	}
6071	+	{
6072	+	if (PyString_Check(obj2)) {
6073	+	temp3 = std::string(PyString_AsString(obj2));
6074	+	arg3 = &temp3;
6075	+	}else {
6076	+	SWIG_exception(SWIG_TypeError, "string expected");
6077	+	}
6078	+	}
6079	+	{
6080	+	try {
6081	+	result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
6082	+
6083	+	}catch (const BossSchedFailure & e) {
6084	+	PyErr_SetString ( SchedulerError, e.what() );
6085	+	return NULL;
6086	+	}catch (const std::exception& e) {
6087	+	PyErr_SetString ( BossError, e.what() );
6088	+	return NULL;
6089	+	}
6090	+	}
6091	+	resultobj = result;
6092	+	return resultobj;
6093	+	fail:
6094	+	return NULL;
6095	+	}
6096	+
6097	+
6098		static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
6099		PyObject *obj;
6100		if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
#	Line 6438 | Line 7077 | static PyMethodDef SwigMethods[] = {
7077		{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
7078		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
7079		{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
7080	+	{ (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
7081	+	{ (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
7082	+	{ (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
7083		{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7084		{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7085		{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
#	Line 6446 | Line 7088 | static PyMethodDef SwigMethods[] = {
7088		{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7089		{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7090		{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6449	–	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6450	–	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
7091		{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
6452	–	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
7092		{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7093		{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7094	+	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7095	+	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7096	+	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7097	+	{ (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7098	+	{ (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
7099		{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
7100		{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
7101		{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
7102		{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
7103	+	{ (char *)"BossTask_chain", _wrap_BossTask_chain, METH_VARARGS },
7104		{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6460	–	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6461	–	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7105		{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
7106		{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
7107		{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6465	–	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7108		{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
7109		{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
7110		{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
#	Line 6472 | Line 7114 | static PyMethodDef SwigMethods[] = {
7114		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
7115		{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
7116		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
7117	+	{ (char *)"BossTask_schedulerQuery", _wrap_BossTask_schedulerQuery, METH_VARARGS },
7118		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
7119		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
7120		{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
7121		{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
7122		{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
7123		{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
7124	+	{ (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7125	+	{ (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7126	+	{ (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7127	+	{ (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7128		{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7129		{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
7130	+	{ (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
7131	+	{ (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
7132	+	{ (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
7133		{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
7134		{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
7135		{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
#	Line 6504 | Line 7154 | static PyMethodDef SwigMethods[] = {
7154
7155		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
7156
6507	–	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7157		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}};
7158	+	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7159		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}};
7160	+	static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
7161		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}};
7162	+	static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7163		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}};
6512	–	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7164		static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
7165		static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
7166	+	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
7167	+	static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
7168		static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
7169		static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
7170		static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
#	Line 6520 | Line 7173 | static swig_type_info _swigt__p_BossSess
7173		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}};
7174		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}};
7175		static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
6523	–	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}};
7176		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}};
7177	+	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}};
7178		static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7179
7180		static swig_type_info *swig_types_initial[] = {
6528	–	_swigt__p_XMLDoc,
7181		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
7182	+	_swigt__p_XMLDoc,
7183		_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7184	+	_swigt__p_BossProgramExec,
7185		_swigt__p_std__vectorTBossTask_p_t,
7186	+	_swigt__p_BossChain,
7187		_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6533	–	_swigt__p_std__ostream,
7188		_swigt__p_BossTask,
7189		_swigt__p_BossTaskException,
7190	+	_swigt__p_std__ostream,
7191	+	_swigt__p_BossProgram,
7192		_swigt__p_printOption,
7193		_swigt__p_BossAttributeContainer,
7194		_swigt__p_BossJob,
#	Line 6541 | Line 7197 | _swigt__p_BossSession,
7197		_swigt__p_std__vectorTstd__string_t,
7198		_swigt__p_std__mapTstd__string_std__string_t,
7199		_swigt__p_BossAdministratorSession,
6544	–	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7200		_swigt__p_BossTask__job_iterator,
7201	+	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
7202		_swigt__p_jobStates,
7203		0
7204		};

Diff Legend

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