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.23 by gcodispo, Fri Mar 2 13:06:44 2007 UTC vs.
Revision 1.27 by gcodispo, Thu Mar 8 17:52:39 2007 UTC

#	Line 966 | Line 966 | PyObject *BossSession_schedListMatch(Bos
966		timeout);
967		return BossSession_show( self, my_vec );
968		}
969	<	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){
970	<	if ( !avoidCheck ) {
971	<	self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
972	<	type, user, after, before, timeout );
973	<	}
974	<	PyObject * job_dict = PyList_New(0);
975	<	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() ) );
969	>	PyObject *BossSession_queryTasks(BossSession *self,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
970	>	PyObject * task_list = PyList_New(0);
971	>	std::vector <std::string> taskList;
972	>	if ( taskName.empty() ) {
973	>	taskList = self->selectTasks( taskRange, before, after, user);
974	>	} else {
975	>	taskList = self->selectTasksByName( taskName );
976		}
977	<	return  job_dict;
978	<	}
979	<	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	<
990	<	PyDict_SetItemString( dict, it->first.name().c_str(), PyString_FromString(it->second.value().c_str()) );
977	>	for ( std::vector <std::string>::const_iterator it= taskList.begin();
978	>	it!= taskList.end(); ++it ) {
979	>	PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
980		}
981	<	return dict;
981	>	return  task_list;
982		}
983	<	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
983	>	void 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	>
989	>	PyObject * key = PyString_FromString( (it->first.name()).c_str() );
990	>	PyObject * val = PyString_FromString( (*it).second.value ().c_str() );
991	>	PyDict_SetItem( dict, key, val);
992	>	Py_DECREF(key);
993	>	Py_DECREF(val);
994	>	}
995	>	return;
996	>	}
997	>	void BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit,PyObject *job_dict){
998
999	<	PyObject * job_dict = PyDict_New();
999	>	//    PyObject * job_dict = PyDict_New();
1000		std::string tmp;
1001
1002		BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1003	<	job_dict = BossTask_appendToPyDict ( self, job_dict, obj );
1003	>	BossTask_appendToPyDict ( self, job_dict, obj );
1004
1005		std::set<std::string> sch = (*jit)->getSchedulerElements();
1006		std::set<std::string>::const_iterator sch_end =  sch.end();
1007		for (std::set<std::string>::const_iterator it =sch.begin();
1008		it != sch_end; ++ it ) {
1009	<	unsigned int size = it->size() +1;
1007	<	char * key = new char[ size ];
1008	<	strncpy( key, tmp.c_str(), size );
1009	>
1010		tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1011	<	PyDict_SetItemString( job_dict, key,
1012	<	PyString_FromString( tmp.c_str() ) );
1013	<	delete [] key;
1011	>	PyObject * key = PyString_FromString( it->c_str() );
1012	>	PyObject * val = PyString_FromString( tmp.c_str() );
1013	>	PyDict_SetItem( job_dict, key, val);
1014	>	Py_DECREF(key);
1015	>	Py_DECREF(val);
1016		}
1017	<	return job_dict;
1017	>	return;
1018		}
1019		PyObject *BossTask_jobsDict(BossTask *self){
1020
#	Line 1019 | Line 1022 | PyObject *BossTask_jobsDict(BossTask *se
1022		if ( self->job_begin () == self->job_end ()) self->load(ALL);
1023		for (BossTask::job_iterator jit = self->job_begin ();
1024		jit != self->job_end (); ++jit) {
1025	<	std::string id = (*jit)->chainId();
1026	<	PyObject * tmp =  BossTask_jobDict( self, jit );
1027	<	PyObject * myid =  PyString_FromString(id.c_str() );
1028	<	PyDict_SetItem( job_dict, myid,tmp );
1025	>	PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1026	>	PyObject * tmp_dict = PyDict_New();
1027	>	BossTask_jobDict( self, jit, tmp_dict );
1028	>	PyDict_SetItem( job_dict, id, tmp_dict );
1029	>	Py_DECREF(id);
1030	>	Py_DECREF(tmp_dict);
1031		}
1032		return job_dict;
1033		}
#	Line 1067 | Line 1072 | PyObject *BossTask_jobPrograms(BossTask
1072		for ( programs_it = programs.begin(); programs_it != programs_it_end;
1073		++programs_it  ) {
1074		std::string id = (programs_it->first)["PROGRAM.ID"];
1075	<	PyObject * tmp =  BossTask_progDict( self, programs_it );
1075	>	PyObject * tmp_dict =  BossTask_progDict( self, programs_it );
1076		PyObject * myid =  PyString_FromString(id.c_str() );
1077	<	PyDict_SetItem( job_dict, myid,tmp );
1077	>	PyDict_SetItem( job_dict, myid, tmp_dict );
1078	>	Py_DECREF(myid);
1079	>	Py_DECREF(tmp_dict);
1080		}
1081		return job_dict;
1082		}
#	Line 3183 | Line 3190 | static PyObject *_wrap_BossSession_selec
3190		}
3191
3192
3193	+	static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
3194	+	PyObject *resultobj;
3195	+	BossSession *arg1 = (BossSession *) 0 ;
3196	+	std::string *arg2 = 0 ;
3197	+	std::vector<std::string > result;
3198	+	std::string temp2 ;
3199	+	PyObject * obj0 = 0 ;
3200	+	PyObject * obj1 = 0 ;
3201	+
3202	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3203	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3204	+	{
3205	+	if (PyString_Check(obj1)) {
3206	+	temp2 = std::string(PyString_AsString(obj1));
3207	+	arg2 = &temp2;
3208	+	}else {
3209	+	SWIG_exception(SWIG_TypeError, "string expected");
3210	+	}
3211	+	}
3212	+	{
3213	+	try {
3214	+	result = (arg1)->selectTasksByName((std::string const &)*arg2);
3215	+
3216	+	}catch (const BossSchedFailure & e) {
3217	+	PyErr_SetString ( SchedulerError, e.what() );
3218	+	return NULL;
3219	+	}catch (const std::exception& e) {
3220	+	PyErr_SetString ( BossError, e.what() );
3221	+	return NULL;
3222	+	}
3223	+	}
3224	+	{
3225	+	resultobj = PyTuple_New((&result)->size());
3226	+	for (unsigned int i=0; i<(&result)->size(); i++)
3227	+	PyTuple_SetItem(resultobj,i,
3228	+	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3229	+	}
3230	+	return resultobj;
3231	+	fail:
3232	+	return NULL;
3233	+	}
3234	+
3235	+
3236		static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3237		PyObject *resultobj;
3238		BossSession *arg1 = (BossSession *) 0 ;
#	Line 3309 | Line 3359 | static PyObject *_wrap_BossSession_query
3359		}
3360
3361
3362	+	static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3363	+	PyObject *resultobj;
3364	+	BossSession *arg1 = (BossSession *) 0 ;
3365	+	std::string *arg2 = 0 ;
3366	+	SwigValueWrapper< std::vector<BossTask * > > result;
3367	+	std::string temp2 ;
3368	+	PyObject * obj0 = 0 ;
3369	+	PyObject * obj1 = 0 ;
3370	+
3371	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3372	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3373	+	{
3374	+	if (PyString_Check(obj1)) {
3375	+	temp2 = std::string(PyString_AsString(obj1));
3376	+	arg2 = &temp2;
3377	+	}else {
3378	+	SWIG_exception(SWIG_TypeError, "string expected");
3379	+	}
3380	+	}
3381	+	{
3382	+	try {
3383	+	result = (arg1)->getTasksByName((std::string const &)*arg2);
3384	+
3385	+	}catch (const BossSchedFailure & e) {
3386	+	PyErr_SetString ( SchedulerError, e.what() );
3387	+	return NULL;
3388	+	}catch (const std::exception& e) {
3389	+	PyErr_SetString ( BossError, e.what() );
3390	+	return NULL;
3391	+	}
3392	+	}
3393	+	{
3394	+	std::vector<BossTask * > * resultptr;
3395	+	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3396	+	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3397	+	}
3398	+	return resultobj;
3399	+	fail:
3400	+	return NULL;
3401	+	}
3402	+
3403	+
3404		static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3405		PyObject *resultobj;
3406		BossSession *arg1 = (BossSession *) 0 ;
#	Line 3542 | Line 3634 | static PyObject *_wrap_BossSession_sched
3634		static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3635		PyObject *resultobj;
3636		BossSession *arg1 = (BossSession *) 0 ;
3637	<	int arg2 = (int) SCHEDULED ;
3637	>	std::string const &arg2_defvalue = "" ;
3638	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3639		std::string const &arg3_defvalue = "all" ;
3640		std::string *arg3 = (std::string *) &arg3_defvalue ;
3641	<	std::string const &arg4_defvalue = "all" ;
3642	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
3550	<	std::string const &arg5_defvalue = "" ;
3551	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
3641	>	std::string arg4 = (std::string) "" ;
3642	>	std::string arg5 = (std::string) "" ;
3643		std::string arg6 = (std::string) "" ;
3553	–	std::string arg7 = (std::string) "" ;
3554	–	std::string arg8 = (std::string) "" ;
3555	–	std::string arg9 = (std::string) "" ;
3556	–	unsigned int arg10 = (unsigned int) 0 ;
3557	–	bool arg11 = (bool) false ;
3644		PyObject *result;
3645	+	std::string temp2 ;
3646		std::string temp3 ;
3560	–	std::string temp4 ;
3561	–	std::string temp5 ;
3647		PyObject * obj0 = 0 ;
3648	+	PyObject * obj1 = 0 ;
3649		PyObject * obj2 = 0 ;
3650		PyObject * obj3 = 0 ;
3651		PyObject * obj4 = 0 ;
3652		PyObject * obj5 = 0 ;
3567	–	PyObject * obj6 = 0 ;
3568	–	PyObject * obj7 = 0 ;
3569	–	PyObject * obj8 = 0 ;
3570	–	PyObject * obj9 = 0 ;
3571	–	PyObject * obj10 = 0 ;
3653
3654	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3654	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3655		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3656	<	if (obj2) {
3576	<	{
3577	<	if (PyString_Check(obj2)) {
3578	<	temp3 = std::string(PyString_AsString(obj2));
3579	<	arg3 = &temp3;
3580	<	}else {
3581	<	SWIG_exception(SWIG_TypeError, "string expected");
3582	<	}
3583	<	}
3584	<	}
3585	<	if (obj3) {
3656	>	if (obj1) {
3657		{
3658	<	if (PyString_Check(obj3)) {
3659	<	temp4 = std::string(PyString_AsString(obj3));
3660	<	arg4 = &temp4;
3658	>	if (PyString_Check(obj1)) {
3659	>	temp2 = std::string(PyString_AsString(obj1));
3660	>	arg2 = &temp2;
3661		}else {
3662		SWIG_exception(SWIG_TypeError, "string expected");
3663		}
3664		}
3665		}
3666	<	if (obj4) {
3666	>	if (obj2) {
3667		{
3668	<	if (PyString_Check(obj4)) {
3669	<	temp5 = std::string(PyString_AsString(obj4));
3670	<	arg5 = &temp5;
3668	>	if (PyString_Check(obj2)) {
3669	>	temp3 = std::string(PyString_AsString(obj2));
3670	>	arg3 = &temp3;
3671		}else {
3672		SWIG_exception(SWIG_TypeError, "string expected");
3673		}
3674		}
3675		}
3676	<	if (obj5) {
3606	<	{
3607	<	if (PyString_Check(obj5))
3608	<	arg6 = std::string(PyString_AsString(obj5));
3609	<	else
3610	<	SWIG_exception(SWIG_TypeError, "string expected");
3611	<	}
3612	<	}
3613	<	if (obj6) {
3676	>	if (obj3) {
3677		{
3678	<	if (PyString_Check(obj6))
3679	<	arg7 = std::string(PyString_AsString(obj6));
3678	>	if (PyString_Check(obj3))
3679	>	arg4 = std::string(PyString_AsString(obj3));
3680		else
3681		SWIG_exception(SWIG_TypeError, "string expected");
3682		}
3683		}
3684	<	if (obj7) {
3684	>	if (obj4) {
3685		{
3686	<	if (PyString_Check(obj7))
3687	<	arg8 = std::string(PyString_AsString(obj7));
3686	>	if (PyString_Check(obj4))
3687	>	arg5 = std::string(PyString_AsString(obj4));
3688		else
3689		SWIG_exception(SWIG_TypeError, "string expected");
3690		}
3691		}
3692	<	if (obj8) {
3692	>	if (obj5) {
3693		{
3694	<	if (PyString_Check(obj8))
3695	<	arg9 = std::string(PyString_AsString(obj8));
3694	>	if (PyString_Check(obj5))
3695	>	arg6 = std::string(PyString_AsString(obj5));
3696		else
3697		SWIG_exception(SWIG_TypeError, "string expected");
3698		}
3699		}
3637	–	if (obj9) {
3638	–	arg10 = (unsigned int) PyInt_AsLong(obj9);
3639	–	if (PyErr_Occurred()) SWIG_fail;
3640	–	}
3641	–	if (obj10) {
3642	–	arg11 = PyInt_AsLong(obj10) ? true : false;
3643	–	if (PyErr_Occurred()) SWIG_fail;
3644	–	}
3700		{
3701		try {
3702	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3702	>	result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3703
3704		}catch (const BossSchedFailure & e) {
3705		PyErr_SetString ( SchedulerError, e.what() );
#	Line 4901 | Line 4956 | static PyObject *_wrap_BossTask_getOutpu
4956		}
4957
4958
4959	+	static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
4960	+	PyObject *resultobj;
4961	+	BossTask *arg1 = (BossTask *) 0 ;
4962	+	std::string *arg2 = 0 ;
4963	+	int result;
4964	+	std::string temp2 ;
4965	+	PyObject * obj0 = 0 ;
4966	+	PyObject * obj1 = 0 ;
4967	+
4968	+	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
4969	+	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4970	+	{
4971	+	if (PyString_Check(obj1)) {
4972	+	temp2 = std::string(PyString_AsString(obj1));
4973	+	arg2 = &temp2;
4974	+	}else {
4975	+	SWIG_exception(SWIG_TypeError, "string expected");
4976	+	}
4977	+	}
4978	+	{
4979	+	try {
4980	+	result = (int)(arg1)->loadByName((std::string const &)*arg2);
4981	+
4982	+	}catch (const BossSchedFailure & e) {
4983	+	PyErr_SetString ( SchedulerError, e.what() );
4984	+	return NULL;
4985	+	}catch (const std::exception& e) {
4986	+	PyErr_SetString ( BossError, e.what() );
4987	+	return NULL;
4988	+	}
4989	+	}
4990	+	resultobj = PyInt_FromLong((long)result);
4991	+	return resultobj;
4992	+	fail:
4993	+	return NULL;
4994	+	}
4995	+
4996	+
4997		static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4998		PyObject *resultobj;
4999		BossTask *arg1 = (BossTask *) 0 ;
#	Line 5199 | Line 5292 | static PyObject *_wrap_BossTask_appendTo
5292		BossTask *arg1 = (BossTask *) 0 ;
5293		PyObject *arg2 = (PyObject *) 0 ;
5294		BossAttributeContainer *arg3 = 0 ;
5202	–	PyObject *result;
5295		PyObject * obj0 = 0 ;
5296		PyObject * obj1 = 0 ;
5297		PyObject * obj2 = 0 ;
#	Line 5213 | Line 5305 | static PyObject *_wrap_BossTask_appendTo
5305		}
5306		{
5307		try {
5308	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5308	>	BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5309
5310		}catch (const BossSchedFailure & e) {
5311		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5223 | Line 5315 | static PyObject *_wrap_BossTask_appendTo
5315		return NULL;
5316		}
5317		}
5318	<	resultobj = result;
5318	>	Py_INCREF(Py_None); resultobj = Py_None;
5319		return resultobj;
5320		fail:
5321		return NULL;
#	Line 5234 | Line 5326 | static PyObject *_wrap_BossTask_jobDict(
5326		PyObject *resultobj;
5327		BossTask *arg1 = (BossTask *) 0 ;
5328		std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5329	<	PyObject *result;
5329	>	PyObject *arg3 = (PyObject *) 0 ;
5330		PyObject * obj0 = 0 ;
5331		PyObject * obj1 = 0 ;
5332	+	PyObject * obj2 = 0 ;
5333
5334	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5334	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5335		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5336		if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5337		if (arg2 == NULL) {
5338		PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5339		}
5340	+	arg3 = obj2;
5341		{
5342		try {
5343	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5343	>	BossTask_jobDict((BossTask const *)arg1,*arg2,arg3);
5344
5345		}catch (const BossSchedFailure & e) {
5346		PyErr_SetString ( SchedulerError, e.what() );
#	Line 5256 | Line 5350 | static PyObject *_wrap_BossTask_jobDict(
5350		return NULL;
5351		}
5352		}
5353	<	resultobj = result;
5353	>	Py_INCREF(Py_None); resultobj = Py_None;
5354		return resultobj;
5355		fail:
5356		return NULL;
#	Line 6340 | Line 6434 | static PyMethodDef SwigMethods[] = {
6434		{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6435		{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6436		{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6437	+	{ (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
6438		{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6439	+	{ (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
6440		{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6441		{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6442		{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
#	Line 6373 | Line 6469 | static PyMethodDef SwigMethods[] = {
6469		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6470		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6471		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6472	+	{ (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
6473		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6474		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6475		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },

Diff Legend

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