ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/COMP/BOSS/BossPython/BossSession_wrap.cxx
(Generate patch)

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.32 by gcodispo, Fri May 18 16:10:19 2007 UTC vs.
Revision 1.37 by gcodispo, Wed Jul 18 13:53:45 2007 UTC

# Line 658 | Line 658 | SWIG_InstallConstants(PyObject *d, swig_
658   #define  SWIGTYPE_p_XMLDoc swig_types[1]
659   #define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660   #define  SWIGTYPE_p_BossProgramExec swig_types[3]
661 < #define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[4]
662 < #define  SWIGTYPE_p_BossChain swig_types[5]
663 < #define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[6]
664 < #define  SWIGTYPE_p_BossTask swig_types[7]
665 < #define  SWIGTYPE_p_BossTaskException swig_types[8]
666 < #define  SWIGTYPE_p_std__ostream swig_types[9]
667 < #define  SWIGTYPE_p_BossProgram swig_types[10]
668 < #define  SWIGTYPE_p_printOption swig_types[11]
669 < #define  SWIGTYPE_p_BossAttributeContainer swig_types[12]
670 < #define  SWIGTYPE_p_BossJob swig_types[13]
671 < #define  SWIGTYPE_p_BossDatabase swig_types[14]
672 < #define  SWIGTYPE_p_BossSession swig_types[15]
673 < #define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[16]
674 < #define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[17]
675 < #define  SWIGTYPE_p_BossAdministratorSession swig_types[18]
676 < #define  SWIGTYPE_p_BossTask__job_iterator swig_types[19]
661 > #define  SWIGTYPE_p_BossChain swig_types[4]
662 > #define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[5]
663 > #define  SWIGTYPE_p_BossTask swig_types[6]
664 > #define  SWIGTYPE_p_BossTaskException swig_types[7]
665 > #define  SWIGTYPE_p_std__ostream swig_types[8]
666 > #define  SWIGTYPE_p_BossProgram swig_types[9]
667 > #define  SWIGTYPE_p_printOption swig_types[10]
668 > #define  SWIGTYPE_p_BossAttributeContainer swig_types[11]
669 > #define  SWIGTYPE_p_BossJob swig_types[12]
670 > #define  SWIGTYPE_p_BossDatabase swig_types[13]
671 > #define  SWIGTYPE_p_BossSession swig_types[14]
672 > #define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[15]
673 > #define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[16]
674 > #define  SWIGTYPE_p_BossAdministratorSession swig_types[17]
675 > #define  SWIGTYPE_p_BossTask__job_iterator swig_types[18]
676 > #define  SWIGTYPE_p_BossSession__task_iterator swig_types[19]
677   #define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[20]
678   #define  SWIGTYPE_p_jobStates swig_types[21]
679   static swig_type_info *swig_types[23];
# Line 961 | 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,
967                                                       keepfile,
967                                                         taskid,
968                                                         jobid,
969                                                         timeout);
970      return BossSession_show( self, my_vec );
971    }
972 < PyObject *BossSession_queryTasks(BossSession *self,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
973 <      PyObject * task_list = PyList_New(0);
974 <      std::vector <std::string> taskList;
976 <      if ( taskName.empty() ) {
977 <        taskList = self->selectTasks( taskRange, before, after, user);
978 <      } else {
979 <        taskList = self->selectTasksByName( taskName );
980 <      }
981 <      for ( std::vector <std::string>::const_iterator it= taskList.begin();
982 <            it!= taskList.end(); ++it ) {
983 <        PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
984 <      }
985 <      return  task_list;
972 > void BossSession_schedulerQuery(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,unsigned int timeout,bool avoidCheck){
973 >      self->query ( filter_opt, taskRange, jobRange, subn, type, user, after, before, timeout, avoidCheck );
974 >      return;
975      }
976   void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
977      std::string tmp;
# Line 1036 | Line 1025 | PyObject *BossTask_jobsDict(BossTask *se
1025      return job_dict;
1026    }
1027   PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1028 <  
1028 >    if ( ! self->jobsInMemory() ) self->load( ALL, jobid );
1029      PyObject * job_dict = PyDict_New();
1041    self->load( ALL, jobid );
1030      BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1031      return job_dict;
1032    }
# Line 1064 | Line 1052 | PyObject *BossTask_jobStates(BossTask *s
1052      }
1053      return job_dict;
1054    }
1055 + PyObject *BossTask_joblist(BossTask *self){
1056 +    if ( self->job_begin () == self->job_end ()) self->load(ALL);
1057 +    PyObject *  job_list = PyList_New( self->jobsInMemory() );
1058 +    unsigned int index = 0;
1059 +    for (BossTask::job_iterator jit = self->job_begin ();
1060 +         jit != self->job_end (); ++jit, ++index) {
1061 +      PyList_SetItem( job_list,
1062 +                      index,
1063 +                      PyString_FromString( ( (*jit)->chainId() ).c_str() )
1064 +                      );
1065 +    }
1066 +    return job_list;
1067 +  }
1068   PyObject *BossTask_jobStatistic(BossTask *self){
1069    
1070      PyObject * job_dict = PyDict_New();
# Line 2530 | Line 2531 | static PyObject *_wrap_BossSession_clear
2531   }
2532  
2533  
2534 + static PyObject *_wrap_BossSession_task_begin(PyObject *self, PyObject *args) {
2535 +    PyObject *resultobj;
2536 +    BossSession *arg1 = (BossSession *) 0 ;
2537 +    BossSession::task_iterator result;
2538 +    PyObject * obj0 = 0 ;
2539 +    
2540 +    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_begin",&obj0)) goto fail;
2541 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2542 +    {
2543 +        try {
2544 +            result = ((BossSession const *)arg1)->task_begin();
2545 +            
2546 +        }catch (const BossSchedFailure & e) {
2547 +            PyErr_SetString ( SchedulerError, e.what() );
2548 +            return NULL;
2549 +        }catch (const std::exception& e) {
2550 +            PyErr_SetString ( BossError, e.what() );
2551 +            return NULL;
2552 +        }
2553 +    }
2554 +    {
2555 +        BossSession::task_iterator * resultptr;
2556 +        resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2557 +        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2558 +    }
2559 +    return resultobj;
2560 +    fail:
2561 +    return NULL;
2562 + }
2563 +
2564 +
2565 + static PyObject *_wrap_BossSession_task_end(PyObject *self, PyObject *args) {
2566 +    PyObject *resultobj;
2567 +    BossSession *arg1 = (BossSession *) 0 ;
2568 +    BossSession::task_iterator result;
2569 +    PyObject * obj0 = 0 ;
2570 +    
2571 +    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_task_end",&obj0)) goto fail;
2572 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2573 +    {
2574 +        try {
2575 +            result = ((BossSession const *)arg1)->task_end();
2576 +            
2577 +        }catch (const BossSchedFailure & e) {
2578 +            PyErr_SetString ( SchedulerError, e.what() );
2579 +            return NULL;
2580 +        }catch (const std::exception& e) {
2581 +            PyErr_SetString ( BossError, e.what() );
2582 +            return NULL;
2583 +        }
2584 +    }
2585 +    {
2586 +        BossSession::task_iterator * resultptr;
2587 +        resultptr = new BossSession::task_iterator((BossSession::task_iterator &) result);
2588 +        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossSession__task_iterator, 1);
2589 +    }
2590 +    return resultobj;
2591 +    fail:
2592 +    return NULL;
2593 + }
2594 +
2595 +
2596 + static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
2597 +    PyObject *resultobj;
2598 +    BossSession *arg1 = (BossSession *) 0 ;
2599 +    unsigned int result;
2600 +    PyObject * obj0 = 0 ;
2601 +    
2602 +    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
2603 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2604 +    {
2605 +        try {
2606 +            result = (unsigned int)((BossSession const *)arg1)->tasksInMemory();
2607 +            
2608 +        }catch (const BossSchedFailure & e) {
2609 +            PyErr_SetString ( SchedulerError, e.what() );
2610 +            return NULL;
2611 +        }catch (const std::exception& e) {
2612 +            PyErr_SetString ( BossError, e.what() );
2613 +            return NULL;
2614 +        }
2615 +    }
2616 +    resultobj = PyInt_FromLong((long)result);
2617 +    return resultobj;
2618 +    fail:
2619 +    return NULL;
2620 + }
2621 +
2622 +
2623 + static PyObject *_wrap_BossSession_locate(PyObject *self, PyObject *args) {
2624 +    PyObject *resultobj;
2625 +    BossSession *arg1 = (BossSession *) 0 ;
2626 +    unsigned int arg2 ;
2627 +    BossTask *result;
2628 +    PyObject * obj0 = 0 ;
2629 +    PyObject * obj1 = 0 ;
2630 +    
2631 +    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_locate",&obj0,&obj1)) goto fail;
2632 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2633 +    arg2 = (unsigned int) PyInt_AsLong(obj1);
2634 +    if (PyErr_Occurred()) SWIG_fail;
2635 +    {
2636 +        try {
2637 +            result = (BossTask *)((BossSession const *)arg1)->locate(arg2);
2638 +            
2639 +        }catch (const BossSchedFailure & e) {
2640 +            PyErr_SetString ( SchedulerError, e.what() );
2641 +            return NULL;
2642 +        }catch (const std::exception& e) {
2643 +            PyErr_SetString ( BossError, e.what() );
2644 +            return NULL;
2645 +        }
2646 +    }
2647 +    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2648 +    return resultobj;
2649 +    fail:
2650 +    return NULL;
2651 + }
2652 +
2653 +
2654   static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2655      PyObject *resultobj;
2656      BossSession *arg1 = (BossSession *) 0 ;
# Line 2997 | Line 3118 | static PyObject *_wrap_BossSession_listM
3118      BossSession *arg1 = (BossSession *) 0 ;
3119      std::string *arg2 = 0 ;
3120      std::string *arg3 = 0 ;
3121 <    bool arg4 = (bool) false ;
3121 >    std::string const &arg4_defvalue = "" ;
3122 >    std::string *arg4 = (std::string *) &arg4_defvalue ;
3123      std::string const &arg5_defvalue = "" ;
3124      std::string *arg5 = (std::string *) &arg5_defvalue ;
3125 <    std::string const &arg6_defvalue = "" ;
3004 <    std::string *arg6 = (std::string *) &arg6_defvalue ;
3005 <    unsigned int arg7 = (unsigned int) 0 ;
3125 >    unsigned int arg6 = (unsigned int) 0 ;
3126      std::vector<std::string > result;
3127      std::string temp2 ;
3128      std::string temp3 ;
3129 +    std::string temp4 ;
3130      std::string temp5 ;
3010    std::string temp6 ;
3131      PyObject * obj0 = 0 ;
3132      PyObject * obj1 = 0 ;
3133      PyObject * obj2 = 0 ;
3134      PyObject * obj3 = 0 ;
3135      PyObject * obj4 = 0 ;
3136      PyObject * obj5 = 0 ;
3017    PyObject * obj6 = 0 ;
3137      
3138 <    if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3138 >    if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3139      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3140      {
3141          if (PyString_Check(obj1)) {
# Line 3035 | Line 3154 | static PyObject *_wrap_BossSession_listM
3154          }
3155      }
3156      if (obj3) {
3038        arg4 = PyInt_AsLong(obj3) ? true : false;
3039        if (PyErr_Occurred()) SWIG_fail;
3040    }
3041    if (obj4) {
3042        {
3043            if (PyString_Check(obj4)) {
3044                temp5 = std::string(PyString_AsString(obj4));
3045                arg5 = &temp5;
3046            }else {
3047                SWIG_exception(SWIG_TypeError, "string expected");
3048            }
3049        }
3050    }
3051    if (obj5) {
3052        {
3053            if (PyString_Check(obj5)) {
3054                temp6 = std::string(PyString_AsString(obj5));
3055                arg6 = &temp6;
3056            }else {
3057                SWIG_exception(SWIG_TypeError, "string expected");
3058            }
3059        }
3060    }
3061    if (obj6) {
3062        arg7 = (unsigned int) PyInt_AsLong(obj6);
3063        if (PyErr_Occurred()) SWIG_fail;
3064    }
3065    {
3066        try {
3067            result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
3068            
3069        }catch (const BossSchedFailure & e) {
3070            PyErr_SetString ( SchedulerError, e.what() );
3071            return NULL;
3072        }catch (const std::exception& e) {
3073            PyErr_SetString ( BossError, e.what() );
3074            return NULL;
3075        }
3076    }
3077    {
3078        resultobj = PyTuple_New((&result)->size());
3079        for (unsigned int i=0; i<(&result)->size(); i++)
3080        PyTuple_SetItem(resultobj,i,
3081        SwigString_FromString(((std::vector<std::string > &)result)[i]));
3082    }
3083    return resultobj;
3084    fail:
3085    return NULL;
3086 }
3087
3088
3089 static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3090    PyObject *resultobj;
3091    BossSession *arg1 = (BossSession *) 0 ;
3092    int arg2 = (int) SCHEDULED ;
3093    std::string const &arg3_defvalue = "all" ;
3094    std::string *arg3 = (std::string *) &arg3_defvalue ;
3095    std::string const &arg4_defvalue = "all" ;
3096    std::string *arg4 = (std::string *) &arg4_defvalue ;
3097    std::string const &arg5_defvalue = "" ;
3098    std::string *arg5 = (std::string *) &arg5_defvalue ;
3099    std::string arg6 = (std::string) "" ;
3100    std::string arg7 = (std::string) "" ;
3101    std::string arg8 = (std::string) "" ;
3102    std::string arg9 = (std::string) "" ;
3103    unsigned int arg10 = (unsigned int) 0 ;
3104    std::string temp3 ;
3105    std::string temp4 ;
3106    std::string temp5 ;
3107    PyObject * obj0 = 0 ;
3108    PyObject * obj2 = 0 ;
3109    PyObject * obj3 = 0 ;
3110    PyObject * obj4 = 0 ;
3111    PyObject * obj5 = 0 ;
3112    PyObject * obj6 = 0 ;
3113    PyObject * obj7 = 0 ;
3114    PyObject * obj8 = 0 ;
3115    PyObject * obj9 = 0 ;
3116    
3117    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3118    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3119    if (obj2) {
3120        {
3121            if (PyString_Check(obj2)) {
3122                temp3 = std::string(PyString_AsString(obj2));
3123                arg3 = &temp3;
3124            }else {
3125                SWIG_exception(SWIG_TypeError, "string expected");
3126            }
3127        }
3128    }
3129    if (obj3) {
3157          {
3158              if (PyString_Check(obj3)) {
3159                  temp4 = std::string(PyString_AsString(obj3));
# Line 3147 | Line 3174 | static PyObject *_wrap_BossSession_sched
3174          }
3175      }
3176      if (obj5) {
3177 <        {
3151 <            if (PyString_Check(obj5))
3152 <            arg6 = std::string(PyString_AsString(obj5));
3153 <            else
3154 <            SWIG_exception(SWIG_TypeError, "string expected");
3155 <        }
3156 <    }
3157 <    if (obj6) {
3158 <        {
3159 <            if (PyString_Check(obj6))
3160 <            arg7 = std::string(PyString_AsString(obj6));
3161 <            else
3162 <            SWIG_exception(SWIG_TypeError, "string expected");
3163 <        }
3164 <    }
3165 <    if (obj7) {
3166 <        {
3167 <            if (PyString_Check(obj7))
3168 <            arg8 = std::string(PyString_AsString(obj7));
3169 <            else
3170 <            SWIG_exception(SWIG_TypeError, "string expected");
3171 <        }
3172 <    }
3173 <    if (obj8) {
3174 <        {
3175 <            if (PyString_Check(obj8))
3176 <            arg9 = std::string(PyString_AsString(obj8));
3177 <            else
3178 <            SWIG_exception(SWIG_TypeError, "string expected");
3179 <        }
3180 <    }
3181 <    if (obj9) {
3182 <        arg10 = (unsigned int) PyInt_AsLong(obj9);
3177 >        arg6 = (unsigned int) PyInt_AsLong(obj5);
3178          if (PyErr_Occurred()) SWIG_fail;
3179      }
3180      {
3181          try {
3182 <            (arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3188 <            
3189 <        }catch (const BossSchedFailure & e) {
3190 <            PyErr_SetString ( SchedulerError, e.what() );
3191 <            return NULL;
3192 <        }catch (const std::exception& e) {
3193 <            PyErr_SetString ( BossError, e.what() );
3194 <            return NULL;
3195 <        }
3196 <    }
3197 <    Py_INCREF(Py_None); resultobj = Py_None;
3198 <    return resultobj;
3199 <    fail:
3200 <    return NULL;
3201 < }
3202 <
3203 <
3204 < static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3205 <    PyObject *resultobj;
3206 <    BossSession *arg1 = (BossSession *) 0 ;
3207 <    std::string const &arg2_defvalue = "all" ;
3208 <    std::string *arg2 = (std::string *) &arg2_defvalue ;
3209 <    std::string const &arg3_defvalue = "" ;
3210 <    std::string *arg3 = (std::string *) &arg3_defvalue ;
3211 <    std::string const &arg4_defvalue = "" ;
3212 <    std::string *arg4 = (std::string *) &arg4_defvalue ;
3213 <    std::string const &arg5_defvalue = "" ;
3214 <    std::string *arg5 = (std::string *) &arg5_defvalue ;
3215 <    std::vector<std::string > result;
3216 <    std::string temp2 ;
3217 <    std::string temp3 ;
3218 <    std::string temp4 ;
3219 <    std::string temp5 ;
3220 <    PyObject * obj0 = 0 ;
3221 <    PyObject * obj1 = 0 ;
3222 <    PyObject * obj2 = 0 ;
3223 <    PyObject * obj3 = 0 ;
3224 <    PyObject * obj4 = 0 ;
3225 <    
3226 <    if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3227 <    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3228 <    if (obj1) {
3229 <        {
3230 <            if (PyString_Check(obj1)) {
3231 <                temp2 = std::string(PyString_AsString(obj1));
3232 <                arg2 = &temp2;
3233 <            }else {
3234 <                SWIG_exception(SWIG_TypeError, "string expected");
3235 <            }
3236 <        }
3237 <    }
3238 <    if (obj2) {
3239 <        {
3240 <            if (PyString_Check(obj2)) {
3241 <                temp3 = std::string(PyString_AsString(obj2));
3242 <                arg3 = &temp3;
3243 <            }else {
3244 <                SWIG_exception(SWIG_TypeError, "string expected");
3245 <            }
3246 <        }
3247 <    }
3248 <    if (obj3) {
3249 <        {
3250 <            if (PyString_Check(obj3)) {
3251 <                temp4 = std::string(PyString_AsString(obj3));
3252 <                arg4 = &temp4;
3253 <            }else {
3254 <                SWIG_exception(SWIG_TypeError, "string expected");
3255 <            }
3256 <        }
3257 <    }
3258 <    if (obj4) {
3259 <        {
3260 <            if (PyString_Check(obj4)) {
3261 <                temp5 = std::string(PyString_AsString(obj4));
3262 <                arg5 = &temp5;
3263 <            }else {
3264 <                SWIG_exception(SWIG_TypeError, "string expected");
3265 <            }
3266 <        }
3267 <    }
3268 <    {
3269 <        try {
3270 <            result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3271 <            
3272 <        }catch (const BossSchedFailure & e) {
3273 <            PyErr_SetString ( SchedulerError, e.what() );
3274 <            return NULL;
3275 <        }catch (const std::exception& e) {
3276 <            PyErr_SetString ( BossError, e.what() );
3277 <            return NULL;
3278 <        }
3279 <    }
3280 <    {
3281 <        resultobj = PyTuple_New((&result)->size());
3282 <        for (unsigned int i=0; i<(&result)->size(); i++)
3283 <        PyTuple_SetItem(resultobj,i,
3284 <        SwigString_FromString(((std::vector<std::string > &)result)[i]));
3285 <    }
3286 <    return resultobj;
3287 <    fail:
3288 <    return NULL;
3289 < }
3290 <
3291 <
3292 < static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
3293 <    PyObject *resultobj;
3294 <    BossSession *arg1 = (BossSession *) 0 ;
3295 <    std::string *arg2 = 0 ;
3296 <    std::vector<std::string > result;
3297 <    std::string temp2 ;
3298 <    PyObject * obj0 = 0 ;
3299 <    PyObject * obj1 = 0 ;
3300 <    
3301 <    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3302 <    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3303 <    {
3304 <        if (PyString_Check(obj1)) {
3305 <            temp2 = std::string(PyString_AsString(obj1));
3306 <            arg2 = &temp2;
3307 <        }else {
3308 <            SWIG_exception(SWIG_TypeError, "string expected");
3309 <        }
3310 <    }
3311 <    {
3312 <        try {
3313 <            result = (arg1)->selectTasksByName((std::string const &)*arg2);
3182 >            result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3183              
3184          }catch (const BossSchedFailure & e) {
3185              PyErr_SetString ( SchedulerError, e.what() );
# Line 3348 | Line 3217 | static PyObject *_wrap_BossSession_query
3217      std::string arg9 = (std::string) "" ;
3218      unsigned int arg10 = (unsigned int) 0 ;
3219      bool arg11 = (bool) false ;
3351    SwigValueWrapper< std::vector<BossTask * > > result;
3220      std::string temp3 ;
3221      std::string temp4 ;
3222      std::string temp5 ;
# Line 3437 | Line 3305 | static PyObject *_wrap_BossSession_query
3305      }
3306      {
3307          try {
3308 <            result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3308 >            (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3309              
3310          }catch (const BossSchedFailure & e) {
3311              PyErr_SetString ( SchedulerError, e.what() );
# Line 3447 | Line 3315 | static PyObject *_wrap_BossSession_query
3315              return NULL;
3316          }
3317      }
3318 <    {
3451 <        std::vector<BossTask * > * resultptr;
3452 <        resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3453 <        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3454 <    }
3318 >    Py_INCREF(Py_None); resultobj = Py_None;
3319      return resultobj;
3320      fail:
3321      return NULL;
# Line 3462 | Line 3326 | static PyObject *_wrap_BossSession_getTa
3326      PyObject *resultobj;
3327      BossSession *arg1 = (BossSession *) 0 ;
3328      std::string *arg2 = 0 ;
3329 <    SwigValueWrapper< std::vector<BossTask * > > result;
3329 >    unsigned int result;
3330      std::string temp2 ;
3331      PyObject * obj0 = 0 ;
3332      PyObject * obj1 = 0 ;
# Line 3479 | Line 3343 | static PyObject *_wrap_BossSession_getTa
3343      }
3344      {
3345          try {
3346 <            result = (arg1)->getTasksByName((std::string const &)*arg2);
3346 >            result = (unsigned int)(arg1)->getTasksByName((std::string const &)*arg2);
3347              
3348          }catch (const BossSchedFailure & e) {
3349              PyErr_SetString ( SchedulerError, e.what() );
# Line 3489 | Line 3353 | static PyObject *_wrap_BossSession_getTa
3353              return NULL;
3354          }
3355      }
3356 <    {
3493 <        std::vector<BossTask * > * resultptr;
3494 <        resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3495 <        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3496 <    }
3356 >    resultobj = PyInt_FromLong((long)result);
3357      return resultobj;
3358      fail:
3359      return NULL;
3360   }
3361  
3362  
3363 < static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3363 > static PyObject *_wrap_BossSession_getTasksByTaskInfo(PyObject *self, PyObject *args) {
3364      PyObject *resultobj;
3365      BossSession *arg1 = (BossSession *) 0 ;
3366      std::string *arg2 = 0 ;
3367 <    SwigValueWrapper< std::vector<BossTask * > > result;
3367 >    unsigned int result;
3368      std::string temp2 ;
3369      PyObject * obj0 = 0 ;
3370      PyObject * obj1 = 0 ;
3371      
3372 <    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3372 >    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByTaskInfo",&obj0,&obj1)) goto fail;
3373      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3374      {
3375          if (PyString_Check(obj1)) {
# Line 3521 | Line 3381 | static PyObject *_wrap_BossSession_getTa
3381      }
3382      {
3383          try {
3384 <            result = (arg1)->getTasksByJobName((std::string const &)*arg2);
3384 >            result = (unsigned int)(arg1)->getTasksByTaskInfo((std::string const &)*arg2);
3385              
3386          }catch (const BossSchedFailure & e) {
3387              PyErr_SetString ( SchedulerError, e.what() );
# Line 3531 | Line 3391 | static PyObject *_wrap_BossSession_getTa
3391              return NULL;
3392          }
3393      }
3394 <    {
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 <    }
3394 >    resultobj = PyInt_FromLong((long)result);
3395      return resultobj;
3396      fail:
3397      return NULL;
3398   }
3399  
3400  
3401 < static PyObject *_wrap_BossSession_tasksInMemory(PyObject *self, PyObject *args) {
3401 > static PyObject *_wrap_BossSession_getTasksByJobName(PyObject *self, PyObject *args) {
3402      PyObject *resultobj;
3403      BossSession *arg1 = (BossSession *) 0 ;
3404 +    std::string *arg2 = 0 ;
3405      unsigned int result;
3406 +    std::string temp2 ;
3407      PyObject * obj0 = 0 ;
3408 +    PyObject * obj1 = 0 ;
3409      
3410 <    if(!PyArg_ParseTuple(args,(char *)"O:BossSession_tasksInMemory",&obj0)) goto fail;
3410 >    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByJobName",&obj0,&obj1)) goto fail;
3411      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3412      {
3413 <        try {
3414 <            result = (unsigned int)(arg1)->tasksInMemory();
3415 <            
3416 <        }catch (const BossSchedFailure & e) {
3417 <            PyErr_SetString ( SchedulerError, e.what() );
3559 <            return NULL;
3560 <        }catch (const std::exception& e) {
3561 <            PyErr_SetString ( BossError, e.what() );
3562 <            return NULL;
3413 >        if (PyString_Check(obj1)) {
3414 >            temp2 = std::string(PyString_AsString(obj1));
3415 >            arg2 = &temp2;
3416 >        }else {
3417 >            SWIG_exception(SWIG_TypeError, "string expected");
3418          }
3419      }
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;
3420      {
3421          try {
3422 <            result = (BossTask *)(arg1)->locate(arg2);
3422 >            result = (unsigned int)(arg1)->getTasksByJobName((std::string const &)*arg2);
3423              
3424          }catch (const BossSchedFailure & e) {
3425              PyErr_SetString ( SchedulerError, e.what() );
# Line 3593 | Line 3429 | static PyObject *_wrap_BossSession_locat
3429              return NULL;
3430          }
3431      }
3432 <    resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
3432 >    resultobj = PyInt_FromLong((long)result);
3433      return resultobj;
3434      fail:
3435      return NULL;
# Line 3751 | Line 3587 | static PyObject *_wrap_BossSession_sched
3587      std::string const &arg5_defvalue = "" ;
3588      std::string *arg5 = (std::string *) &arg5_defvalue ;
3589      unsigned int arg6 = (unsigned int) 0 ;
3754    bool arg7 = (bool) false ;
3590      PyObject *result;
3591      std::string temp2 ;
3592      std::string temp3 ;
# Line 3763 | Line 3598 | static PyObject *_wrap_BossSession_sched
3598      PyObject * obj3 = 0 ;
3599      PyObject * obj4 = 0 ;
3600      PyObject * obj5 = 0 ;
3766    PyObject * obj6 = 0 ;
3601      
3602 <    if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3602 >    if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3603      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3604      {
3605          if (PyString_Check(obj1)) {
# Line 3807 | Line 3641 | static PyObject *_wrap_BossSession_sched
3641          arg6 = (unsigned int) PyInt_AsLong(obj5);
3642          if (PyErr_Occurred()) SWIG_fail;
3643      }
3810    if (obj6) {
3811        arg7 = PyInt_AsLong(obj6) ? true : false;
3812        if (PyErr_Occurred()) SWIG_fail;
3813    }
3644      {
3645          try {
3646 <            result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3646 >            result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3647              
3648          }catch (const BossSchedFailure & e) {
3649              PyErr_SetString ( SchedulerError, e.what() );
# Line 3830 | Line 3660 | static PyObject *_wrap_BossSession_sched
3660   }
3661  
3662  
3663 < static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3663 > static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3664      PyObject *resultobj;
3665      BossSession *arg1 = (BossSession *) 0 ;
3666 <    std::string const &arg2_defvalue = "" ;
3837 <    std::string *arg2 = (std::string *) &arg2_defvalue ;
3666 >    int arg2 = (int) SCHEDULED ;
3667      std::string const &arg3_defvalue = "all" ;
3668      std::string *arg3 = (std::string *) &arg3_defvalue ;
3669 <    std::string arg4 = (std::string) "" ;
3670 <    std::string arg5 = (std::string) "" ;
3669 >    std::string const &arg4_defvalue = "all" ;
3670 >    std::string *arg4 = (std::string *) &arg4_defvalue ;
3671 >    std::string const &arg5_defvalue = "" ;
3672 >    std::string *arg5 = (std::string *) &arg5_defvalue ;
3673      std::string arg6 = (std::string) "" ;
3674 <    PyObject *result;
3675 <    std::string temp2 ;
3674 >    std::string arg7 = (std::string) "" ;
3675 >    std::string arg8 = (std::string) "" ;
3676 >    std::string arg9 = (std::string) "" ;
3677 >    unsigned int arg10 = (unsigned int) 0 ;
3678 >    bool arg11 = (bool) false ;
3679      std::string temp3 ;
3680 +    std::string temp4 ;
3681 +    std::string temp5 ;
3682      PyObject * obj0 = 0 ;
3847    PyObject * obj1 = 0 ;
3683      PyObject * obj2 = 0 ;
3684      PyObject * obj3 = 0 ;
3685      PyObject * obj4 = 0 ;
3686      PyObject * obj5 = 0 ;
3687 +    PyObject * obj6 = 0 ;
3688 +    PyObject * obj7 = 0 ;
3689 +    PyObject * obj8 = 0 ;
3690 +    PyObject * obj9 = 0 ;
3691 +    PyObject * obj10 = 0 ;
3692      
3693 <    if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3693 >    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3694      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3695 <    if (obj1) {
3695 >    if (obj2) {
3696          {
3697 <            if (PyString_Check(obj1)) {
3698 <                temp2 = std::string(PyString_AsString(obj1));
3699 <                arg2 = &temp2;
3697 >            if (PyString_Check(obj2)) {
3698 >                temp3 = std::string(PyString_AsString(obj2));
3699 >                arg3 = &temp3;
3700              }else {
3701                  SWIG_exception(SWIG_TypeError, "string expected");
3702              }
3703          }
3704      }
3705 <    if (obj2) {
3705 >    if (obj3) {
3706          {
3707 <            if (PyString_Check(obj2)) {
3708 <                temp3 = std::string(PyString_AsString(obj2));
3709 <                arg3 = &temp3;
3707 >            if (PyString_Check(obj3)) {
3708 >                temp4 = std::string(PyString_AsString(obj3));
3709 >                arg4 = &temp4;
3710              }else {
3711                  SWIG_exception(SWIG_TypeError, "string expected");
3712              }
3713          }
3714      }
3715 <    if (obj3) {
3715 >    if (obj4) {
3716          {
3717 <            if (PyString_Check(obj3))
3718 <            arg4 = std::string(PyString_AsString(obj3));
3717 >            if (PyString_Check(obj4)) {
3718 >                temp5 = std::string(PyString_AsString(obj4));
3719 >                arg5 = &temp5;
3720 >            }else {
3721 >                SWIG_exception(SWIG_TypeError, "string expected");
3722 >            }
3723 >        }
3724 >    }
3725 >    if (obj5) {
3726 >        {
3727 >            if (PyString_Check(obj5))
3728 >            arg6 = std::string(PyString_AsString(obj5));
3729              else
3730              SWIG_exception(SWIG_TypeError, "string expected");
3731          }
3732      }
3733 <    if (obj4) {
3733 >    if (obj6) {
3734          {
3735 <            if (PyString_Check(obj4))
3736 <            arg5 = std::string(PyString_AsString(obj4));
3735 >            if (PyString_Check(obj6))
3736 >            arg7 = std::string(PyString_AsString(obj6));
3737              else
3738              SWIG_exception(SWIG_TypeError, "string expected");
3739          }
3740      }
3741 <    if (obj5) {
3741 >    if (obj7) {
3742          {
3743 <            if (PyString_Check(obj5))
3744 <            arg6 = std::string(PyString_AsString(obj5));
3743 >            if (PyString_Check(obj7))
3744 >            arg8 = std::string(PyString_AsString(obj7));
3745              else
3746              SWIG_exception(SWIG_TypeError, "string expected");
3747          }
3748      }
3749 +    if (obj8) {
3750 +        {
3751 +            if (PyString_Check(obj8))
3752 +            arg9 = std::string(PyString_AsString(obj8));
3753 +            else
3754 +            SWIG_exception(SWIG_TypeError, "string expected");
3755 +        }
3756 +    }
3757 +    if (obj9) {
3758 +        arg10 = (unsigned int) PyInt_AsLong(obj9);
3759 +        if (PyErr_Occurred()) SWIG_fail;
3760 +    }
3761 +    if (obj10) {
3762 +        arg11 = PyInt_AsLong(obj10) ? true : false;
3763 +        if (PyErr_Occurred()) SWIG_fail;
3764 +    }
3765      {
3766          try {
3767 <            result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3767 >            BossSession_schedulerQuery(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3768              
3769          }catch (const BossSchedFailure & e) {
3770              PyErr_SetString ( SchedulerError, e.what() );
# Line 3908 | Line 3774 | static PyObject *_wrap_BossSession_query
3774              return NULL;
3775          }
3776      }
3777 <    resultobj = result;
3777 >    Py_INCREF(Py_None); resultobj = Py_None;
3778      return resultobj;
3779      fail:
3780      return NULL;
# Line 4042 | Line 3908 | static PyObject *_wrap_BossTask_job_end(
3908   }
3909  
3910  
3911 + static PyObject *_wrap_BossTask_jobsInMemory(PyObject *self, PyObject *args) {
3912 +    PyObject *resultobj;
3913 +    BossTask *arg1 = (BossTask *) 0 ;
3914 +    unsigned int result;
3915 +    PyObject * obj0 = 0 ;
3916 +    
3917 +    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsInMemory",&obj0)) goto fail;
3918 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3919 +    {
3920 +        try {
3921 +            result = (unsigned int)((BossTask const *)arg1)->jobsInMemory();
3922 +            
3923 +        }catch (const BossSchedFailure & e) {
3924 +            PyErr_SetString ( SchedulerError, e.what() );
3925 +            return NULL;
3926 +        }catch (const std::exception& e) {
3927 +            PyErr_SetString ( BossError, e.what() );
3928 +            return NULL;
3929 +        }
3930 +    }
3931 +    resultobj = PyInt_FromLong((long)result);
3932 +    return resultobj;
3933 +    fail:
3934 +    return NULL;
3935 + }
3936 +
3937 +
3938   static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
3939      PyObject *resultobj;
3940      BossTask *arg1 = (BossTask *) 0 ;
# Line 5850 | Line 5743 | static PyObject *_wrap_BossTask_jobState
5743   }
5744  
5745  
5746 + static PyObject *_wrap_BossTask_joblist(PyObject *self, PyObject *args) {
5747 +    PyObject *resultobj;
5748 +    BossTask *arg1 = (BossTask *) 0 ;
5749 +    PyObject *result;
5750 +    PyObject * obj0 = 0 ;
5751 +    
5752 +    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_joblist",&obj0)) goto fail;
5753 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5754 +    {
5755 +        try {
5756 +            result = (PyObject *)BossTask_joblist(arg1);
5757 +            
5758 +        }catch (const BossSchedFailure & e) {
5759 +            PyErr_SetString ( SchedulerError, e.what() );
5760 +            return NULL;
5761 +        }catch (const std::exception& e) {
5762 +            PyErr_SetString ( BossError, e.what() );
5763 +            return NULL;
5764 +        }
5765 +    }
5766 +    resultobj = result;
5767 +    return resultobj;
5768 +    fail:
5769 +    return NULL;
5770 + }
5771 +
5772 +
5773   static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5774      PyObject *resultobj;
5775      BossTask *arg1 = (BossTask *) 0 ;
# Line 7057 | Line 6977 | static PyMethodDef SwigMethods[] = {
6977           { (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6978           { (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6979           { (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6980 +         { (char *)"BossSession_task_begin", _wrap_BossSession_task_begin, METH_VARARGS },
6981 +         { (char *)"BossSession_task_end", _wrap_BossSession_task_end, METH_VARARGS },
6982 +         { (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
6983 +         { (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
6984           { (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6985           { (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6986           { (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
# Line 7072 | Line 6996 | static PyMethodDef SwigMethods[] = {
6996           { (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
6997           { (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6998           { (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
7075         { (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7076         { (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
7077         { (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
6999           { (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
7000           { (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
7001 +         { (char *)"BossSession_getTasksByTaskInfo", _wrap_BossSession_getTasksByTaskInfo, METH_VARARGS },
7002           { (char *)"BossSession_getTasksByJobName", _wrap_BossSession_getTasksByJobName, METH_VARARGS },
7081         { (char *)"BossSession_tasksInMemory", _wrap_BossSession_tasksInMemory, METH_VARARGS },
7082         { (char *)"BossSession_locate", _wrap_BossSession_locate, METH_VARARGS },
7003           { (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
7004           { (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
7005           { (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
7006           { (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
7007           { (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
7008           { (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
7009 <         { (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
7009 >         { (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
7010           { (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
7011           { (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
7012           { (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
7013           { (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
7014           { (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
7015           { (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
7016 +         { (char *)"BossTask_jobsInMemory", _wrap_BossTask_jobsInMemory, METH_VARARGS },
7017           { (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
7018           { (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
7019           { (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
# Line 7124 | Line 7045 | static PyMethodDef SwigMethods[] = {
7045           { (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
7046           { (char *)"BossTask_Chain", _wrap_BossTask_Chain, METH_VARARGS },
7047           { (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
7048 +         { (char *)"BossTask_joblist", _wrap_BossTask_joblist, METH_VARARGS },
7049           { (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
7050           { (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
7051           { (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
# Line 7158 | Line 7080 | static swig_type_info _swigt__p_std__vec
7080   static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
7081   static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator[] = {{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator", 0, "std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *", 0},{"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator"},{0}};
7082   static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
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}};
7083   static swig_type_info _swigt__p_BossChain[] = {{"_p_BossChain", 0, "BossChain *", 0},{"_p_BossChain"},{0}};
7084   static swig_type_info _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t[] = {{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t", 0, "std::map<std::string,std::map<std::string,std::string > > *", 0},{"_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t"},{0}};
7085   static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
# Line 7174 | Line 7095 | static swig_type_info _swigt__p_std__vec
7095   static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
7096   static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
7097   static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
7098 + static swig_type_info _swigt__p_BossSession__task_iterator[] = {{"_p_BossSession__task_iterator", 0, "BossSession::task_iterator const *", 0},{"_p_BossSession__task_iterator"},{0}};
7099   static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
7100   static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
7101  
# Line 7182 | Line 7104 | _swigt__p_std__vectorTstd__pairTBossProg
7104   _swigt__p_XMLDoc,
7105   _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
7106   _swigt__p_BossProgramExec,
7185 _swigt__p_std__vectorTBossTask_p_t,
7107   _swigt__p_BossChain,
7108   _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
7109   _swigt__p_BossTask,
# Line 7198 | Line 7119 | _swigt__p_std__vectorTstd__string_t,
7119   _swigt__p_std__mapTstd__string_std__string_t,
7120   _swigt__p_BossAdministratorSession,
7121   _swigt__p_BossTask__job_iterator,
7122 + _swigt__p_BossSession__task_iterator,
7123   _swigt__p_std__vectorTBossJob_p_t__const_iterator,
7124   _swigt__p_jobStates,
7125   0

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines