ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/COMP/BOSS/BossPython/BossSession_wrap.cxx

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.14 by gcodispo, Mon Nov 6 08:52:57 2006 UTC vs.
Revision 1.17 by gcodispo, Thu Dec 7 09:31:22 2006 UTC

#	Line 927 | Line 927 | void std_vectorlstd_string_g___delslice_
927		#include "BossProgram.h"
928		#include "BossProgramExec.h"
929		#include "BossDatabase.h"
930	+	#include "BossScheduler.h"
931
932		PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
933		PyObject *  my_list = PyList_New( my_vec.size());
#	Line 1084 | Line 1085 | static PyObject *_wrap_new_objectMap__SW
1085		try {
1086		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1087
1088	+	}catch (const BossSchedFailure & e) {
1089	+	SWIG_exception(SWIG_ValueError, e.what());
1090		}catch (const std::exception& e) {
1091		SWIG_exception(SWIG_RuntimeError, e.what());
1092		}
#	Line 1143 | Line 1146 | static PyObject *_wrap_new_objectMap__SW
1146		try {
1147		result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1148
1149	+	}catch (const BossSchedFailure & e) {
1150	+	SWIG_exception(SWIG_ValueError, e.what());
1151		}catch (const std::exception& e) {
1152		SWIG_exception(SWIG_RuntimeError, e.what());
1153		}
#	Line 1258 | Line 1263 | static PyObject *_wrap_objectMap___len__
1263		try {
1264		result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1265
1266	+	}catch (const BossSchedFailure & e) {
1267	+	SWIG_exception(SWIG_ValueError, e.what());
1268		}catch (const std::exception& e) {
1269		SWIG_exception(SWIG_RuntimeError, e.what());
1270		}
#	Line 1280 | Line 1287 | static PyObject *_wrap_objectMap_clear(P
1287		try {
1288		(arg1)->clear();
1289
1290	+	}catch (const BossSchedFailure & e) {
1291	+	SWIG_exception(SWIG_ValueError, e.what());
1292		}catch (const std::exception& e) {
1293		SWIG_exception(SWIG_RuntimeError, e.what());
1294		}
#	Line 1303 | Line 1312 | static PyObject *_wrap_objectMap___nonze
1312		try {
1313		result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1314
1315	+	}catch (const BossSchedFailure & e) {
1316	+	SWIG_exception(SWIG_ValueError, e.what());
1317		}catch (const std::exception& e) {
1318		SWIG_exception(SWIG_RuntimeError, e.what());
1319		}
#	Line 1375 | Line 1386 | static PyObject *_wrap_objectMap___setit
1386		try {
1387		std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1388
1389	+	}catch (const BossSchedFailure & e) {
1390	+	SWIG_exception(SWIG_ValueError, e.what());
1391		}catch (const std::exception& e) {
1392		SWIG_exception(SWIG_RuntimeError, e.what());
1393		}
#	Line 1437 | Line 1450 | static PyObject *_wrap_objectMap_has_key
1450		try {
1451		result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1452
1453	+	}catch (const BossSchedFailure & e) {
1454	+	SWIG_exception(SWIG_ValueError, e.what());
1455		}catch (const std::exception& e) {
1456		SWIG_exception(SWIG_RuntimeError, e.what());
1457		}
#	Line 1460 | Line 1475 | static PyObject *_wrap_objectMap_keys(Py
1475		try {
1476		result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1477
1478	+	}catch (const BossSchedFailure & e) {
1479	+	SWIG_exception(SWIG_ValueError, e.what());
1480		}catch (const std::exception& e) {
1481		SWIG_exception(SWIG_RuntimeError, e.what());
1482		}
#	Line 1483 | Line 1500 | static PyObject *_wrap_objectMap_values(
1500		try {
1501		result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1502
1503	+	}catch (const BossSchedFailure & e) {
1504	+	SWIG_exception(SWIG_ValueError, e.what());
1505		}catch (const std::exception& e) {
1506		SWIG_exception(SWIG_RuntimeError, e.what());
1507		}
#	Line 1506 | Line 1525 | static PyObject *_wrap_objectMap_items(P
1525		try {
1526		result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1527
1528	+	}catch (const BossSchedFailure & e) {
1529	+	SWIG_exception(SWIG_ValueError, e.what());
1530		}catch (const std::exception& e) {
1531		SWIG_exception(SWIG_RuntimeError, e.what());
1532		}
#	Line 1537 | Line 1558 | static PyObject *_wrap_objectMap___conta
1558		try {
1559		result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1560
1561	+	}catch (const BossSchedFailure & e) {
1562	+	SWIG_exception(SWIG_ValueError, e.what());
1563		}catch (const std::exception& e) {
1564		SWIG_exception(SWIG_RuntimeError, e.what());
1565		}
#	Line 1583 | Line 1606 | static PyObject *_wrap_delete_objectMap(
1606		try {
1607		delete arg1;
1608
1609	+	}catch (const BossSchedFailure & e) {
1610	+	SWIG_exception(SWIG_ValueError, e.what());
1611		}catch (const std::exception& e) {
1612		SWIG_exception(SWIG_RuntimeError, e.what());
1613		}
#	Line 1616 | Line 1641 | static PyObject *_wrap_new_vector_string
1641		try {
1642		result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1643
1644	+	}catch (const BossSchedFailure & e) {
1645	+	SWIG_exception(SWIG_ValueError, e.what());
1646		}catch (const std::exception& e) {
1647		SWIG_exception(SWIG_RuntimeError, e.what());
1648		}
#	Line 1651 | Line 1678 | static PyObject *_wrap_new_vector_string
1678		try {
1679		result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1680
1681	+	}catch (const BossSchedFailure & e) {
1682	+	SWIG_exception(SWIG_ValueError, e.what());
1683		}catch (const std::exception& e) {
1684		SWIG_exception(SWIG_RuntimeError, e.what());
1685		}
#	Line 1703 | Line 1732 | static PyObject *_wrap_new_vector_string
1732		try {
1733		result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1734
1735	+	}catch (const BossSchedFailure & e) {
1736	+	SWIG_exception(SWIG_ValueError, e.what());
1737		}catch (const std::exception& e) {
1738		SWIG_exception(SWIG_RuntimeError, e.what());
1739		}
#	Line 1830 | Line 1861 | static PyObject *_wrap_vector_string___l
1861		try {
1862		result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1863
1864	+	}catch (const BossSchedFailure & e) {
1865	+	SWIG_exception(SWIG_ValueError, e.what());
1866		}catch (const std::exception& e) {
1867		SWIG_exception(SWIG_RuntimeError, e.what());
1868		}
#	Line 1882 | Line 1915 | static PyObject *_wrap_vector_string___n
1915		try {
1916		result = (bool)((std::vector<std::string > const *)arg1)->empty();
1917
1918	+	}catch (const BossSchedFailure & e) {
1919	+	SWIG_exception(SWIG_ValueError, e.what());
1920		}catch (const std::exception& e) {
1921		SWIG_exception(SWIG_RuntimeError, e.what());
1922		}
#	Line 1904 | Line 1939 | static PyObject *_wrap_vector_string_cle
1939		try {
1940		(arg1)->clear();
1941
1942	+	}catch (const BossSchedFailure & e) {
1943	+	SWIG_exception(SWIG_ValueError, e.what());
1944		}catch (const std::exception& e) {
1945		SWIG_exception(SWIG_RuntimeError, e.what());
1946		}
#	Line 1934 | Line 1971 | static PyObject *_wrap_vector_string_app
1971		try {
1972		(arg1)->push_back(arg2);
1973
1974	+	}catch (const BossSchedFailure & e) {
1975	+	SWIG_exception(SWIG_ValueError, e.what());
1976		}catch (const std::exception& e) {
1977		SWIG_exception(SWIG_RuntimeError, e.what());
1978		}
#	Line 2010 | Line 2049 | static PyObject *_wrap_vector_string___g
2049		try {
2050		result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2051
2052	+	}catch (const BossSchedFailure & e) {
2053	+	SWIG_exception(SWIG_ValueError, e.what());
2054		}catch (const std::exception& e) {
2055		SWIG_exception(SWIG_RuntimeError, e.what());
2056		}
#	Line 2102 | Line 2143 | static PyObject *_wrap_vector_string___s
2143		try {
2144		std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2145
2146	+	}catch (const BossSchedFailure & e) {
2147	+	SWIG_exception(SWIG_ValueError, e.what());
2148		}catch (const std::exception& e) {
2149		SWIG_exception(SWIG_RuntimeError, e.what());
2150		}
#	Line 2149 | Line 2192 | static PyObject *_wrap_vector_string___d
2192		try {
2193		std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2194
2195	+	}catch (const BossSchedFailure & e) {
2196	+	SWIG_exception(SWIG_ValueError, e.what());
2197		}catch (const std::exception& e) {
2198		SWIG_exception(SWIG_RuntimeError, e.what());
2199		}
#	Line 2171 | Line 2216 | static PyObject *_wrap_delete_vector_str
2216		try {
2217		delete arg1;
2218
2219	+	}catch (const BossSchedFailure & e) {
2220	+	SWIG_exception(SWIG_ValueError, e.what());
2221		}catch (const std::exception& e) {
2222		SWIG_exception(SWIG_RuntimeError, e.what());
2223		}
#	Line 2207 | Line 2254 | static PyObject *_wrap_BossSession_show(
2254		try {
2255		result = (PyObject *)BossSession_show(arg1,*arg2);
2256
2257	+	}catch (const BossSchedFailure & e) {
2258	+	SWIG_exception(SWIG_ValueError, e.what());
2259		}catch (const std::exception& e) {
2260		SWIG_exception(SWIG_RuntimeError, e.what());
2261		}
#	Line 2230 | Line 2279 | static PyObject *_wrap_BossSession_CHToo
2279		try {
2280		result = (PyObject *)BossSession_CHTools(arg1);
2281
2282	+	}catch (const BossSchedFailure & e) {
2283	+	SWIG_exception(SWIG_ValueError, e.what());
2284		}catch (const std::exception& e) {
2285		SWIG_exception(SWIG_RuntimeError, e.what());
2286		}
#	Line 2253 | Line 2304 | static PyObject *_wrap_BossSession_Progr
2304		try {
2305		result = (PyObject *)BossSession_ProgramTypes(arg1);
2306
2307	+	}catch (const BossSchedFailure & e) {
2308	+	SWIG_exception(SWIG_ValueError, e.what());
2309		}catch (const std::exception& e) {
2310		SWIG_exception(SWIG_RuntimeError, e.what());
2311		}
#	Line 2276 | Line 2329 | static PyObject *_wrap_BossSession_RTMon
2329		try {
2330		result = (PyObject *)BossSession_RTMons(arg1);
2331
2332	+	}catch (const BossSchedFailure & e) {
2333	+	SWIG_exception(SWIG_ValueError, e.what());
2334		}catch (const std::exception& e) {
2335		SWIG_exception(SWIG_RuntimeError, e.what());
2336		}
#	Line 2299 | Line 2354 | static PyObject *_wrap_BossSession_sched
2354		try {
2355		result = (PyObject *)BossSession_schedulers(arg1);
2356
2357	+	}catch (const BossSchedFailure & e) {
2358	+	SWIG_exception(SWIG_ValueError, e.what());
2359		}catch (const std::exception& e) {
2360		SWIG_exception(SWIG_RuntimeError, e.what());
2361		}
#	Line 2378 | Line 2435 | static PyObject *_wrap_BossSession_sched
2435		try {
2436		result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
2437
2438	+	}catch (const BossSchedFailure & e) {
2439	+	SWIG_exception(SWIG_ValueError, e.what());
2440		}catch (const std::exception& e) {
2441		SWIG_exception(SWIG_RuntimeError, e.what());
2442		}
#	Line 2490 | Line 2549 | static PyObject *_wrap_BossSession_query
2549		try {
2550		result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2551
2552	+	}catch (const BossSchedFailure & e) {
2553	+	SWIG_exception(SWIG_ValueError, e.what());
2554		}catch (const std::exception& e) {
2555		SWIG_exception(SWIG_RuntimeError, e.what());
2556		}
#	Line 2504 | Line 2565 | static PyObject *_wrap_BossSession_query
2565		static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2566		PyObject *resultobj;
2567		std::string arg1 = (std::string) "" ;
2568	+	std::string arg2 = (std::string) "2" ;
2569	+	std::string arg3 = (std::string) "" ;
2570		BossSession *result;
2571		PyObject * obj0 = 0 ;
2572	+	PyObject * obj1 = 0 ;
2573	+	PyObject * obj2 = 0 ;
2574
2575	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2575	>	if(!PyArg_ParseTuple(args,(char *)"|OOO:new_BossSession",&obj0,&obj1,&obj2)) goto fail;
2576		if (obj0) {
2577		{
2578		if (PyString_Check(obj0))
#	Line 2516 | Line 2581 | static PyObject *_wrap_new_BossSession(P
2581		SWIG_exception(SWIG_TypeError, "string expected");
2582		}
2583		}
2584	+	if (obj1) {
2585	+	{
2586	+	if (PyString_Check(obj1))
2587	+	arg2 = std::string(PyString_AsString(obj1));
2588	+	else
2589	+	SWIG_exception(SWIG_TypeError, "string expected");
2590	+	}
2591	+	}
2592	+	if (obj2) {
2593	+	{
2594	+	if (PyString_Check(obj2))
2595	+	arg3 = std::string(PyString_AsString(obj2));
2596	+	else
2597	+	SWIG_exception(SWIG_TypeError, "string expected");
2598	+	}
2599	+	}
2600		{
2601		try {
2602	<	result = (BossSession *)new BossSession(arg1);
2602	>	result = (BossSession *)new BossSession(arg1,arg2,arg3);
2603
2604	+	}catch (const BossSchedFailure & e) {
2605	+	SWIG_exception(SWIG_ValueError, e.what());
2606		}catch (const std::exception& e) {
2607		SWIG_exception(SWIG_RuntimeError, e.what());
2608		}
#	Line 2542 | Line 2625 | static PyObject *_wrap_delete_BossSessio
2625		try {
2626		delete arg1;
2627
2628	+	}catch (const BossSchedFailure & e) {
2629	+	SWIG_exception(SWIG_ValueError, e.what());
2630		}catch (const std::exception& e) {
2631		SWIG_exception(SWIG_RuntimeError, e.what());
2632		}
#	Line 2564 | Line 2649 | static PyObject *_wrap_BossSession_reset
2649		try {
2650		(arg1)->resetDB();
2651
2652	+	}catch (const BossSchedFailure & e) {
2653	+	SWIG_exception(SWIG_ValueError, e.what());
2654		}catch (const std::exception& e) {
2655		SWIG_exception(SWIG_RuntimeError, e.what());
2656		}
#	Line 2586 | Line 2673 | static PyObject *_wrap_BossSession_clear
2673		try {
2674		(arg1)->clear();
2675
2676	+	}catch (const BossSchedFailure & e) {
2677	+	SWIG_exception(SWIG_ValueError, e.what());
2678		}catch (const std::exception& e) {
2679		SWIG_exception(SWIG_RuntimeError, e.what());
2680		}
#	Line 2623 | Line 2712 | static PyObject *_wrap_BossSession_makeB
2712		try {
2713		result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2714
2715	+	}catch (const BossSchedFailure & e) {
2716	+	SWIG_exception(SWIG_ValueError, e.what());
2717		}catch (const std::exception& e) {
2718		SWIG_exception(SWIG_RuntimeError, e.what());
2719		}
#	Line 2648 | Line 2739 | static PyObject *_wrap_BossSession_destr
2739		try {
2740		(arg1)->destroyBossTask(arg2);
2741
2742	+	}catch (const BossSchedFailure & e) {
2743	+	SWIG_exception(SWIG_ValueError, e.what());
2744		}catch (const std::exception& e) {
2745		SWIG_exception(SWIG_RuntimeError, e.what());
2746		}
#	Line 2671 | Line 2764 | static PyObject *_wrap_BossSession_defau
2764		try {
2765		result = (arg1)->defaultCHTool();
2766
2767	+	}catch (const BossSchedFailure & e) {
2768	+	SWIG_exception(SWIG_ValueError, e.what());
2769		}catch (const std::exception& e) {
2770		SWIG_exception(SWIG_RuntimeError, e.what());
2771		}
#	Line 2696 | Line 2791 | static PyObject *_wrap_BossSession_defau
2791		try {
2792		result = (arg1)->defaultProgramType();
2793
2794	+	}catch (const BossSchedFailure & e) {
2795	+	SWIG_exception(SWIG_ValueError, e.what());
2796		}catch (const std::exception& e) {
2797		SWIG_exception(SWIG_RuntimeError, e.what());
2798		}
#	Line 2721 | Line 2818 | static PyObject *_wrap_BossSession_defau
2818		try {
2819		result = (arg1)->defaultRTMon();
2820
2821	+	}catch (const BossSchedFailure & e) {
2822	+	SWIG_exception(SWIG_ValueError, e.what());
2823		}catch (const std::exception& e) {
2824		SWIG_exception(SWIG_RuntimeError, e.what());
2825		}
#	Line 2746 | Line 2845 | static PyObject *_wrap_BossSession_defau
2845		try {
2846		result = (arg1)->defaultScheduler();
2847
2848	+	}catch (const BossSchedFailure & e) {
2849	+	SWIG_exception(SWIG_ValueError, e.what());
2850		}catch (const std::exception& e) {
2851		SWIG_exception(SWIG_RuntimeError, e.what());
2852		}
#	Line 2771 | Line 2872 | static PyObject *_wrap_BossSession_versi
2872		try {
2873		result = (arg1)->version();
2874
2875	+	}catch (const BossSchedFailure & e) {
2876	+	SWIG_exception(SWIG_ValueError, e.what());
2877		}catch (const std::exception& e) {
2878		SWIG_exception(SWIG_RuntimeError, e.what());
2879		}
#	Line 2796 | Line 2899 | static PyObject *_wrap_BossSession_clien
2899		try {
2900		result = (arg1)->clientID();
2901
2902	+	}catch (const BossSchedFailure & e) {
2903	+	SWIG_exception(SWIG_ValueError, e.what());
2904		}catch (const std::exception& e) {
2905		SWIG_exception(SWIG_RuntimeError, e.what());
2906		}
#	Line 2827 | Line 2932 | static PyObject *_wrap_BossSession_showC
2932		try {
2933		result = (int)(arg1)->showConfigs(arg2);
2934
2935	+	}catch (const BossSchedFailure & e) {
2936	+	SWIG_exception(SWIG_ValueError, e.what());
2937		}catch (const std::exception& e) {
2938		SWIG_exception(SWIG_RuntimeError, e.what());
2939		}
#	Line 2880 | Line 2987 | static PyObject *_wrap_BossSession_RTupd
2987		try {
2988		result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2989
2990	+	}catch (const BossSchedFailure & e) {
2991	+	SWIG_exception(SWIG_ValueError, e.what());
2992		}catch (const std::exception& e) {
2993		SWIG_exception(SWIG_RuntimeError, e.what());
2994		}
#	Line 2959 | Line 3068 | static PyObject *_wrap_BossSession_listM
3068		try {
3069		result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
3070
3071	+	}catch (const BossSchedFailure & e) {
3072	+	SWIG_exception(SWIG_ValueError, e.what());
3073		}catch (const std::exception& e) {
3074		SWIG_exception(SWIG_RuntimeError, e.what());
3075		}
#	Line 3069 | Line 3180 | static PyObject *_wrap_BossSession_sched
3180		try {
3181		(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3182
3183	+	}catch (const BossSchedFailure & e) {
3184	+	SWIG_exception(SWIG_ValueError, e.what());
3185		}catch (const std::exception& e) {
3186		SWIG_exception(SWIG_RuntimeError, e.what());
3187		}
#	Line 3148 | Line 3261 | static PyObject *_wrap_BossSession_selec
3261		try {
3262		result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3263
3264	+	}catch (const BossSchedFailure & e) {
3265	+	SWIG_exception(SWIG_ValueError, e.what());
3266		}catch (const std::exception& e) {
3267		SWIG_exception(SWIG_RuntimeError, e.what());
3268		}
#	Line 3265 | Line 3380 | static PyObject *_wrap_BossSession_query
3380		try {
3381		result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3382
3383	+	}catch (const BossSchedFailure & e) {
3384	+	SWIG_exception(SWIG_ValueError, e.what());
3385		}catch (const std::exception& e) {
3386		SWIG_exception(SWIG_RuntimeError, e.what());
3387		}
#	Line 3337 | Line 3454 | static PyObject *_wrap_new_BossTaskExcep
3454		try {
3455		result = (BossTaskException *)new BossTaskException((char const *)arg1);
3456
3457	+	}catch (const BossSchedFailure & e) {
3458	+	SWIG_exception(SWIG_ValueError, e.what());
3459		}catch (const std::exception& e) {
3460		SWIG_exception(SWIG_RuntimeError, e.what());
3461		}
#	Line 3360 | Line 3479 | static PyObject *_wrap_BossTaskException
3479		try {
3480		result = (char *)((BossTaskException const *)arg1)->what();
3481
3482	+	}catch (const BossSchedFailure & e) {
3483	+	SWIG_exception(SWIG_ValueError, e.what());
3484		}catch (const std::exception& e) {
3485		SWIG_exception(SWIG_RuntimeError, e.what());
3486		}
#	Line 3382 | Line 3503 | static PyObject *_wrap_delete_BossTaskEx
3503		try {
3504		delete arg1;
3505
3506	+	}catch (const BossSchedFailure & e) {
3507	+	SWIG_exception(SWIG_ValueError, e.what());
3508		}catch (const std::exception& e) {
3509		SWIG_exception(SWIG_RuntimeError, e.what());
3510		}
#	Line 3421 | Line 3544 | static PyObject *_wrap_BossTask_appendTo
3544		try {
3545		result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3546
3547	+	}catch (const BossSchedFailure & e) {
3548	+	SWIG_exception(SWIG_ValueError, e.what());
3549		}catch (const std::exception& e) {
3550		SWIG_exception(SWIG_RuntimeError, e.what());
3551		}
#	Line 3450 | Line 3575 | static PyObject *_wrap_BossTask_jobDict(
3575		try {
3576		result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3577
3578	+	}catch (const BossSchedFailure & e) {
3579	+	SWIG_exception(SWIG_ValueError, e.what());
3580		}catch (const std::exception& e) {
3581		SWIG_exception(SWIG_RuntimeError, e.what());
3582		}
#	Line 3473 | Line 3600 | static PyObject *_wrap_BossTask_jobsDict
3600		try {
3601		result = (PyObject *)BossTask_jobsDict(arg1);
3602
3603	+	}catch (const BossSchedFailure & e) {
3604	+	SWIG_exception(SWIG_ValueError, e.what());
3605		}catch (const std::exception& e) {
3606		SWIG_exception(SWIG_RuntimeError, e.what());
3607		}
#	Line 3502 | Line 3631 | static PyObject *_wrap_BossTask_progDict
3631		try {
3632		result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3633
3634	+	}catch (const BossSchedFailure & e) {
3635	+	SWIG_exception(SWIG_ValueError, e.what());
3636		}catch (const std::exception& e) {
3637		SWIG_exception(SWIG_RuntimeError, e.what());
3638		}
#	Line 3536 | Line 3667 | static PyObject *_wrap_BossTask_jobProgr
3667		try {
3668		result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3669
3670	+	}catch (const BossSchedFailure & e) {
3671	+	SWIG_exception(SWIG_ValueError, e.what());
3672		}catch (const std::exception& e) {
3673		SWIG_exception(SWIG_RuntimeError, e.what());
3674		}
#	Line 3559 | Line 3692 | static PyObject *_wrap_new_BossTask__SWI
3692		try {
3693		result = (BossTask *)new BossTask(arg1);
3694
3695	+	}catch (const BossSchedFailure & e) {
3696	+	SWIG_exception(SWIG_ValueError, e.what());
3697		}catch (const std::exception& e) {
3698		SWIG_exception(SWIG_RuntimeError, e.what());
3699		}
#	Line 3593 | Line 3728 | static PyObject *_wrap_new_BossTask__SWI
3728		try {
3729		result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3730
3731	+	}catch (const BossSchedFailure & e) {
3732	+	SWIG_exception(SWIG_ValueError, e.what());
3733		}catch (const std::exception& e) {
3734		SWIG_exception(SWIG_RuntimeError, e.what());
3735		}
#	Line 3615 | Line 3752 | static PyObject *_wrap_delete_BossTask(P
3752		try {
3753		delete arg1;
3754
3755	+	}catch (const BossSchedFailure & e) {
3756	+	SWIG_exception(SWIG_ValueError, e.what());
3757		}catch (const std::exception& e) {
3758		SWIG_exception(SWIG_RuntimeError, e.what());
3759		}
#	Line 3641 | Line 3780 | static PyObject *_wrap_new_BossTask__SWI
3780		try {
3781		result = (BossTask *)new BossTask((BossTask const &)*arg1);
3782
3783	+	}catch (const BossSchedFailure & e) {
3784	+	SWIG_exception(SWIG_ValueError, e.what());
3785		}catch (const std::exception& e) {
3786		SWIG_exception(SWIG_RuntimeError, e.what());
3787		}
#	Line 3732 | Line 3873 | static PyObject *_wrap_BossTask_id(PyObj
3873		result = (std::string *) &_result_ref;
3874		}
3875
3876	+	}catch (const BossSchedFailure & e) {
3877	+	SWIG_exception(SWIG_ValueError, e.what());
3878		}catch (const std::exception& e) {
3879		SWIG_exception(SWIG_RuntimeError, e.what());
3880		}
#	Line 3760 | Line 3903 | static PyObject *_wrap_BossTask_name(PyO
3903		result = (std::string *) &_result_ref;
3904		}
3905
3906	+	}catch (const BossSchedFailure & e) {
3907	+	SWIG_exception(SWIG_ValueError, e.what());
3908		}catch (const std::exception& e) {
3909		SWIG_exception(SWIG_RuntimeError, e.what());
3910		}
#	Line 3785 | Line 3930 | static PyObject *_wrap_BossTask_taskMap(
3930		try {
3931		result = ((BossTask const *)arg1)->taskMap();
3932
3933	+	}catch (const BossSchedFailure & e) {
3934	+	SWIG_exception(SWIG_ValueError, e.what());
3935		}catch (const std::exception& e) {
3936		SWIG_exception(SWIG_RuntimeError, e.what());
3937		}
#	Line 3815 | Line 3962 | static PyObject *_wrap_BossTask_job_begi
3962		try {
3963		result = ((BossTask const *)arg1)->job_begin();
3964
3965	+	}catch (const BossSchedFailure & e) {
3966	+	SWIG_exception(SWIG_ValueError, e.what());
3967		}catch (const std::exception& e) {
3968		SWIG_exception(SWIG_RuntimeError, e.what());
3969		}
#	Line 3842 | Line 3991 | static PyObject *_wrap_BossTask_job_end(
3991		try {
3992		result = ((BossTask const *)arg1)->job_end();
3993
3994	+	}catch (const BossSchedFailure & e) {
3995	+	SWIG_exception(SWIG_ValueError, e.what());
3996		}catch (const std::exception& e) {
3997		SWIG_exception(SWIG_RuntimeError, e.what());
3998		}
#	Line 3869 | Line 4020 | static PyObject *_wrap_BossTask_jobsMap(
4020		try {
4021		result = ((BossTask const *)arg1)->jobsMap();
4022
4023	+	}catch (const BossSchedFailure & e) {
4024	+	SWIG_exception(SWIG_ValueError, e.what());
4025		}catch (const std::exception& e) {
4026		SWIG_exception(SWIG_RuntimeError, e.what());
4027		}
#	Line 3907 | Line 4060 | static PyObject *_wrap_BossTask_jobMap__
4060		try {
4061		result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4062
4063	+	}catch (const BossSchedFailure & e) {
4064	+	SWIG_exception(SWIG_ValueError, e.what());
4065		}catch (const std::exception& e) {
4066		SWIG_exception(SWIG_RuntimeError, e.what());
4067		}
#	Line 3936 | Line 4091 | static PyObject *_wrap_BossTask_jobMap__
4091		try {
4092		result = ((BossTask const *)arg1)->jobMap(arg2);
4093
4094	+	}catch (const BossSchedFailure & e) {
4095	+	SWIG_exception(SWIG_ValueError, e.what());
4096		}catch (const std::exception& e) {
4097		SWIG_exception(SWIG_RuntimeError, e.what());
4098		}
#	Line 4041 | Line 4198 | static PyObject *_wrap_BossTask_programs
4198		try {
4199		result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4200
4201	+	}catch (const BossSchedFailure & e) {
4202	+	SWIG_exception(SWIG_ValueError, e.what());
4203		}catch (const std::exception& e) {
4204		SWIG_exception(SWIG_RuntimeError, e.what());
4205		}
#	Line 4071 | Line 4230 | static PyObject *_wrap_BossTask_queryJob
4230		try {
4231		result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4232
4233	+	}catch (const BossSchedFailure & e) {
4234	+	SWIG_exception(SWIG_ValueError, e.what());
4235		}catch (const std::exception& e) {
4236		SWIG_exception(SWIG_RuntimeError, e.what());
4237		}
#	Line 4122 | Line 4283 | static PyObject *_wrap_BossTask_declare_
4283		try {
4284		(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4285
4286	+	}catch (const BossSchedFailure & e) {
4287	+	SWIG_exception(SWIG_ValueError, e.what());
4288		}catch (const std::exception& e) {
4289		SWIG_exception(SWIG_RuntimeError, e.what());
4290		}
#	Line 4161 | Line 4324 | static PyObject *_wrap_BossTask_declare_
4324		try {
4325		(arg1)->declare(arg2,(std::string const &)*arg3);
4326
4327	+	}catch (const BossSchedFailure & e) {
4328	+	SWIG_exception(SWIG_ValueError, e.what());
4329		}catch (const std::exception& e) {
4330		SWIG_exception(SWIG_RuntimeError, e.what());
4331		}
#	Line 4260 | Line 4425 | static PyObject *_wrap_BossTask_remove(P
4425		try {
4426		(arg1)->remove();
4427
4428	+	}catch (const BossSchedFailure & e) {
4429	+	SWIG_exception(SWIG_ValueError, e.what());
4430		}catch (const std::exception& e) {
4431		SWIG_exception(SWIG_RuntimeError, e.what());
4432		}
#	Line 4296 | Line 4463 | static PyObject *_wrap_BossTask_archive(
4463		try {
4464		(arg1)->archive((std::string const &)*arg2);
4465
4466	+	}catch (const BossSchedFailure & e) {
4467	+	SWIG_exception(SWIG_ValueError, e.what());
4468		}catch (const std::exception& e) {
4469		SWIG_exception(SWIG_RuntimeError, e.what());
4470		}
#	Line 4395 | Line 4564 | static PyObject *_wrap_BossTask_submit(P
4564		try {
4565		result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
4566
4567	+	}catch (const BossSchedFailure & e) {
4568	+	SWIG_exception(SWIG_ValueError, e.what());
4569		}catch (const std::exception& e) {
4570		SWIG_exception(SWIG_RuntimeError, e.what());
4571		}
#	Line 4435 | Line 4606 | static PyObject *_wrap_BossTask_reSubmit
4606		try {
4607		result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4608
4609	+	}catch (const BossSchedFailure & e) {
4610	+	SWIG_exception(SWIG_ValueError, e.what());
4611		}catch (const std::exception& e) {
4612		SWIG_exception(SWIG_RuntimeError, e.what());
4613		}
#	Line 4475 | Line 4648 | static PyObject *_wrap_BossTask_kill(PyO
4648		try {
4649		result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4650
4651	+	}catch (const BossSchedFailure & e) {
4652	+	SWIG_exception(SWIG_ValueError, e.what());
4653		}catch (const std::exception& e) {
4654		SWIG_exception(SWIG_RuntimeError, e.what());
4655		}
#	Line 4538 | Line 4713 | static PyObject *_wrap_BossTask_getOutpu
4713		try {
4714		result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4715
4716	<	}catch (const std::exception& e) {
4717	<	SWIG_exception(SWIG_RuntimeError, e.what());
4543	<	}
4544	<	}
4545	<	resultobj = PyInt_FromLong((long)result);
4546	<	return resultobj;
4547	<	fail:
4548	<	return NULL;
4549	<	}
4550	<
4551	<
4552	<	static PyObject *_wrap_BossTask_getAllOutput(PyObject *self, PyObject *args) {
4553	<	PyObject *resultobj;
4554	<	BossTask *arg1 = (BossTask *) 0 ;
4555	<	std::string const &arg2_defvalue = "" ;
4556	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
4557	<	bool arg3 = (bool) false ;
4558	<	bool arg4 = (bool) false ;
4559	<	int result;
4560	<	std::string temp2 ;
4561	<	PyObject * obj0 = 0 ;
4562	<	PyObject * obj1 = 0 ;
4563	<	PyObject * obj2 = 0 ;
4564	<	PyObject * obj3 = 0 ;
4565	<
4566	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4567	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4568	<	if (obj1) {
4569	<	{
4570	<	if (PyString_Check(obj1)) {
4571	<	temp2 = std::string(PyString_AsString(obj1));
4572	<	arg2 = &temp2;
4573	<	}else {
4574	<	SWIG_exception(SWIG_TypeError, "string expected");
4575	<	}
4576	<	}
4577	<	}
4578	<	if (obj2) {
4579	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4580	<	if (PyErr_Occurred()) SWIG_fail;
4581	<	}
4582	<	if (obj3) {
4583	<	arg4 = PyInt_AsLong(obj3) ? true : false;
4584	<	if (PyErr_Occurred()) SWIG_fail;
4585	<	}
4586	<	{
4587	<	try {
4588	<	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3,arg4);
4589	<
4716	>	}catch (const BossSchedFailure & e) {
4717	>	SWIG_exception(SWIG_ValueError, e.what());
4718		}catch (const std::exception& e) {
4719		SWIG_exception(SWIG_RuntimeError, e.what());
4720		}
#	Line 4679 | Line 4807 | static PyObject *_wrap_BossTask_load(PyO
4807		try {
4808		result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4809
4810	+	}catch (const BossSchedFailure & e) {
4811	+	SWIG_exception(SWIG_ValueError, e.what());
4812		}catch (const std::exception& e) {
4813		SWIG_exception(SWIG_RuntimeError, e.what());
4814		}
#	Line 4777 | Line 4907 | static PyObject *_wrap_BossTask_query(Py
4907		try {
4908		result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
4909
4910	+	}catch (const BossSchedFailure & e) {
4911	+	SWIG_exception(SWIG_ValueError, e.what());
4912		}catch (const std::exception& e) {
4913		SWIG_exception(SWIG_RuntimeError, e.what());
4914		}
#	Line 4836 | Line 4968 | static PyObject *_wrap_BossTask_query_ou
4968		try {
4969		((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
4970
4971	+	}catch (const BossSchedFailure & e) {
4972	+	SWIG_exception(SWIG_ValueError, e.what());
4973		}catch (const std::exception& e) {
4974		SWIG_exception(SWIG_RuntimeError, e.what());
4975		}
#	Line 4858 | Line 4992 | static PyObject *_wrap_BossTask_clear(Py
4992		try {
4993		(arg1)->clear();
4994
4995	+	}catch (const BossSchedFailure & e) {
4996	+	SWIG_exception(SWIG_ValueError, e.what());
4997		}catch (const std::exception& e) {
4998		SWIG_exception(SWIG_RuntimeError, e.what());
4999		}
#	Line 4879 | Line 5015 | static PyObject * BossTask_swigregister(
5015		static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5016		PyObject *resultobj;
5017		std::string arg1 = (std::string) "" ;
5018	<	bool arg2 = (bool) false ;
5018	>	std::string arg2 = (std::string) "2" ;
5019	>	std::string arg3 = (std::string) "" ;
5020	>	bool arg4 = (bool) false ;
5021		BossAdministratorSession *result;
5022		PyObject * obj0 = 0 ;
5023		PyObject * obj1 = 0 ;
5024	+	PyObject * obj2 = 0 ;
5025	+	PyObject * obj3 = 0 ;
5026
5027	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
5027	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
5028		if (obj0) {
5029		{
5030		if (PyString_Check(obj0))
#	Line 4894 | Line 5034 | static PyObject *_wrap_new_BossAdministr
5034		}
5035		}
5036		if (obj1) {
5037	<	arg2 = PyInt_AsLong(obj1) ? true : false;
5037	>	{
5038	>	if (PyString_Check(obj1))
5039	>	arg2 = std::string(PyString_AsString(obj1));
5040	>	else
5041	>	SWIG_exception(SWIG_TypeError, "string expected");
5042	>	}
5043	>	}
5044	>	if (obj2) {
5045	>	{
5046	>	if (PyString_Check(obj2))
5047	>	arg3 = std::string(PyString_AsString(obj2));
5048	>	else
5049	>	SWIG_exception(SWIG_TypeError, "string expected");
5050	>	}
5051	>	}
5052	>	if (obj3) {
5053	>	arg4 = PyInt_AsLong(obj3) ? true : false;
5054		if (PyErr_Occurred()) SWIG_fail;
5055		}
5056		{
5057		try {
5058	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
5058	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4);
5059
5060	+	}catch (const BossSchedFailure & e) {
5061	+	SWIG_exception(SWIG_ValueError, e.what());
5062		}catch (const std::exception& e) {
5063		SWIG_exception(SWIG_RuntimeError, e.what());
5064		}
#	Line 4923 | Line 5081 | static PyObject *_wrap_delete_BossAdmini
5081		try {
5082		delete arg1;
5083
5084	+	}catch (const BossSchedFailure & e) {
5085	+	SWIG_exception(SWIG_ValueError, e.what());
5086		}catch (const std::exception& e) {
5087		SWIG_exception(SWIG_RuntimeError, e.what());
5088		}
#	Line 4946 | Line 5106 | static PyObject *_wrap_BossAdministrator
5106		try {
5107		result = (int)(arg1)->configureDB();
5108
5109	+	}catch (const BossSchedFailure & e) {
5110	+	SWIG_exception(SWIG_ValueError, e.what());
5111		}catch (const std::exception& e) {
5112		SWIG_exception(SWIG_RuntimeError, e.what());
5113		}
#	Line 4980 | Line 5142 | static PyObject *_wrap_BossAdministrator
5142		try {
5143		result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5144
5145	+	}catch (const BossSchedFailure & e) {
5146	+	SWIG_exception(SWIG_ValueError, e.what());
5147		}catch (const std::exception& e) {
5148		SWIG_exception(SWIG_RuntimeError, e.what());
5149		}
#	Line 5014 | Line 5178 | static PyObject *_wrap_BossAdministrator
5178		try {
5179		result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5180
5181	+	}catch (const BossSchedFailure & e) {
5182	+	SWIG_exception(SWIG_ValueError, e.what());
5183		}catch (const std::exception& e) {
5184		SWIG_exception(SWIG_RuntimeError, e.what());
5185		}
#	Line 5048 | Line 5214 | static PyObject *_wrap_BossAdministrator
5214		try {
5215		result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5216
5217	+	}catch (const BossSchedFailure & e) {
5218	+	SWIG_exception(SWIG_ValueError, e.what());
5219		}catch (const std::exception& e) {
5220		SWIG_exception(SWIG_RuntimeError, e.what());
5221		}
#	Line 5082 | Line 5250 | static PyObject *_wrap_BossAdministrator
5250		try {
5251		result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5252
5253	+	}catch (const BossSchedFailure & e) {
5254	+	SWIG_exception(SWIG_ValueError, e.what());
5255		}catch (const std::exception& e) {
5256		SWIG_exception(SWIG_RuntimeError, e.what());
5257		}
#	Line 5116 | Line 5286 | static PyObject *_wrap_BossAdministrator
5286		try {
5287		result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5288
5289	+	}catch (const BossSchedFailure & e) {
5290	+	SWIG_exception(SWIG_ValueError, e.what());
5291		}catch (const std::exception& e) {
5292		SWIG_exception(SWIG_RuntimeError, e.what());
5293		}
#	Line 5182 | Line 5354 | static PyObject *_wrap_BossAdministrator
5354		try {
5355		result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5356
5357	+	}catch (const BossSchedFailure & e) {
5358	+	SWIG_exception(SWIG_ValueError, e.what());
5359		}catch (const std::exception& e) {
5360		SWIG_exception(SWIG_RuntimeError, e.what());
5361		}
#	Line 5272 | Line 5446 | static PyObject *_wrap_BossAdministrator
5446		try {
5447		result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5448
5449	+	}catch (const BossSchedFailure & e) {
5450	+	SWIG_exception(SWIG_ValueError, e.what());
5451		}catch (const std::exception& e) {
5452		SWIG_exception(SWIG_RuntimeError, e.what());
5453		}
#	Line 5348 | Line 5524 | static PyObject *_wrap_BossAdministrator
5524		try {
5525		result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5526
5527	+	}catch (const BossSchedFailure & e) {
5528	+	SWIG_exception(SWIG_ValueError, e.what());
5529		}catch (const std::exception& e) {
5530		SWIG_exception(SWIG_RuntimeError, e.what());
5531		}
#	Line 5377 | Line 5555 | static PyObject *_wrap_BossAdministrator
5555		std::string arg13 = (std::string) "" ;
5556		bool arg14 = (bool) false ;
5557		bool arg15 = (bool) false ;
5558	+	bool arg16 = (bool) false ;
5559	+	bool arg17 = (bool) false ;
5560		int result;
5561		std::string temp2 ;
5562		std::string temp11 ;
#	Line 5395 | Line 5575 | static PyObject *_wrap_BossAdministrator
5575		PyObject * obj12 = 0 ;
5576		PyObject * obj13 = 0 ;
5577		PyObject * obj14 = 0 ;
5578	+	PyObject * obj15 = 0 ;
5579	+	PyObject * obj16 = 0 ;
5580
5581	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) goto fail;
5581	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) goto fail;
5582		if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5583		{
5584		if (PyString_Check(obj1)) {
#	Line 5504 | Line 5686 | static PyObject *_wrap_BossAdministrator
5686		arg15 = PyInt_AsLong(obj14) ? true : false;
5687		if (PyErr_Occurred()) SWIG_fail;
5688		}
5689	+	if (obj15) {
5690	+	arg16 = PyInt_AsLong(obj15) ? true : false;
5691	+	if (PyErr_Occurred()) SWIG_fail;
5692	+	}
5693	+	if (obj16) {
5694	+	arg17 = PyInt_AsLong(obj16) ? true : false;
5695	+	if (PyErr_Occurred()) SWIG_fail;
5696	+	}
5697		{
5698		try {
5699	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
5699	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15,arg16,arg17);
5700
5701	+	}catch (const BossSchedFailure & e) {
5702	+	SWIG_exception(SWIG_ValueError, e.what());
5703		}catch (const std::exception& e) {
5704		SWIG_exception(SWIG_RuntimeError, e.what());
5705		}
#	Line 5531 | Line 5723 | static PyObject *_wrap_BossAdministrator
5723		try {
5724		result = (arg1)->help();
5725
5726	+	}catch (const BossSchedFailure & e) {
5727	+	SWIG_exception(SWIG_ValueError, e.what());
5728		}catch (const std::exception& e) {
5729		SWIG_exception(SWIG_RuntimeError, e.what());
5730		}
#	Line 5570 | Line 5764 | static PyObject *_wrap_BossAdministrator
5764		try {
5765		result = (arg1)->SQL(arg2,arg3);
5766
5767	+	}catch (const BossSchedFailure & e) {
5768	+	SWIG_exception(SWIG_ValueError, e.what());
5769		}catch (const std::exception& e) {
5770		SWIG_exception(SWIG_RuntimeError, e.what());
5771		}
#	Line 5642 | Line 5838 | static PyObject *_wrap_BossAdministrator
5838		try {
5839		result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
5840
5841	+	}catch (const BossSchedFailure & e) {
5842	+	SWIG_exception(SWIG_ValueError, e.what());
5843		}catch (const std::exception& e) {
5844		SWIG_exception(SWIG_RuntimeError, e.what());
5845		}
#	Line 5673 | Line 5871 | static PyObject *_wrap_BossAdministrator
5871		try {
5872		result = (int)(arg1)->registerPlugins(arg2);
5873
5874	+	}catch (const BossSchedFailure & e) {
5875	+	SWIG_exception(SWIG_ValueError, e.what());
5876		}catch (const std::exception& e) {
5877		SWIG_exception(SWIG_RuntimeError, e.what());
5878		}
#	Line 5776 | Line 5976 | static PyMethodDef SwigMethods[] = {
5976		{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
5977		{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
5978		{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
5779	–	{ (char *)"BossTask_getAllOutput", _wrap_BossTask_getAllOutput, METH_VARARGS },
5979		{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
5980		{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
5981		{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },

Diff Legend

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