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.25 by gcodispo, Mon Mar 5 08:07:03 2007 UTC vs.
Revision 1.29 by gcodispo, Fri Mar 9 15:40:00 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]
660 > #define  SWIGTYPE_p_BossProgramExec swig_types[3]
661 > #define  SWIGTYPE_p_std__vectorTBossTask_p_t 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_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];
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_std__vectorTBossJob_p_t__const_iterator swig_types[18]
676 > #define  SWIGTYPE_p_BossTask__job_iterator swig_types[19]
677 > #define  SWIGTYPE_p_jobStates swig_types[20]
678 > static swig_type_info *swig_types[22];
679  
680   /* -------- TYPES TABLE (END) -------- */
681  
# Line 966 | Line 968 | PyObject *BossSession_schedListMatch(Bos
968                                                         timeout);
969      return BossSession_show( self, my_vec );
970    }
971 < 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){
972 <      if ( !avoidCheck ) {
973 <        self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
974 <                               type, user, after, before, timeout );
973 <      }
974 <      PyObject * job_dict = PyList_New(0);
975 <      std::vector <std::string>
971 > PyObject *BossSession_queryTasks(BossSession *self,std::string const &taskName,std::string const &taskRange,std::string after,std::string before,std::string user){
972 >      PyObject * task_list = PyList_New(0);
973 >      std::vector <std::string> taskList;
974 >      if ( taskName.empty() ) {
975          taskList = self->selectTasks( taskRange, before, after, user);
976 +      } else {
977 +        taskList = self->selectTasksByName( taskName );
978 +      }
979        for ( std::vector <std::string>::const_iterator it= taskList.begin();
980              it!= taskList.end(); ++it ) {
981 <        PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
981 >        PyList_Append( task_list,  PyString_FromString(it->c_str() ) );
982        }
983 <      return  job_dict;
983 >      return  task_list;
984      }
985   void BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
986      std::string tmp;
# Line 994 | Line 996 | void BossTask_appendToPyDict(BossTask co
996      }
997      return;
998    }
999 < void BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit,PyObject *job_dict){
999 > void BossTask_jobDict(BossTask const *self,BossJob const *jobH,PyObject *job_dict){
1000  
1001      //    PyObject * job_dict = PyDict_New();
1002      std::string tmp;
1003  
1004 <    BossAttributeContainer obj = (*jit)->getTableEntries("JOB");
1004 >    BossAttributeContainer obj = jobH->getTableEntries("JOB");
1005      BossTask_appendToPyDict ( self, job_dict, obj );
1006  
1007 <    std::set<std::string> sch = (*jit)->getSchedulerElements();
1007 >    std::set<std::string> sch = jobH->getSchedulerElements();
1008      std::set<std::string>::const_iterator sch_end =  sch.end();
1009      for (std::set<std::string>::const_iterator it =sch.begin();
1010           it != sch_end; ++ it ) {
1011  
1012 <      tmp = (**jit)["JOB_SCHED_INFO."+(*it)];
1012 >      tmp = (*jobH)["JOB_SCHED_INFO."+(*it)];
1013        PyObject * key = PyString_FromString( it->c_str() );
1014        PyObject * val = PyString_FromString( tmp.c_str() );
1015        PyDict_SetItem( job_dict, key, val);
# Line 1024 | Line 1026 | PyObject *BossTask_jobsDict(BossTask *se
1026           jit != self->job_end (); ++jit) {
1027        PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1028        PyObject * tmp_dict = PyDict_New();
1029 <      BossTask_jobDict( self, jit, tmp_dict );
1029 >      BossTask_jobDict( self, *jit, tmp_dict );
1030        PyDict_SetItem( job_dict, id, tmp_dict );
1031        Py_DECREF(id);
1032        Py_DECREF(tmp_dict);
1033      }
1034      return job_dict;
1035    }
1036 + PyObject *BossTask_job(BossTask *self,std::string const &jobid){
1037 +  
1038 +    PyObject * job_dict = PyDict_New();
1039 +    self->load( ALL, jobid );
1040 +    BossTask_jobDict( self, &(*self)[ atoi(jobid.c_str()) ], job_dict );
1041 +    return job_dict;
1042 +  }
1043 + PyObject *BossTask_jobStates(BossTask *self){
1044 +  
1045 +    PyObject * job_dict = PyDict_New();
1046 +    if ( self->job_begin () == self->job_end ()) self->load(ALL);
1047 +    for (BossTask::job_iterator jit = self->job_begin ();
1048 +         jit != self->job_end (); ++jit) {
1049 +      PyObject * id = PyString_FromString( ((*jit)->chainId()).c_str() );
1050 +      PyObject * status = PyString_FromString( ((**jit)["JOB.STATUS"]).c_str() );
1051 +      PyDict_SetItem( job_dict, id, status );
1052 +      Py_DECREF(id);
1053 +      Py_DECREF(status);
1054 +    }
1055 +    return job_dict;
1056 +  }
1057 + PyObject *BossTask_jobStatistic(BossTask *self){
1058 +  
1059 +    PyObject * job_dict = PyDict_New();
1060 +    if ( self->job_begin () == self->job_end ()) self->load(ALL);
1061 +    std::map< std::string, int > states;
1062 +    for (BossTask::job_iterator jit = self->job_begin ();
1063 +         jit != self->job_end (); ++jit) {
1064 +      ++states[(**jit)["JOB.STATUS"]];
1065 +    }
1066 +
1067 +    std::map< std::string, int >::const_iterator end = states.end ();
1068 +    for (std::map< std::string, int >::const_iterator it = states.begin ();
1069 +         it != end; ++it) {
1070 +      PyObject * status = PyString_FromString( (it->first).c_str() );
1071 +      PyObject * jobs = PyString_FromFormat( "%d", it->second );
1072 +      PyDict_SetItem( job_dict, status, jobs );
1073 +      Py_DECREF(jobs);
1074 +      Py_DECREF(status);
1075 +    }
1076 +    return job_dict;
1077 +  }
1078   PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator &programs_it){
1079  
1080      PyObject * job_dict = PyDict_New();
# Line 1080 | Line 1124 | PyObject *BossTask_jobPrograms(BossTask
1124      }
1125      return job_dict;
1126    }
1127 + PyObject *BossTask_program(BossTask *self,std::string const &jobid,std::string const &programId){
1128 +  
1129 +    PyObject * job_dict = PyDict_New();
1130 +
1131 +    const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1132 +    BossAttributeContainer obj =
1133 +      self->queryProgram( jH, programId ).getTableEntries("PROGRAM");
1134 +    BossTask_appendToPyDict ( self, job_dict, obj );
1135 +    return job_dict;
1136 +  }
1137 + PyObject *BossTask_programExec(BossTask *self,std::string const &jobid,std::string const &programId){
1138 +  
1139 +    PyObject * job_dict = PyDict_New();
1140 +
1141 +    const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1142 +
1143 +    // PROGRAM_EXEC
1144 +    BossProgramExec programExec = self->queryProgramExec( jH, programId );
1145 +    BossAttributeContainer obj = programExec.getTableEntries("PROGRAM_EXEC");
1146 +    BossTask_appendToPyDict ( self, job_dict, obj );
1147 +
1148 +    // SPECIFICS
1149 +    std::vector < BossAttributeContainer >::const_iterator it;
1150 +    std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1151 +    for ( it = programExec.specBegin (); it != it_end; ++it) {
1152 +      BossTask_appendToPyDict ( self, job_dict, *it );
1153 +    }
1154 +    return job_dict;
1155 +  }
1156 + PyObject *BossTask_specific(BossTask *self,std::string const &jobid,std::string const &programId){
1157 +  
1158 +    PyObject * job_dict = PyDict_New();
1159 +
1160 +    const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1161 +    BossProgramExec programExec = self->queryProgramExec( jH, programId );
1162 +
1163 +    std::vector < BossAttributeContainer >::const_iterator it;
1164 +    std::vector < BossAttributeContainer >::const_iterator it_end = programExec.specEnd ();
1165 +    for ( it = programExec.specBegin (); it != it_end; ++it) {
1166 +      BossTask_appendToPyDict ( self, job_dict, *it );
1167 +    }
1168 +    return job_dict;
1169 +  }
1170   #ifdef __cplusplus
1171   extern "C" {
1172   #endif
# Line 3190 | Line 3277 | static PyObject *_wrap_BossSession_selec
3277   }
3278  
3279  
3280 + static PyObject *_wrap_BossSession_selectTasksByName(PyObject *self, PyObject *args) {
3281 +    PyObject *resultobj;
3282 +    BossSession *arg1 = (BossSession *) 0 ;
3283 +    std::string *arg2 = 0 ;
3284 +    std::vector<std::string > result;
3285 +    std::string temp2 ;
3286 +    PyObject * obj0 = 0 ;
3287 +    PyObject * obj1 = 0 ;
3288 +    
3289 +    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasksByName",&obj0,&obj1)) goto fail;
3290 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3291 +    {
3292 +        if (PyString_Check(obj1)) {
3293 +            temp2 = std::string(PyString_AsString(obj1));
3294 +            arg2 = &temp2;
3295 +        }else {
3296 +            SWIG_exception(SWIG_TypeError, "string expected");
3297 +        }
3298 +    }
3299 +    {
3300 +        try {
3301 +            result = (arg1)->selectTasksByName((std::string const &)*arg2);
3302 +            
3303 +        }catch (const BossSchedFailure & e) {
3304 +            PyErr_SetString ( SchedulerError, e.what() );
3305 +            return NULL;
3306 +        }catch (const std::exception& e) {
3307 +            PyErr_SetString ( BossError, e.what() );
3308 +            return NULL;
3309 +        }
3310 +    }
3311 +    {
3312 +        resultobj = PyTuple_New((&result)->size());
3313 +        for (unsigned int i=0; i<(&result)->size(); i++)
3314 +        PyTuple_SetItem(resultobj,i,
3315 +        SwigString_FromString(((std::vector<std::string > &)result)[i]));
3316 +    }
3317 +    return resultobj;
3318 +    fail:
3319 +    return NULL;
3320 + }
3321 +
3322 +
3323   static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3324      PyObject *resultobj;
3325      BossSession *arg1 = (BossSession *) 0 ;
# Line 3316 | Line 3446 | static PyObject *_wrap_BossSession_query
3446   }
3447  
3448  
3449 + static PyObject *_wrap_BossSession_getTasksByName(PyObject *self, PyObject *args) {
3450 +    PyObject *resultobj;
3451 +    BossSession *arg1 = (BossSession *) 0 ;
3452 +    std::string *arg2 = 0 ;
3453 +    SwigValueWrapper< std::vector<BossTask * > > result;
3454 +    std::string temp2 ;
3455 +    PyObject * obj0 = 0 ;
3456 +    PyObject * obj1 = 0 ;
3457 +    
3458 +    if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_getTasksByName",&obj0,&obj1)) goto fail;
3459 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3460 +    {
3461 +        if (PyString_Check(obj1)) {
3462 +            temp2 = std::string(PyString_AsString(obj1));
3463 +            arg2 = &temp2;
3464 +        }else {
3465 +            SWIG_exception(SWIG_TypeError, "string expected");
3466 +        }
3467 +    }
3468 +    {
3469 +        try {
3470 +            result = (arg1)->getTasksByName((std::string const &)*arg2);
3471 +            
3472 +        }catch (const BossSchedFailure & e) {
3473 +            PyErr_SetString ( SchedulerError, e.what() );
3474 +            return NULL;
3475 +        }catch (const std::exception& e) {
3476 +            PyErr_SetString ( BossError, e.what() );
3477 +            return NULL;
3478 +        }
3479 +    }
3480 +    {
3481 +        std::vector<BossTask * > * resultptr;
3482 +        resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3483 +        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3484 +    }
3485 +    return resultobj;
3486 +    fail:
3487 +    return NULL;
3488 + }
3489 +
3490 +
3491   static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3492      PyObject *resultobj;
3493      BossSession *arg1 = (BossSession *) 0 ;
# Line 3549 | Line 3721 | static PyObject *_wrap_BossSession_sched
3721   static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3722      PyObject *resultobj;
3723      BossSession *arg1 = (BossSession *) 0 ;
3724 <    int arg2 = (int) SCHEDULED ;
3724 >    std::string const &arg2_defvalue = "" ;
3725 >    std::string *arg2 = (std::string *) &arg2_defvalue ;
3726      std::string const &arg3_defvalue = "all" ;
3727      std::string *arg3 = (std::string *) &arg3_defvalue ;
3728 <    std::string const &arg4_defvalue = "all" ;
3729 <    std::string *arg4 = (std::string *) &arg4_defvalue ;
3557 <    std::string const &arg5_defvalue = "" ;
3558 <    std::string *arg5 = (std::string *) &arg5_defvalue ;
3728 >    std::string arg4 = (std::string) "" ;
3729 >    std::string arg5 = (std::string) "" ;
3730      std::string arg6 = (std::string) "" ;
3560    std::string arg7 = (std::string) "" ;
3561    std::string arg8 = (std::string) "" ;
3562    std::string arg9 = (std::string) "" ;
3563    unsigned int arg10 = (unsigned int) 0 ;
3564    bool arg11 = (bool) false ;
3731      PyObject *result;
3732 +    std::string temp2 ;
3733      std::string temp3 ;
3567    std::string temp4 ;
3568    std::string temp5 ;
3734      PyObject * obj0 = 0 ;
3735 +    PyObject * obj1 = 0 ;
3736      PyObject * obj2 = 0 ;
3737      PyObject * obj3 = 0 ;
3738      PyObject * obj4 = 0 ;
3739      PyObject * obj5 = 0 ;
3574    PyObject * obj6 = 0 ;
3575    PyObject * obj7 = 0 ;
3576    PyObject * obj8 = 0 ;
3577    PyObject * obj9 = 0 ;
3578    PyObject * obj10 = 0 ;
3740      
3741 <    if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3741 >    if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3742      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3743 <    if (obj2) {
3583 <        {
3584 <            if (PyString_Check(obj2)) {
3585 <                temp3 = std::string(PyString_AsString(obj2));
3586 <                arg3 = &temp3;
3587 <            }else {
3588 <                SWIG_exception(SWIG_TypeError, "string expected");
3589 <            }
3590 <        }
3591 <    }
3592 <    if (obj3) {
3743 >    if (obj1) {
3744          {
3745 <            if (PyString_Check(obj3)) {
3746 <                temp4 = std::string(PyString_AsString(obj3));
3747 <                arg4 = &temp4;
3745 >            if (PyString_Check(obj1)) {
3746 >                temp2 = std::string(PyString_AsString(obj1));
3747 >                arg2 = &temp2;
3748              }else {
3749                  SWIG_exception(SWIG_TypeError, "string expected");
3750              }
3751          }
3752      }
3753 <    if (obj4) {
3753 >    if (obj2) {
3754          {
3755 <            if (PyString_Check(obj4)) {
3756 <                temp5 = std::string(PyString_AsString(obj4));
3757 <                arg5 = &temp5;
3755 >            if (PyString_Check(obj2)) {
3756 >                temp3 = std::string(PyString_AsString(obj2));
3757 >                arg3 = &temp3;
3758              }else {
3759                  SWIG_exception(SWIG_TypeError, "string expected");
3760              }
3761          }
3762      }
3763 <    if (obj5) {
3613 <        {
3614 <            if (PyString_Check(obj5))
3615 <            arg6 = std::string(PyString_AsString(obj5));
3616 <            else
3617 <            SWIG_exception(SWIG_TypeError, "string expected");
3618 <        }
3619 <    }
3620 <    if (obj6) {
3763 >    if (obj3) {
3764          {
3765 <            if (PyString_Check(obj6))
3766 <            arg7 = std::string(PyString_AsString(obj6));
3765 >            if (PyString_Check(obj3))
3766 >            arg4 = std::string(PyString_AsString(obj3));
3767              else
3768              SWIG_exception(SWIG_TypeError, "string expected");
3769          }
3770      }
3771 <    if (obj7) {
3771 >    if (obj4) {
3772          {
3773 <            if (PyString_Check(obj7))
3774 <            arg8 = std::string(PyString_AsString(obj7));
3773 >            if (PyString_Check(obj4))
3774 >            arg5 = std::string(PyString_AsString(obj4));
3775              else
3776              SWIG_exception(SWIG_TypeError, "string expected");
3777          }
3778      }
3779 <    if (obj8) {
3779 >    if (obj5) {
3780          {
3781 <            if (PyString_Check(obj8))
3782 <            arg9 = std::string(PyString_AsString(obj8));
3781 >            if (PyString_Check(obj5))
3782 >            arg6 = std::string(PyString_AsString(obj5));
3783              else
3784              SWIG_exception(SWIG_TypeError, "string expected");
3785          }
3786      }
3644    if (obj9) {
3645        arg10 = (unsigned int) PyInt_AsLong(obj9);
3646        if (PyErr_Occurred()) SWIG_fail;
3647    }
3648    if (obj10) {
3649        arg11 = PyInt_AsLong(obj10) ? true : false;
3650        if (PyErr_Occurred()) SWIG_fail;
3651    }
3787      {
3788          try {
3789 <            result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3789 >            result = (PyObject *)BossSession_queryTasks(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
3790              
3791          }catch (const BossSchedFailure & e) {
3792              PyErr_SetString ( SchedulerError, e.what() );
# Line 3800 | Line 3935 | static PyObject * BossTaskException_swig
3935      Py_INCREF(obj);
3936      return Py_BuildValue((char *)"");
3937   }
3938 + static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3939 +    PyObject *resultobj;
3940 +    BossTask *arg1 = (BossTask *) 0 ;
3941 +    BossTask::job_iterator result;
3942 +    PyObject * obj0 = 0 ;
3943 +    
3944 +    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3945 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3946 +    {
3947 +        try {
3948 +            result = ((BossTask const *)arg1)->job_begin();
3949 +            
3950 +        }catch (const BossSchedFailure & e) {
3951 +            PyErr_SetString ( SchedulerError, e.what() );
3952 +            return NULL;
3953 +        }catch (const std::exception& e) {
3954 +            PyErr_SetString ( BossError, e.what() );
3955 +            return NULL;
3956 +        }
3957 +    }
3958 +    {
3959 +        BossTask::job_iterator * resultptr;
3960 +        resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3961 +        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3962 +    }
3963 +    return resultobj;
3964 +    fail:
3965 +    return NULL;
3966 + }
3967 +
3968 +
3969 + static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3970 +    PyObject *resultobj;
3971 +    BossTask *arg1 = (BossTask *) 0 ;
3972 +    BossTask::job_iterator result;
3973 +    PyObject * obj0 = 0 ;
3974 +    
3975 +    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3976 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3977 +    {
3978 +        try {
3979 +            result = ((BossTask const *)arg1)->job_end();
3980 +            
3981 +        }catch (const BossSchedFailure & e) {
3982 +            PyErr_SetString ( SchedulerError, e.what() );
3983 +            return NULL;
3984 +        }catch (const std::exception& e) {
3985 +            PyErr_SetString ( BossError, e.what() );
3986 +            return NULL;
3987 +        }
3988 +    }
3989 +    {
3990 +        BossTask::job_iterator * resultptr;
3991 +        resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3992 +        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3993 +    }
3994 +    return resultobj;
3995 +    fail:
3996 +    return NULL;
3997 + }
3998 +
3999 +
4000 + static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4001 +    PyObject *resultobj;
4002 +    BossTask *arg1 = (BossTask *) 0 ;
4003 +    BossJob *arg2 = (BossJob *) 0 ;
4004 +    SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4005 +    PyObject * obj0 = 0 ;
4006 +    PyObject * obj1 = 0 ;
4007 +    
4008 +    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4009 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4010 +    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4011 +    {
4012 +        try {
4013 +            result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4014 +            
4015 +        }catch (const BossSchedFailure & e) {
4016 +            PyErr_SetString ( SchedulerError, e.what() );
4017 +            return NULL;
4018 +        }catch (const std::exception& e) {
4019 +            PyErr_SetString ( BossError, e.what() );
4020 +            return NULL;
4021 +        }
4022 +    }
4023 +    {
4024 +        std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4025 +        resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4026 +        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4027 +    }
4028 +    return resultobj;
4029 +    fail:
4030 +    return NULL;
4031 + }
4032 +
4033 +
4034 + static PyObject *_wrap_BossTask_queryProgram(PyObject *self, PyObject *args) {
4035 +    PyObject *resultobj;
4036 +    BossTask *arg1 = (BossTask *) 0 ;
4037 +    BossJob *arg2 = (BossJob *) 0 ;
4038 +    std::string *arg3 = 0 ;
4039 +    BossProgram result;
4040 +    std::string temp3 ;
4041 +    PyObject * obj0 = 0 ;
4042 +    PyObject * obj1 = 0 ;
4043 +    PyObject * obj2 = 0 ;
4044 +    
4045 +    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgram",&obj0,&obj1,&obj2)) goto fail;
4046 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4047 +    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4048 +    {
4049 +        if (PyString_Check(obj2)) {
4050 +            temp3 = std::string(PyString_AsString(obj2));
4051 +            arg3 = &temp3;
4052 +        }else {
4053 +            SWIG_exception(SWIG_TypeError, "string expected");
4054 +        }
4055 +    }
4056 +    {
4057 +        try {
4058 +            result = ((BossTask const *)arg1)->queryProgram((BossJob const *)arg2,(std::string const &)*arg3);
4059 +            
4060 +        }catch (const BossSchedFailure & e) {
4061 +            PyErr_SetString ( SchedulerError, e.what() );
4062 +            return NULL;
4063 +        }catch (const std::exception& e) {
4064 +            PyErr_SetString ( BossError, e.what() );
4065 +            return NULL;
4066 +        }
4067 +    }
4068 +    {
4069 +        BossProgram * resultptr;
4070 +        resultptr = new BossProgram((BossProgram &) result);
4071 +        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgram, 1);
4072 +    }
4073 +    return resultobj;
4074 +    fail:
4075 +    return NULL;
4076 + }
4077 +
4078 +
4079 + static PyObject *_wrap_BossTask_queryProgramExec(PyObject *self, PyObject *args) {
4080 +    PyObject *resultobj;
4081 +    BossTask *arg1 = (BossTask *) 0 ;
4082 +    BossJob *arg2 = (BossJob *) 0 ;
4083 +    std::string *arg3 = 0 ;
4084 +    BossProgramExec result;
4085 +    std::string temp3 ;
4086 +    PyObject * obj0 = 0 ;
4087 +    PyObject * obj1 = 0 ;
4088 +    PyObject * obj2 = 0 ;
4089 +    
4090 +    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_queryProgramExec",&obj0,&obj1,&obj2)) goto fail;
4091 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4092 +    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4093 +    {
4094 +        if (PyString_Check(obj2)) {
4095 +            temp3 = std::string(PyString_AsString(obj2));
4096 +            arg3 = &temp3;
4097 +        }else {
4098 +            SWIG_exception(SWIG_TypeError, "string expected");
4099 +        }
4100 +    }
4101 +    {
4102 +        try {
4103 +            result = ((BossTask const *)arg1)->queryProgramExec((BossJob const *)arg2,(std::string const &)*arg3);
4104 +            
4105 +        }catch (const BossSchedFailure & e) {
4106 +            PyErr_SetString ( SchedulerError, e.what() );
4107 +            return NULL;
4108 +        }catch (const std::exception& e) {
4109 +            PyErr_SetString ( BossError, e.what() );
4110 +            return NULL;
4111 +        }
4112 +    }
4113 +    {
4114 +        BossProgramExec * resultptr;
4115 +        resultptr = new BossProgramExec((BossProgramExec &) result);
4116 +        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossProgramExec, 1);
4117 +    }
4118 +    return resultobj;
4119 +    fail:
4120 +    return NULL;
4121 + }
4122 +
4123 +
4124   static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
4125      PyObject *resultobj;
4126      BossDatabase *arg1 = (BossDatabase *) 0 ;
# Line 4084 | Line 4405 | static PyObject *_wrap_BossTask_taskMap(
4405   }
4406  
4407  
4087 static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4088    PyObject *resultobj;
4089    BossTask *arg1 = (BossTask *) 0 ;
4090    BossTask::job_iterator result;
4091    PyObject * obj0 = 0 ;
4092    
4093    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4094    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4095    {
4096        try {
4097            result = ((BossTask const *)arg1)->job_begin();
4098            
4099        }catch (const BossSchedFailure & e) {
4100            PyErr_SetString ( SchedulerError, e.what() );
4101            return NULL;
4102        }catch (const std::exception& e) {
4103            PyErr_SetString ( BossError, e.what() );
4104            return NULL;
4105        }
4106    }
4107    {
4108        BossTask::job_iterator * resultptr;
4109        resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4110        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4111    }
4112    return resultobj;
4113    fail:
4114    return NULL;
4115 }
4116
4117
4118 static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4119    PyObject *resultobj;
4120    BossTask *arg1 = (BossTask *) 0 ;
4121    BossTask::job_iterator result;
4122    PyObject * obj0 = 0 ;
4123    
4124    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4125    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4126    {
4127        try {
4128            result = ((BossTask const *)arg1)->job_end();
4129            
4130        }catch (const BossSchedFailure & e) {
4131            PyErr_SetString ( SchedulerError, e.what() );
4132            return NULL;
4133        }catch (const std::exception& e) {
4134            PyErr_SetString ( BossError, e.what() );
4135            return NULL;
4136        }
4137    }
4138    {
4139        BossTask::job_iterator * resultptr;
4140        resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4141        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4142    }
4143    return resultobj;
4144    fail:
4145    return NULL;
4146 }
4147
4148
4408   static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4409      PyObject *resultobj;
4410      BossTask *arg1 = (BossTask *) 0 ;
# Line 4361 | Line 4620 | static PyObject *_wrap_BossTask_programs
4620   }
4621  
4622  
4364 static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4365    PyObject *resultobj;
4366    BossTask *arg1 = (BossTask *) 0 ;
4367    BossJob *arg2 = (BossJob *) 0 ;
4368    SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4369    PyObject * obj0 = 0 ;
4370    PyObject * obj1 = 0 ;
4371    
4372    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4373    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4374    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4375    {
4376        try {
4377            result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4378            
4379        }catch (const BossSchedFailure & e) {
4380            PyErr_SetString ( SchedulerError, e.what() );
4381            return NULL;
4382        }catch (const std::exception& e) {
4383            PyErr_SetString ( BossError, e.what() );
4384            return NULL;
4385        }
4386    }
4387    {
4388        std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4389        resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4390        resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4391    }
4392    return resultobj;
4393    fail:
4394    return NULL;
4395 }
4396
4397
4623   static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4624      PyObject *resultobj;
4625      BossTask *arg1 = (BossTask *) 0 ;
# Line 4908 | Line 5133 | static PyObject *_wrap_BossTask_getOutpu
5133   }
5134  
5135  
5136 + static PyObject *_wrap_BossTask_loadByName(PyObject *self, PyObject *args) {
5137 +    PyObject *resultobj;
5138 +    BossTask *arg1 = (BossTask *) 0 ;
5139 +    std::string *arg2 = 0 ;
5140 +    int result;
5141 +    std::string temp2 ;
5142 +    PyObject * obj0 = 0 ;
5143 +    PyObject * obj1 = 0 ;
5144 +    
5145 +    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_loadByName",&obj0,&obj1)) goto fail;
5146 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5147 +    {
5148 +        if (PyString_Check(obj1)) {
5149 +            temp2 = std::string(PyString_AsString(obj1));
5150 +            arg2 = &temp2;
5151 +        }else {
5152 +            SWIG_exception(SWIG_TypeError, "string expected");
5153 +        }
5154 +    }
5155 +    {
5156 +        try {
5157 +            result = (int)(arg1)->loadByName((std::string const &)*arg2);
5158 +            
5159 +        }catch (const BossSchedFailure & e) {
5160 +            PyErr_SetString ( SchedulerError, e.what() );
5161 +            return NULL;
5162 +        }catch (const std::exception& e) {
5163 +            PyErr_SetString ( BossError, e.what() );
5164 +            return NULL;
5165 +        }
5166 +    }
5167 +    resultobj = PyInt_FromLong((long)result);
5168 +    return resultobj;
5169 +    fail:
5170 +    return NULL;
5171 + }
5172 +
5173 +
5174   static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
5175      PyObject *resultobj;
5176      BossTask *arg1 = (BossTask *) 0 ;
# Line 5239 | Line 5502 | static PyObject *_wrap_BossTask_appendTo
5502   static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5503      PyObject *resultobj;
5504      BossTask *arg1 = (BossTask *) 0 ;
5505 <    std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5505 >    BossJob *arg2 = (BossJob *) 0 ;
5506      PyObject *arg3 = (PyObject *) 0 ;
5507      PyObject * obj0 = 0 ;
5508      PyObject * obj1 = 0 ;
# Line 5247 | Line 5510 | static PyObject *_wrap_BossTask_jobDict(
5510      
5511      if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobDict",&obj0,&obj1,&obj2)) goto fail;
5512      if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5513 <    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5251 <    if (arg2 == NULL) {
5252 <        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5253 <    }
5513 >    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5514      arg3 = obj2;
5515      {
5516          try {
5517 <            BossTask_jobDict((BossTask const *)arg1,*arg2,arg3);
5517 >            BossTask_jobDict((BossTask const *)arg1,(BossJob const *)arg2,arg3);
5518              
5519          }catch (const BossSchedFailure & e) {
5520              PyErr_SetString ( SchedulerError, e.what() );
# Line 5298 | Line 5558 | static PyObject *_wrap_BossTask_jobsDict
5558   }
5559  
5560  
5561 + static PyObject *_wrap_BossTask_job(PyObject *self, PyObject *args) {
5562 +    PyObject *resultobj;
5563 +    BossTask *arg1 = (BossTask *) 0 ;
5564 +    std::string *arg2 = 0 ;
5565 +    PyObject *result;
5566 +    std::string temp2 ;
5567 +    PyObject * obj0 = 0 ;
5568 +    PyObject * obj1 = 0 ;
5569 +    
5570 +    if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_job",&obj0,&obj1)) goto fail;
5571 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5572 +    {
5573 +        if (PyString_Check(obj1)) {
5574 +            temp2 = std::string(PyString_AsString(obj1));
5575 +            arg2 = &temp2;
5576 +        }else {
5577 +            SWIG_exception(SWIG_TypeError, "string expected");
5578 +        }
5579 +    }
5580 +    {
5581 +        try {
5582 +            result = (PyObject *)BossTask_job(arg1,(std::string const &)*arg2);
5583 +            
5584 +        }catch (const BossSchedFailure & e) {
5585 +            PyErr_SetString ( SchedulerError, e.what() );
5586 +            return NULL;
5587 +        }catch (const std::exception& e) {
5588 +            PyErr_SetString ( BossError, e.what() );
5589 +            return NULL;
5590 +        }
5591 +    }
5592 +    resultobj = result;
5593 +    return resultobj;
5594 +    fail:
5595 +    return NULL;
5596 + }
5597 +
5598 +
5599 + static PyObject *_wrap_BossTask_jobStates(PyObject *self, PyObject *args) {
5600 +    PyObject *resultobj;
5601 +    BossTask *arg1 = (BossTask *) 0 ;
5602 +    PyObject *result;
5603 +    PyObject * obj0 = 0 ;
5604 +    
5605 +    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStates",&obj0)) goto fail;
5606 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5607 +    {
5608 +        try {
5609 +            result = (PyObject *)BossTask_jobStates(arg1);
5610 +            
5611 +        }catch (const BossSchedFailure & e) {
5612 +            PyErr_SetString ( SchedulerError, e.what() );
5613 +            return NULL;
5614 +        }catch (const std::exception& e) {
5615 +            PyErr_SetString ( BossError, e.what() );
5616 +            return NULL;
5617 +        }
5618 +    }
5619 +    resultobj = result;
5620 +    return resultobj;
5621 +    fail:
5622 +    return NULL;
5623 + }
5624 +
5625 +
5626 + static PyObject *_wrap_BossTask_jobStatistic(PyObject *self, PyObject *args) {
5627 +    PyObject *resultobj;
5628 +    BossTask *arg1 = (BossTask *) 0 ;
5629 +    PyObject *result;
5630 +    PyObject * obj0 = 0 ;
5631 +    
5632 +    if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobStatistic",&obj0)) goto fail;
5633 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5634 +    {
5635 +        try {
5636 +            result = (PyObject *)BossTask_jobStatistic(arg1);
5637 +            
5638 +        }catch (const BossSchedFailure & e) {
5639 +            PyErr_SetString ( SchedulerError, e.what() );
5640 +            return NULL;
5641 +        }catch (const std::exception& e) {
5642 +            PyErr_SetString ( BossError, e.what() );
5643 +            return NULL;
5644 +        }
5645 +    }
5646 +    resultobj = result;
5647 +    return resultobj;
5648 +    fail:
5649 +    return NULL;
5650 + }
5651 +
5652 +
5653   static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5654      PyObject *resultobj;
5655      BossTask *arg1 = (BossTask *) 0 ;
# Line 5369 | Line 5721 | static PyObject *_wrap_BossTask_jobProgr
5721   }
5722  
5723  
5724 + static PyObject *_wrap_BossTask_program(PyObject *self, PyObject *args) {
5725 +    PyObject *resultobj;
5726 +    BossTask *arg1 = (BossTask *) 0 ;
5727 +    std::string *arg2 = 0 ;
5728 +    std::string *arg3 = 0 ;
5729 +    PyObject *result;
5730 +    std::string temp2 ;
5731 +    std::string temp3 ;
5732 +    PyObject * obj0 = 0 ;
5733 +    PyObject * obj1 = 0 ;
5734 +    PyObject * obj2 = 0 ;
5735 +    
5736 +    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_program",&obj0,&obj1,&obj2)) goto fail;
5737 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5738 +    {
5739 +        if (PyString_Check(obj1)) {
5740 +            temp2 = std::string(PyString_AsString(obj1));
5741 +            arg2 = &temp2;
5742 +        }else {
5743 +            SWIG_exception(SWIG_TypeError, "string expected");
5744 +        }
5745 +    }
5746 +    {
5747 +        if (PyString_Check(obj2)) {
5748 +            temp3 = std::string(PyString_AsString(obj2));
5749 +            arg3 = &temp3;
5750 +        }else {
5751 +            SWIG_exception(SWIG_TypeError, "string expected");
5752 +        }
5753 +    }
5754 +    {
5755 +        try {
5756 +            result = (PyObject *)BossTask_program(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
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_programExec(PyObject *self, PyObject *args) {
5774 +    PyObject *resultobj;
5775 +    BossTask *arg1 = (BossTask *) 0 ;
5776 +    std::string *arg2 = 0 ;
5777 +    std::string *arg3 = 0 ;
5778 +    PyObject *result;
5779 +    std::string temp2 ;
5780 +    std::string temp3 ;
5781 +    PyObject * obj0 = 0 ;
5782 +    PyObject * obj1 = 0 ;
5783 +    PyObject * obj2 = 0 ;
5784 +    
5785 +    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_programExec",&obj0,&obj1,&obj2)) goto fail;
5786 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5787 +    {
5788 +        if (PyString_Check(obj1)) {
5789 +            temp2 = std::string(PyString_AsString(obj1));
5790 +            arg2 = &temp2;
5791 +        }else {
5792 +            SWIG_exception(SWIG_TypeError, "string expected");
5793 +        }
5794 +    }
5795 +    {
5796 +        if (PyString_Check(obj2)) {
5797 +            temp3 = std::string(PyString_AsString(obj2));
5798 +            arg3 = &temp3;
5799 +        }else {
5800 +            SWIG_exception(SWIG_TypeError, "string expected");
5801 +        }
5802 +    }
5803 +    {
5804 +        try {
5805 +            result = (PyObject *)BossTask_programExec(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5806 +            
5807 +        }catch (const BossSchedFailure & e) {
5808 +            PyErr_SetString ( SchedulerError, e.what() );
5809 +            return NULL;
5810 +        }catch (const std::exception& e) {
5811 +            PyErr_SetString ( BossError, e.what() );
5812 +            return NULL;
5813 +        }
5814 +    }
5815 +    resultobj = result;
5816 +    return resultobj;
5817 +    fail:
5818 +    return NULL;
5819 + }
5820 +
5821 +
5822 + static PyObject *_wrap_BossTask_specific(PyObject *self, PyObject *args) {
5823 +    PyObject *resultobj;
5824 +    BossTask *arg1 = (BossTask *) 0 ;
5825 +    std::string *arg2 = 0 ;
5826 +    std::string *arg3 = 0 ;
5827 +    PyObject *result;
5828 +    std::string temp2 ;
5829 +    std::string temp3 ;
5830 +    PyObject * obj0 = 0 ;
5831 +    PyObject * obj1 = 0 ;
5832 +    PyObject * obj2 = 0 ;
5833 +    
5834 +    if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_specific",&obj0,&obj1,&obj2)) goto fail;
5835 +    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5836 +    {
5837 +        if (PyString_Check(obj1)) {
5838 +            temp2 = std::string(PyString_AsString(obj1));
5839 +            arg2 = &temp2;
5840 +        }else {
5841 +            SWIG_exception(SWIG_TypeError, "string expected");
5842 +        }
5843 +    }
5844 +    {
5845 +        if (PyString_Check(obj2)) {
5846 +            temp3 = std::string(PyString_AsString(obj2));
5847 +            arg3 = &temp3;
5848 +        }else {
5849 +            SWIG_exception(SWIG_TypeError, "string expected");
5850 +        }
5851 +    }
5852 +    {
5853 +        try {
5854 +            result = (PyObject *)BossTask_specific(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5855 +            
5856 +        }catch (const BossSchedFailure & e) {
5857 +            PyErr_SetString ( SchedulerError, e.what() );
5858 +            return NULL;
5859 +        }catch (const std::exception& e) {
5860 +            PyErr_SetString ( BossError, e.what() );
5861 +            return NULL;
5862 +        }
5863 +    }
5864 +    resultobj = result;
5865 +    return resultobj;
5866 +    fail:
5867 +    return NULL;
5868 + }
5869 +
5870 +
5871   static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5872      PyObject *obj;
5873      if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
# Line 6348 | Line 6847 | static PyMethodDef SwigMethods[] = {
6847           { (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6848           { (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6849           { (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6850 +         { (char *)"BossSession_selectTasksByName", _wrap_BossSession_selectTasksByName, METH_VARARGS },
6851           { (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6852 +         { (char *)"BossSession_getTasksByName", _wrap_BossSession_getTasksByName, METH_VARARGS },
6853           { (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6854           { (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6855           { (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
# Line 6363 | Line 6864 | static PyMethodDef SwigMethods[] = {
6864           { (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6865           { (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6866           { (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
6867 +         { (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6868 +         { (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6869 +         { (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6870 +         { (char *)"BossTask_queryProgram", _wrap_BossTask_queryProgram, METH_VARARGS },
6871 +         { (char *)"BossTask_queryProgramExec", _wrap_BossTask_queryProgramExec, METH_VARARGS },
6872           { (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6873           { (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6874           { (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
6875           { (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
6876           { (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6371         { (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6372         { (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6877           { (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
6878           { (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6879           { (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6376         { (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6880           { (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
6881           { (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
6882           { (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
# Line 6381 | Line 6884 | static PyMethodDef SwigMethods[] = {
6884           { (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6885           { (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6886           { (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6887 +         { (char *)"BossTask_loadByName", _wrap_BossTask_loadByName, METH_VARARGS },
6888           { (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6889           { (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6890           { (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
# Line 6388 | Line 6892 | static PyMethodDef SwigMethods[] = {
6892           { (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6893           { (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6894           { (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6895 +         { (char *)"BossTask_job", _wrap_BossTask_job, METH_VARARGS },
6896 +         { (char *)"BossTask_jobStates", _wrap_BossTask_jobStates, METH_VARARGS },
6897 +         { (char *)"BossTask_jobStatistic", _wrap_BossTask_jobStatistic, METH_VARARGS },
6898           { (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6899           { (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6900 +         { (char *)"BossTask_program", _wrap_BossTask_program, METH_VARARGS },
6901 +         { (char *)"BossTask_programExec", _wrap_BossTask_programExec, METH_VARARGS },
6902 +         { (char *)"BossTask_specific", _wrap_BossTask_specific, METH_VARARGS },
6903           { (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6904           { (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6905           { (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
# Line 6414 | Line 6924 | static PyMethodDef SwigMethods[] = {
6924  
6925   /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6926  
6417 static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6927   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}};
6928 + static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6929   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}};
6930 + static swig_type_info _swigt__p_BossProgramExec[] = {{"_p_BossProgramExec", 0, "BossProgramExec *", 0},{"_p_BossProgramExec"},{0}};
6931   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}};
6932   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}};
6422 static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6933   static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6934   static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
6935 + static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6936 + static swig_type_info _swigt__p_BossProgram[] = {{"_p_BossProgram", 0, "BossProgram *", 0},{"_p_BossProgram"},{0}};
6937   static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6938   static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6939   static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
# Line 6435 | Line 6947 | static swig_type_info _swigt__p_BossTask
6947   static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6948  
6949   static swig_type_info *swig_types_initial[] = {
6438 _swigt__p_XMLDoc,
6950   _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6951 + _swigt__p_XMLDoc,
6952   _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6953 + _swigt__p_BossProgramExec,
6954   _swigt__p_std__vectorTBossTask_p_t,
6955   _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6443 _swigt__p_std__ostream,
6956   _swigt__p_BossTask,
6957   _swigt__p_BossTaskException,
6958 + _swigt__p_std__ostream,
6959 + _swigt__p_BossProgram,
6960   _swigt__p_printOption,
6961   _swigt__p_BossAttributeContainer,
6962   _swigt__p_BossJob,

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines