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.23 by gcodispo, Fri Mar 2 13:06:44 2007 UTC vs.
Revision 1.33 by gcodispo, Fri Jun 8 15:49:19 2007 UTC

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

Diff Legend

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