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.9 by gcodispo, Mon Oct 30 10:44:38 2006 UTC vs.
Revision 1.20 by gcodispo, Thu Dec 14 11:40:04 2006 UTC

#	Line 1 | Line 1
1		/* ----------------------------------------------------------------------------
2		* This file was automatically generated by SWIG (http://www.swig.org).
3	<	* Version 1.3.29
3	>	* Version 1.3.19
4		*
5		* This file is not intended to be easily readable and contains a number of
6		* coding conventions designed to improve portability and efficiency. Do not make
#	Line 9 | Line 9
9		* ----------------------------------------------------------------------------- */
10
11		#define SWIGPYTHON
12	–	#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
12
13		#ifdef __cplusplus
14		template<class T> class SwigValueWrapper {
15		T *tt;
16		public:
17	<	SwigValueWrapper() : tt(0) { }
18	<	SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19	<	SwigValueWrapper(const T& t) : tt(new T(t)) { }
20	<	~SwigValueWrapper() { delete tt; }
21	<	SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22	<	operator T&() const { return *tt; }
24	<	T *operator&() { return tt; }
25	<	private:
26	<	SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27	<	};
28	<	#endif
29	<
30	<	/* -----------------------------------------------------------------------------
31	<	*  This section contains generic SWIG labels for method/variable
32	<	*  declarations/attributes, and other compiler dependent labels.
33	<	* ----------------------------------------------------------------------------- */
34	<
35	<	/* template workaround for compilers that cannot correctly implement the C++ standard */
36	<	#ifndef SWIGTEMPLATEDISAMBIGUATOR
37	<	# if defined(__SUNPRO_CC)
38	<	#   if (__SUNPRO_CC <= 0x560)
39	<	#     define SWIGTEMPLATEDISAMBIGUATOR template
40	<	#   else
41	<	#     define SWIGTEMPLATEDISAMBIGUATOR
42	<	#   endif
43	<	# else
44	<	#   define SWIGTEMPLATEDISAMBIGUATOR
45	<	# endif
46	<	#endif
47	<
48	<	/* inline attribute */
49	<	#ifndef SWIGINLINE
50	<	# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51	<	#   define SWIGINLINE inline
52	<	# else
53	<	#   define SWIGINLINE
54	<	# endif
55	<	#endif
56	<
57	<	/* attribute recognised by some compilers to avoid 'unused' warnings */
58	<	#ifndef SWIGUNUSED
59	<	# if defined(__GNUC__)
60	<	#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61	<	#     define SWIGUNUSED __attribute__ ((__unused__))
62	<	#   else
63	<	#     define SWIGUNUSED
64	<	#   endif
65	<	# elif defined(__ICC)
66	<	#   define SWIGUNUSED __attribute__ ((__unused__))
67	<	# else
68	<	#   define SWIGUNUSED
69	<	# endif
70	<	#endif
71	<
72	<	#ifndef SWIGUNUSEDPARM
73	<	# ifdef __cplusplus
74	<	#   define SWIGUNUSEDPARM(p)
75	<	# else
76	<	#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
77	<	# endif
78	<	#endif
79	<
80	<	/* internal SWIG method */
81	<	#ifndef SWIGINTERN
82	<	# define SWIGINTERN static SWIGUNUSED
17	>	inline SwigValueWrapper() : tt(0) { }
18	>	inline ~SwigValueWrapper() { if (tt) delete tt; }
19	>	inline SwigValueWrapper& operator=(const T& t) { tt = new T(t); return *this; }
20	>	inline operator T&() const { return *tt; }
21	>	inline T *operator&() { return tt; }
22	>	};
23		#endif
24
85	–	/* internal inline SWIG method */
86	–	#ifndef SWIGINTERNINLINE
87	–	# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88	–	#endif
89	–
90	–	/* exporting methods */
91	–	#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92	–	#  ifndef GCC_HASCLASSVISIBILITY
93	–	#    define GCC_HASCLASSVISIBILITY
94	–	#  endif
95	–	#endif
96	–
97	–	#ifndef SWIGEXPORT
98	–	# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99	–	#   if defined(STATIC_LINKED)
100	–	#     define SWIGEXPORT
101	–	#   else
102	–	#     define SWIGEXPORT __declspec(dllexport)
103	–	#   endif
104	–	# else
105	–	#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106	–	#     define SWIGEXPORT __attribute__ ((visibility("default")))
107	–	#   else
108	–	#     define SWIGEXPORT
109	–	#   endif
110	–	# endif
111	–	#endif
112	–
113	–	/* calling conventions for Windows */
114	–	#ifndef SWIGSTDCALL
115	–	# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116	–	#   define SWIGSTDCALL __stdcall
117	–	# else
118	–	#   define SWIGSTDCALL
119	–	# endif
120	–	#endif
121	–
122	–	/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123	–	#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124	–	# define _CRT_SECURE_NO_DEPRECATE
125	–	#endif
25
26	+	#include "Python.h"
27
28	<	/* Python.h has to appear first */
29	<	#include <Python.h>
130	<
131	<	/* -----------------------------------------------------------------------------
132	<	* swigrun.swg
28	>	/***********************************************************************
29	>	* common.swg
30		*
31	<	* This file contains generic CAPI SWIG runtime support for pointer
32	<	* type checking.
33	<	* ----------------------------------------------------------------------------- */
34	<
35	<	/* This should only be incremented when either the layout of swig_type_info changes,
36	<	or for whatever reason, the runtime changes incompatibly */
37	<	#define SWIG_RUNTIME_VERSION "2"
38	<
39	<	/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
40	<	#ifdef SWIG_TYPE_TABLE
41	<	# define SWIG_QUOTE_STRING(x) #x
145	<	# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146	<	# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147	<	#else
148	<	# define SWIG_TYPE_TABLE_NAME
149	<	#endif
150	<
151	<	/*
152	<	You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153	<	creating a static or dynamic library from the swig runtime code.
154	<	In 99.9% of the cases, swig just needs to declare them as 'static'.
155	<
156	<	But only do this if is strictly necessary, ie, if you have problems
157	<	with your compiler or so.
158	<	*/
159	<
160	<	#ifndef SWIGRUNTIME
161	<	# define SWIGRUNTIME SWIGINTERN
162	<	#endif
31	>	*     This file contains generic SWIG runtime support for pointer
32	>	*     type checking as well as a few commonly used macros to control
33	>	*     external linkage.
34	>	*
35	>	* Author : David Beazley (beazley@cs.uchicago.edu)
36	>	*
37	>	* Copyright (c) 1999-2000, The University of Chicago
38	>	*
39	>	* This file may be freely redistributed without license or fee provided
40	>	* this copyright message remains intact.
41	>	************************************************************************/
42
43	<	#ifndef SWIGRUNTIMEINLINE
165	<	# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166	<	#endif
43	>	#include <string.h>
44
45	<	/*  Generic buffer size */
46	<	#ifndef SWIG_BUFFER_SIZE
47	<	# define SWIG_BUFFER_SIZE 1024
45	>	#if defined(_WIN32) || defined(__WIN32__)
46	>	#       if defined(_MSC_VER)
47	>	#               if defined(STATIC_LINKED)
48	>	#                       define SWIGEXPORT(a) a
49	>	#                       define SWIGIMPORT(a) extern a
50	>	#               else
51	>	#                       define SWIGEXPORT(a) __declspec(dllexport) a
52	>	#                       define SWIGIMPORT(a) extern a
53	>	#               endif
54	>	#       else
55	>	#               if defined(__BORLANDC__)
56	>	#                       define SWIGEXPORT(a) a _export
57	>	#                       define SWIGIMPORT(a) a _export
58	>	#               else
59	>	#                       define SWIGEXPORT(a) a
60	>	#                       define SWIGIMPORT(a) a
61	>	#               endif
62	>	#       endif
63	>	#else
64	>	#       define SWIGEXPORT(a) a
65	>	#       define SWIGIMPORT(a) a
66		#endif
67
68	<	/* Flags for pointer conversions */
69	<	#define SWIG_POINTER_DISOWN        0x1
70	<
71	<	/* Flags for new pointer objects */
177	<	#define SWIG_POINTER_OWN           0x1
178	<
179	<
180	<	/*
181	<	Flags/methods for returning states.
182	<
183	<	The swig conversion methods, as ConvertPtr, return and integer
184	<	that tells if the conversion was successful or not. And if not,
185	<	an error code can be returned (see swigerrors.swg for the codes).
186	<
187	<	Use the following macros/flags to set or process the returning
188	<	states.
189	<
190	<	In old swig versions, you usually write code as:
191	<
192	<	if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193	<	// success code
194	<	} else {
195	<	//fail code
196	<	}
197	<
198	<	Now you can be more explicit as:
199	<
200	<	int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201	<	if (SWIG_IsOK(res)) {
202	<	// success code
203	<	} else {
204	<	// fail code
205	<	}
206	<
207	<	that seems to be the same, but now you can also do
208	<
209	<	Type *ptr;
210	<	int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211	<	if (SWIG_IsOK(res)) {
212	<	// success code
213	<	if (SWIG_IsNewObj(res) {
214	<	...
215	<	delete *ptr;
216	<	} else {
217	<	...
218	<	}
219	<	} else {
220	<	// fail code
221	<	}
222	<
223	<	I.e., now SWIG_ConvertPtr can return new objects and you can
224	<	identify the case and take care of the deallocation. Of course that
225	<	requires also to SWIG_ConvertPtr to return new result values, as
226	<
227	<	int SWIG_ConvertPtr(obj, ptr,...) {
228	<	if (<obj is ok>) {
229	<	if (<need new object>) {
230	<	*ptr = <ptr to new allocated object>;
231	<	return SWIG_NEWOBJ;
232	<	} else {
233	<	*ptr = <ptr to old object>;
234	<	return SWIG_OLDOBJ;
235	<	}
236	<	} else {
237	<	return SWIG_BADOBJ;
238	<	}
239	<	}
240	<
241	<	Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242	<	more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243	<	swig errors code.
244	<
245	<	Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246	<	allows to return the 'cast rank', for example, if you have this
247	<
248	<	int food(double)
249	<	int fooi(int);
250	<
251	<	and you call
252	<
253	<	food(1)   // cast rank '1'  (1 -> 1.0)
254	<	fooi(1)   // cast rank '0'
255	<
256	<	just use the SWIG_AddCast()/SWIG_CheckState()
257	<
258	<
259	<	*/
260	<	#define SWIG_OK                    (0)
261	<	#define SWIG_ERROR                 (-1)
262	<	#define SWIG_IsOK(r)               (r >= 0)
263	<	#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264	<
265	<	/* The CastRankLimit says how many bits are used for the cast rank */
266	<	#define SWIG_CASTRANKLIMIT         (1 << 8)
267	<	/* The NewMask denotes the object was created (using new/malloc) */
268	<	#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
269	<	/* The TmpMask is for in/out typemaps that use temporal objects */
270	<	#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
271	<	/* Simple returning values */
272	<	#define SWIG_BADOBJ                (SWIG_ERROR)
273	<	#define SWIG_OLDOBJ                (SWIG_OK)
274	<	#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
275	<	#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
276	<	/* Check, add and del mask methods */
277	<	#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278	<	#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279	<	#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280	<	#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281	<	#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282	<	#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283	<
284	<
285	<	/* Cast-Rank Mode */
286	<	#if defined(SWIG_CASTRANK_MODE)
287	<	#  ifndef SWIG_TypeRank
288	<	#    define SWIG_TypeRank             unsigned long
289	<	#  endif
290	<	#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
291	<	#    define SWIG_MAXCASTRANK          (2)
292	<	#  endif
293	<	#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
294	<	#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
295	<	SWIGINTERNINLINE int SWIG_AddCast(int r) {
296	<	return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297	<	}
298	<	SWIGINTERNINLINE int SWIG_CheckState(int r) {
299	<	return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300	<	}
301	<	#else /* no cast-rank mode */
302	<	#  define SWIG_AddCast
303	<	#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
68	>	#ifdef SWIG_GLOBAL
69	>	#define SWIGRUNTIME(a) SWIGEXPORT(a)
70	>	#else
71	>	#define SWIGRUNTIME(a) static a
72		#endif
73
306	–
307	–
308	–
309	–	#include <string.h>
310	–
74		#ifdef __cplusplus
75		extern "C" {
76		#endif
#	Line 315 | Line 78 | extern "C" {
78		typedef void *(*swig_converter_func)(void *);
79		typedef struct swig_type_info *(*swig_dycast_func)(void **);
80
318	–	/* Structure to store inforomation on one type */
81		typedef struct swig_type_info {
82	<	const char             *name;                 /* mangled name of this type */
83	<	const char             *str;                  /* human readable name of this type */
84	<	swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
85	<	struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
86	<	void                   *clientdata;           /* language specific type data */
87	<	int                    owndata;               /* flag if the structure owns the clientdata */
82	>	const char             *name;
83	>	swig_converter_func     converter;
84	>	const char             *str;
85	>	void                   *clientdata;
86	>	swig_dycast_func        dcast;
87	>	struct swig_type_info  *next;
88	>	struct swig_type_info  *prev;
89		} swig_type_info;
90
91	<	/* Structure to store a type and conversion function used for casting */
329	<	typedef struct swig_cast_info {
330	<	swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
331	<	swig_converter_func     converter;            /* function to cast the void pointers */
332	<	struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
333	<	struct swig_cast_info  *prev;                 /* pointer to the previous cast */
334	<	} swig_cast_info;
335	<
336	<	/* Structure used to store module information
337	<	* Each module generates one structure like this, and the runtime collects
338	<	* all of these structures and stores them in a circularly linked list.*/
339	<	typedef struct swig_module_info {
340	<	swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
341	<	size_t                 size;                  /* Number of types in this module */
342	<	struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
343	<	swig_type_info         **type_initial;        /* Array of initially generated type structures */
344	<	swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
345	<	void                    *clientdata;          /* Language specific module data */
346	<	} swig_module_info;
347	<
348	<	/*
349	<	Compare two type names skipping the space characters, therefore
350	<	"char*" == "char *" and "Class<int>" == "Class<int >", etc.
351	<
352	<	Return 0 when the two name types are equivalent, as in
353	<	strncmp, but skipping ' '.
354	<	*/
355	<	SWIGRUNTIME int
356	<	SWIG_TypeNameComp(const char *f1, const char *l1,
357	<	const char *f2, const char *l2) {
358	<	for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359	<	while ((*f1 == ' ') && (f1 != l1)) ++f1;
360	<	while ((*f2 == ' ') && (f2 != l2)) ++f2;
361	<	if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362	<	}
363	<	return (l1 - f1) - (l2 - f2);
364	<	}
91	>	#ifdef SWIG_NOINCLUDE
92
93	<	/*
94	<	Check type equivalence in a name list like <name1>|<name2>|...
95	<	Return 0 if not equal, 1 if equal
96	<	*/
97	<	SWIGRUNTIME int
98	<	SWIG_TypeEquiv(const char *nb, const char *tb) {
99	<	int equiv = 0;
100	<	const char* te = tb + strlen(tb);
101	<	const char* ne = nb;
102	<	while (!equiv && *ne) {
103	<	for (nb = ne; *ne; ++ne) {
377	<	if (*ne == '|') break;
378	<	}
379	<	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380	<	if (*ne) ++ne;
381	<	}
382	<	return equiv;
383	<	}
93	>	SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
94	>	SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
95	>	SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
96	>	SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
97	>	SWIGIMPORT(const char *)     SWIG_TypeName(const swig_type_info *);
98	>	SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
99	>	SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);
100	>
101	>	#else
102	>
103	>	static swig_type_info *swig_type_list = 0;
104
105	<	/*
106	<	Check type equivalence in a name list like <name1>|<name2>|...
107	<	Return 0 if equal, -1 if nb < tb, 1 if nb > tb
108	<	*/
109	<	SWIGRUNTIME int
110	<	SWIG_TypeCompare(const char *nb, const char *tb) {
111	<	int equiv = 0;
112	<	const char* te = tb + strlen(tb);
113	<	const char* ne = nb;
114	<	while (!equiv && *ne) {
115	<	for (nb = ne; *ne; ++ne) {
116	<	if (*ne == '|') break;
105	>	/* Register a type mapping with the type-checking */
106	>	SWIGRUNTIME(swig_type_info *)
107	>	SWIG_TypeRegister(swig_type_info *ti)
108	>	{
109	>	swig_type_info *tc, *head, *ret, *next;
110	>	/* Check to see if this type has already been registered */
111	>	tc = swig_type_list;
112	>	while (tc) {
113	>	if (strcmp(tc->name, ti->name) == 0) {
114	>	/* Already exists in the table.  Just add additional types to the list */
115	>	if (tc->clientdata) ti->clientdata = tc->clientdata;
116	>	head = tc;
117	>	next = tc->next;
118	>	goto l1;
119	>	}
120	>	tc = tc->prev;
121	>	}
122	>	head = ti;
123	>	next = 0;
124	>
125	>	/* Place in list */
126	>	ti->prev = swig_type_list;
127	>	swig_type_list = ti;
128	>
129	>	/* Build linked lists */
130	>	l1:
131	>	ret = head;
132	>	tc = ti + 1;
133	>	/* Patch up the rest of the links */
134	>	while (tc->name) {
135	>	head->next = tc;
136	>	tc->prev = head;
137	>	head = tc;
138	>	tc++;
139	>	}
140	>	if (next) next->prev = head;  /**/
141	>	head->next = next;
142	>	return ret;
143	>	}
144	>
145	>	/* Check the typename */
146	>	SWIGRUNTIME(swig_type_info *)
147	>	SWIG_TypeCheck(char *c, swig_type_info *ty)
148	>	{
149	>	swig_type_info *s;
150	>	if (!ty) return 0;        /* Void pointer */
151	>	s = ty->next;             /* First element always just a name */
152	>	do {
153	>	if (strcmp(s->name,c) == 0) {
154	>	if (s == ty->next) return s;
155	>	/* Move s to the top of the linked list */
156	>	s->prev->next = s->next;
157	>	if (s->next) {
158	>	s->next->prev = s->prev;
159	>	}
160	>	/* Insert s as second element in the list */
161	>	s->next = ty->next;
162	>	if (ty->next) ty->next->prev = s;
163	>	ty->next = s;
164	>	s->prev = ty;  /**/
165	>	return s;
166		}
167	<	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
168	<	if (*ne) ++ne;
169	<	}
401	<	return equiv;
167	>	s = s->next;
168	>	} while (s && (s != ty->next));
169	>	return 0;
170		}
171
172	+	/* Cast a pointer up an inheritance hierarchy */
173	+	SWIGRUNTIME(void *)
174	+	SWIG_TypeCast(swig_type_info *ty, void *ptr)
175	+	{
176	+	if ((!ty) || (!ty->converter)) return ptr;
177	+	return (*ty->converter)(ptr);
178	+	}
179
180	<	/* think of this as a c++ template<> or a scheme macro */
181	<	#define SWIG_TypeCheck_Template(comparison, ty)         \
182	<	if (ty) {                                             \
183	<	swig_cast_info *iter = ty->cast;                    \
409	<	while (iter) {                                      \
410	<	if (comparison) {                                 \
411	<	if (iter == ty->cast) return iter;              \
412	<	/* Move iter to the top of the linked list */   \
413	<	iter->prev->next = iter->next;                  \
414	<	if (iter->next)                                 \
415	<	iter->next->prev = iter->prev;                \
416	<	iter->next = ty->cast;                          \
417	<	iter->prev = 0;                                 \
418	<	if (ty->cast) ty->cast->prev = iter;            \
419	<	ty->cast = iter;                                \
420	<	return iter;                                    \
421	<	}                                                 \
422	<	iter = iter->next;                                \
423	<	}                                                   \
424	<	}                                                     \
425	<	return 0
426	<
427	<	/*
428	<	Check the typename
429	<	*/
430	<	SWIGRUNTIME swig_cast_info *
431	<	SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432	<	SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433	<	}
434	<
435	<	/* Same as previous function, except strcmp is replaced with a pointer comparison */
436	<	SWIGRUNTIME swig_cast_info *
437	<	SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438	<	SWIG_TypeCheck_Template(iter->type == from, into);
439	<	}
440	<
441	<	/*
442	<	Cast a pointer up an inheritance hierarchy
443	<	*/
444	<	SWIGRUNTIMEINLINE void *
445	<	SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446	<	return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447	<	}
448	<
449	<	/*
450	<	Dynamic pointer casting. Down an inheritance hierarchy
451	<	*/
452	<	SWIGRUNTIME swig_type_info *
453	<	SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
180	>	/* Dynamic pointer casting. Down an inheritance hierarchy */
181	>	SWIGRUNTIME(swig_type_info *)
182	>	SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
183	>	{
184		swig_type_info *lastty = ty;
185		if (!ty || !ty->dcast) return ty;
186		while (ty && (ty->dcast)) {
187	<	ty = (*ty->dcast)(ptr);
188	<	if (ty) lastty = ty;
187	>	ty = (*ty->dcast)(ptr);
188	>	if (ty) lastty = ty;
189		}
190		return lastty;
191		}
192
193	<	/*
194	<	Return the name associated with this type
465	<	*/
466	<	SWIGRUNTIMEINLINE const char *
193	>	/* Return the name associated with this type */
194	>	SWIGRUNTIME(const char *)
195		SWIG_TypeName(const swig_type_info *ty) {
196		return ty->name;
197		}
198
199	<	/*
200	<	Return the pretty name associated with this type,
201	<	that is an unmangled type name in a form presentable to the user.
202	<	*/
203	<	SWIGRUNTIME const char *
204	<	SWIG_TypePrettyName(const swig_type_info *type) {
205	<	/* The "str" field contains the equivalent pretty names of the
206	<	type, separated by vertical-bar characters.  We choose
479	<	to print the last name, as it is often (?) the most
480	<	specific. */
481	<	if (!type) return NULL;
482	<	if (type->str != NULL) {
483	<	const char *last_name = type->str;
484	<	const char *s;
485	<	for (s = type->str; *s; s++)
486	<	if (*s == '|') last_name = s+1;
487	<	return last_name;
199	>	/* Search for a swig_type_info structure */
200	>	SWIGRUNTIME(swig_type_info *)
201	>	SWIG_TypeQuery(const char *name) {
202	>	swig_type_info *ty = swig_type_list;
203	>	while (ty) {
204	>	if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
205	>	if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
206	>	ty = ty->prev;
207		}
208	<	else
490	<	return type->name;
208	>	return 0;
209		}
210
211	<	/*
212	<	Set the clientdata field for a type
495	<	*/
496	<	SWIGRUNTIME void
211	>	/* Set the clientdata field for a type */
212	>	SWIGRUNTIME(void)
213		SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
214	<	swig_cast_info *cast = ti->cast;
215	<	/* if (ti->clientdata == clientdata) return; */
214	>	swig_type_info *tc, *equiv;
215	>	if (ti->clientdata == clientdata) return;
216		ti->clientdata = clientdata;
217	<
218	<	while (cast) {
219	<	if (!cast->converter) {
220	<	swig_type_info *tc = cast->type;
221	<	if (!tc->clientdata) {
222	<	SWIG_TypeClientData(tc, clientdata);
217	>	equiv = ti->next;
218	>	while (equiv) {
219	>	if (!equiv->converter) {
220	>	tc = swig_type_list;
221	>	while (tc) {
222	>	if ((strcmp(tc->name, equiv->name) == 0))
223	>	SWIG_TypeClientData(tc,clientdata);
224	>	tc = tc->prev;
225		}
508	–	}
509	–	cast = cast->next;
510	–	}
511	–	}
512	–	SWIGRUNTIME void
513	–	SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514	–	SWIG_TypeClientData(ti, clientdata);
515	–	ti->owndata = 1;
516	–	}
517	–
518	–	/*
519	–	Search for a swig_type_info structure only by mangled name
520	–	Search is a O(log #types)
521	–
522	–	We start searching at module start, and finish searching when start == end.
523	–	Note: if start == end at the beginning of the function, we go all the way around
524	–	the circular list.
525	–	*/
526	–	SWIGRUNTIME swig_type_info *
527	–	SWIG_MangledTypeQueryModule(swig_module_info *start,
528	–	swig_module_info *end,
529	–	const char *name) {
530	–	swig_module_info *iter = start;
531	–	do {
532	–	if (iter->size) {
533	–	register size_t l = 0;
534	–	register size_t r = iter->size - 1;
535	–	do {
536	–	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
537	–	register size_t i = (l + r) >> 1;
538	–	const char *iname = iter->types[i]->name;
539	–	if (iname) {
540	–	register int compare = strcmp(name, iname);
541	–	if (compare == 0) {
542	–	return iter->types[i];
543	–	} else if (compare < 0) {
544	–	if (i) {
545	–	r = i - 1;
546	–	} else {
547	–	break;
548	–	}
549	–	} else if (compare > 0) {
550	–	l = i + 1;
551	–	}
552	–	} else {
553	–	break; /* should never happen */
554	–	}
555	–	} while (l <= r);
226		}
227	<	iter = iter->next;
558	<	} while (iter != end);
559	<	return 0;
560	<	}
561	<
562	<	/*
563	<	Search for a swig_type_info structure for either a mangled name or a human readable name.
564	<	It first searches the mangled names of the types, which is a O(log #types)
565	<	If a type is not found it then searches the human readable names, which is O(#types).
566	<
567	<	We start searching at module start, and finish searching when start == end.
568	<	Note: if start == end at the beginning of the function, we go all the way around
569	<	the circular list.
570	<	*/
571	<	SWIGRUNTIME swig_type_info *
572	<	SWIG_TypeQueryModule(swig_module_info *start,
573	<	swig_module_info *end,
574	<	const char *name) {
575	<	/* STEP 1: Search the name field using binary search */
576	<	swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577	<	if (ret) {
578	<	return ret;
579	<	} else {
580	<	/* STEP 2: If the type hasn't been found, do a complete search
581	<	of the str field (the human readable name) */
582	<	swig_module_info *iter = start;
583	<	do {
584	<	register size_t i = 0;
585	<	for (; i < iter->size; ++i) {
586	<	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587	<	return iter->types[i];
588	<	}
589	<	iter = iter->next;
590	<	} while (iter != end);
591	<	}
592	<
593	<	/* neither found a match */
594	<	return 0;
595	<	}
596	<
597	<	/*
598	<	Pack binary data into a string
599	<	*/
600	<	SWIGRUNTIME char *
601	<	SWIG_PackData(char *c, void *ptr, size_t sz) {
602	<	static const char hex[17] = "0123456789abcdef";
603	<	register const unsigned char *u = (unsigned char *) ptr;
604	<	register const unsigned char *eu =  u + sz;
605	<	for (; u != eu; ++u) {
606	<	register unsigned char uu = *u;
607	<	*(c++) = hex[(uu & 0xf0) >> 4];
608	<	*(c++) = hex[uu & 0xf];
227	>	equiv = equiv->next;
228		}
610	–	return c;
611	–	}
612	–
613	–	/*
614	–	Unpack binary data from a string
615	–	*/
616	–	SWIGRUNTIME const char *
617	–	SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618	–	register unsigned char *u = (unsigned char *) ptr;
619	–	register const unsigned char *eu = u + sz;
620	–	for (; u != eu; ++u) {
621	–	register char d = *(c++);
622	–	register unsigned char uu;
623	–	if ((d >= '0') && (d <= '9'))
624	–	uu = ((d - '0') << 4);
625	–	else if ((d >= 'a') && (d <= 'f'))
626	–	uu = ((d - ('a'-10)) << 4);
627	–	else
628	–	return (char *) 0;
629	–	d = *(c++);
630	–	if ((d >= '0') && (d <= '9'))
631	–	uu |= (d - '0');
632	–	else if ((d >= 'a') && (d <= 'f'))
633	–	uu |= (d - ('a'-10));
634	–	else
635	–	return (char *) 0;
636	–	*u = uu;
637	–	}
638	–	return c;
639	–	}
640	–
641	–	/*
642	–	Pack 'void *' into a string buffer.
643	–	*/
644	–	SWIGRUNTIME char *
645	–	SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646	–	char *r = buff;
647	–	if ((2*sizeof(void *) + 2) > bsz) return 0;
648	–	*(r++) = '_';
649	–	r = SWIG_PackData(r,&ptr,sizeof(void *));
650	–	if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651	–	strcpy(r,name);
652	–	return buff;
653	–	}
654	–
655	–	SWIGRUNTIME const char *
656	–	SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657	–	if (*c != '_') {
658	–	if (strcmp(c,"NULL") == 0) {
659	–	*ptr = (void *) 0;
660	–	return name;
661	–	} else {
662	–	return 0;
663	–	}
664	–	}
665	–	return SWIG_UnpackData(++c,ptr,sizeof(void *));
666	–	}
667	–
668	–	SWIGRUNTIME char *
669	–	SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670	–	char *r = buff;
671	–	size_t lname = (name ? strlen(name) : 0);
672	–	if ((2*sz + 2 + lname) > bsz) return 0;
673	–	*(r++) = '_';
674	–	r = SWIG_PackData(r,ptr,sz);
675	–	if (lname) {
676	–	strncpy(r,name,lname+1);
677	–	} else {
678	–	*r = 0;
679	–	}
680	–	return buff;
681	–	}
682	–
683	–	SWIGRUNTIME const char *
684	–	SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685	–	if (*c != '_') {
686	–	if (strcmp(c,"NULL") == 0) {
687	–	memset(ptr,0,sz);
688	–	return name;
689	–	} else {
690	–	return 0;
691	–	}
692	–	}
693	–	return SWIG_UnpackData(++c,ptr,sz);
694	–	}
695	–
696	–	#ifdef __cplusplus
229		}
230		#endif
231
232	<	/*  Errors in SWIG */
701	<	#define  SWIG_UnknownError         -1
702	<	#define  SWIG_IOError              -2
703	<	#define  SWIG_RuntimeError         -3
704	<	#define  SWIG_IndexError           -4
705	<	#define  SWIG_TypeError            -5
706	<	#define  SWIG_DivisionByZero       -6
707	<	#define  SWIG_OverflowError        -7
708	<	#define  SWIG_SyntaxError          -8
709	<	#define  SWIG_ValueError           -9
710	<	#define  SWIG_SystemError          -10
711	<	#define  SWIG_AttributeError       -11
712	<	#define  SWIG_MemoryError          -12
713	<	#define  SWIG_NullReferenceError   -13
714	<
715	<
716	<
717	<	/* Python.h has to appear first */
718	<	#include <Python.h>
719	<
720	<	/* Add PyOS_snprintf for old Pythons */
721	<	#if PY_VERSION_HEX < 0x02020000
722	<	# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723	<	#  define PyOS_snprintf _snprintf
724	<	# else
725	<	#  define PyOS_snprintf snprintf
726	<	# endif
727	<	#endif
728	<
729	<	/* A crude PyString_FromFormat implementation for old Pythons */
730	<	#if PY_VERSION_HEX < 0x02020000
731	<
732	<	#ifndef SWIG_PYBUFFER_SIZE
733	<	# define SWIG_PYBUFFER_SIZE 1024
734	<	#endif
735	<
736	<	static PyObject *
737	<	PyString_FromFormat(const char *fmt, ...) {
738	<	va_list ap;
739	<	char buf[SWIG_PYBUFFER_SIZE * 2];
740	<	int res;
741	<	va_start(ap, fmt);
742	<	res = vsnprintf(buf, sizeof(buf), fmt, ap);
743	<	va_end(ap);
744	<	return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
232	>	#ifdef __cplusplus
233		}
746	–	#endif
234
748	–	/* Add PyObject_Del for old Pythons */
749	–	#if PY_VERSION_HEX < 0x01060000
750	–	# define PyObject_Del(op) PyMem_DEL((op))
751	–	#endif
752	–	#ifndef PyObject_DEL
753	–	# define PyObject_DEL PyObject_Del
754	–	#endif
755	–
756	–	/* A crude PyExc_StopIteration exception for old Pythons */
757	–	#if PY_VERSION_HEX < 0x02020000
758	–	# ifndef PyExc_StopIteration
759	–	#  define PyExc_StopIteration PyExc_RuntimeError
760	–	# endif
761	–	# ifndef PyObject_GenericGetAttr
762	–	#  define PyObject_GenericGetAttr 0
763	–	# endif
764	–	#endif
765	–	/* Py_NotImplemented is defined in 2.1 and up. */
766	–	#if PY_VERSION_HEX < 0x02010000
767	–	# ifndef Py_NotImplemented
768	–	#  define Py_NotImplemented PyExc_RuntimeError
769	–	# endif
235		#endif
236
237	+	/***********************************************************************
238	+	* python.swg
239	+	*
240	+	*     This file contains the runtime support for Python modules
241	+	*     and includes code for managing global variables and pointer
242	+	*     type checking.
243	+	*
244	+	* Author : David Beazley (beazley@cs.uchicago.edu)
245	+	************************************************************************/
246
247	<	/* A crude PyString_AsStringAndSize implementation for old Pythons */
774	<	#if PY_VERSION_HEX < 0x02010000
775	<	# ifndef PyString_AsStringAndSize
776	<	#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777	<	# endif
778	<	#endif
779	<
780	<	/* PySequence_Size for old Pythons */
781	<	#if PY_VERSION_HEX < 0x02000000
782	<	# ifndef PySequence_Size
783	<	#  define PySequence_Size PySequence_Length
784	<	# endif
785	<	#endif
786	<
787	<
788	<	/* PyBool_FromLong for old Pythons */
789	<	#if PY_VERSION_HEX < 0x02030000
790	<	static
791	<	PyObject *PyBool_FromLong(long ok)
792	<	{
793	<	PyObject *result = ok ? Py_True : Py_False;
794	<	Py_INCREF(result);
795	<	return result;
796	<	}
797	<	#endif
798	<
799	<
800	<	/* -----------------------------------------------------------------------------
801	<	* error manipulation
802	<	* ----------------------------------------------------------------------------- */
803	<
804	<	SWIGRUNTIME PyObject*
805	<	SWIG_Python_ErrorType(int code) {
806	<	PyObject* type = 0;
807	<	switch(code) {
808	<	case SWIG_MemoryError:
809	<	type = PyExc_MemoryError;
810	<	break;
811	<	case SWIG_IOError:
812	<	type = PyExc_IOError;
813	<	break;
814	<	case SWIG_RuntimeError:
815	<	type = PyExc_RuntimeError;
816	<	break;
817	<	case SWIG_IndexError:
818	<	type = PyExc_IndexError;
819	<	break;
820	<	case SWIG_TypeError:
821	<	type = PyExc_TypeError;
822	<	break;
823	<	case SWIG_DivisionByZero:
824	<	type = PyExc_ZeroDivisionError;
825	<	break;
826	<	case SWIG_OverflowError:
827	<	type = PyExc_OverflowError;
828	<	break;
829	<	case SWIG_SyntaxError:
830	<	type = PyExc_SyntaxError;
831	<	break;
832	<	case SWIG_ValueError:
833	<	type = PyExc_ValueError;
834	<	break;
835	<	case SWIG_SystemError:
836	<	type = PyExc_SystemError;
837	<	break;
838	<	case SWIG_AttributeError:
839	<	type = PyExc_AttributeError;
840	<	break;
841	<	default:
842	<	type = PyExc_RuntimeError;
843	<	}
844	<	return type;
845	<	}
846	<
847	<
848	<	SWIGRUNTIME void
849	<	SWIG_Python_AddErrorMsg(const char* mesg)
850	<	{
851	<	PyObject *type = 0;
852	<	PyObject *value = 0;
853	<	PyObject *traceback = 0;
854	<
855	<	if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856	<	if (value) {
857	<	PyObject *old_str = PyObject_Str(value);
858	<	PyErr_Clear();
859	<	Py_XINCREF(type);
860	<	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861	<	Py_DECREF(old_str);
862	<	Py_DECREF(value);
863	<	} else {
864	<	PyErr_Format(PyExc_RuntimeError, mesg);
865	<	}
866	<	}
867	<
868	<
869	<
870	<	#if defined(SWIG_PYTHON_NO_THREADS)
871	<	#  if defined(SWIG_PYTHON_THREADS)
872	<	#    undef SWIG_PYTHON_THREADS
873	<	#  endif
874	<	#endif
875	<	#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876	<	#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877	<	#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878	<	#      define SWIG_PYTHON_USE_GIL
879	<	#    endif
880	<	#  endif
881	<	#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882	<	#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
883	<	#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
884	<	#    endif
885	<	#    ifdef __cplusplus /* C++ code */
886	<	class SWIG_Python_Thread_Block {
887	<	bool status;
888	<	PyGILState_STATE state;
889	<	public:
890	<	void end() { if (status) { PyGILState_Release(state); status = false;} }
891	<	SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892	<	~SWIG_Python_Thread_Block() { end(); }
893	<	};
894	<	class SWIG_Python_Thread_Allow {
895	<	bool status;
896	<	PyThreadState *save;
897	<	public:
898	<	void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899	<	SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900	<	~SWIG_Python_Thread_Allow() { end(); }
901	<	};
902	<	#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
903	<	#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
904	<	#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
905	<	#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
906	<	#    else /* C code */
907	<	#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908	<	#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
909	<	#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910	<	#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
911	<	#    endif
912	<	#  else /* Old thread way, not implemented, user must provide it */
913	<	#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914	<	#      define SWIG_PYTHON_INITIALIZE_THREADS
915	<	#    endif
916	<	#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917	<	#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918	<	#    endif
919	<	#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920	<	#      define SWIG_PYTHON_THREAD_END_BLOCK
921	<	#    endif
922	<	#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923	<	#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924	<	#    endif
925	<	#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926	<	#      define SWIG_PYTHON_THREAD_END_ALLOW
927	<	#    endif
928	<	#  endif
929	<	#else /* No thread support */
930	<	#  define SWIG_PYTHON_INITIALIZE_THREADS
931	<	#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932	<	#  define SWIG_PYTHON_THREAD_END_BLOCK
933	<	#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934	<	#  define SWIG_PYTHON_THREAD_END_ALLOW
935	<	#endif
936	<
937	<	/* -----------------------------------------------------------------------------
938	<	* Python API portion that goes into the runtime
939	<	* ----------------------------------------------------------------------------- */
247	>	#include "Python.h"
248
249		#ifdef __cplusplus
250		extern "C" {
943	–	#if 0
944	–	} /* cc-mode */
945	–	#endif
251		#endif
252
253	<	/* -----------------------------------------------------------------------------
254	<	* Constant declarations
255	<	* ----------------------------------------------------------------------------- */
951	<
952	<	/* Constant Types */
253	>	#define SWIG_PY_INT     1
254	>	#define SWIG_PY_FLOAT   2
255	>	#define SWIG_PY_STRING  3
256		#define SWIG_PY_POINTER 4
257		#define SWIG_PY_BINARY  5
258
259	<	/* Constant information structure */
957	<	typedef struct swig_const_info {
958	<	int type;
959	<	char *name;
960	<	long lvalue;
961	<	double dvalue;
962	<	void   *pvalue;
963	<	swig_type_info **ptype;
964	<	} swig_const_info;
259	>	/* Flags for pointer conversion */
260
261	<	#ifdef __cplusplus
262	<	#if 0
968	<	{ /* cc-mode */
969	<	#endif
970	<	}
971	<	#endif
261	>	#define SWIG_POINTER_EXCEPTION     0x1
262	>	#define SWIG_POINTER_DISOWN        0x2
263
264	+	/* Exception handling in wrappers */
265	+	#define SWIG_fail   goto fail
266
267	<	/* -----------------------------------------------------------------------------
268	<	* See the LICENSE file for information on copyright, usage and redistribution
269	<	* of SWIG, and the README file for authors - http://www.swig.org/release.html.
270	<	*
271	<	* pyrun.swg
272	<	*
273	<	* This file contains the runtime support for Python modules
274	<	* and includes code for managing global variables and pointer
275	<	* type checking.
983	<	*
984	<	* ----------------------------------------------------------------------------- */
985	<
986	<	/* Common SWIG API */
987	<
988	<	/* for raw pointers */
989	<	#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990	<	#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991	<	#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992	<	#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
993	<	#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
994	<	#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
995	<	#define swig_owntype                                    int
996	<
997	<	/* for raw packed data */
998	<	#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999	<	#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1000	<
1001	<	/* for class or struct pointers */
1002	<	#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
1003	<	#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1004	<
1005	<	/* for C or C++ function pointers */
1006	<	#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007	<	#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
1008	<
1009	<	/* for C++ member pointers, ie, member methods */
1010	<	#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011	<	#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1012	<
1013	<
1014	<	/* Runtime API */
1015	<
1016	<	#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1017	<	#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1018	<	#define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
1019	<
1020	<	#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
1021	<	#define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg
1022	<	#define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)
1023	<	#define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024	<	#define SWIG_fail                                       goto fail
1025	<
1026	<
1027	<	/* Runtime API implementation */
1028	<
1029	<	/* Error manipulation */
1030	<
1031	<	SWIGINTERN void
1032	<	SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033	<	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034	<	PyErr_SetObject(errtype, obj);
1035	<	Py_DECREF(obj);
1036	<	SWIG_PYTHON_THREAD_END_BLOCK;
1037	<	}
1038	<
1039	<	SWIGINTERN void
1040	<	SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041	<	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042	<	PyErr_SetString(errtype, (char *) msg);
1043	<	SWIG_PYTHON_THREAD_END_BLOCK;
1044	<	}
1045	<
1046	<	#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047	<
1048	<	/* Set a constant value */
1049	<
1050	<	SWIGINTERN void
1051	<	SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052	<	PyDict_SetItemString(d, (char*) name, obj);
1053	<	Py_DECREF(obj);
1054	<	}
1055	<
1056	<	/* Append a value to the result obj */
1057	<
1058	<	SWIGINTERN PyObject*
1059	<	SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060	<	#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061	<	if (!result) {
1062	<	result = obj;
1063	<	} else if (result == Py_None) {
1064	<	Py_DECREF(result);
1065	<	result = obj;
1066	<	} else {
1067	<	if (!PyList_Check(result)) {
1068	<	PyObject *o2 = result;
1069	<	result = PyList_New(1);
1070	<	PyList_SetItem(result, 0, o2);
1071	<	}
1072	<	PyList_Append(result,obj);
1073	<	Py_DECREF(obj);
1074	<	}
1075	<	return result;
1076	<	#else
1077	<	PyObject*   o2;
1078	<	PyObject*   o3;
1079	<	if (!result) {
1080	<	result = obj;
1081	<	} else if (result == Py_None) {
1082	<	Py_DECREF(result);
1083	<	result = obj;
1084	<	} else {
1085	<	if (!PyTuple_Check(result)) {
1086	<	o2 = result;
1087	<	result = PyTuple_New(1);
1088	<	PyTuple_SET_ITEM(result, 0, o2);
1089	<	}
1090	<	o3 = PyTuple_New(1);
1091	<	PyTuple_SET_ITEM(o3, 0, obj);
1092	<	o2 = result;
1093	<	result = PySequence_Concat(o2, o3);
1094	<	Py_DECREF(o2);
1095	<	Py_DECREF(o3);
1096	<	}
1097	<	return result;
1098	<	#endif
1099	<	}
1100	<
1101	<	/* Unpack the argument tuple */
1102	<
1103	<	SWIGINTERN int
1104	<	SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105	<	{
1106	<	if (!args) {
1107	<	if (!min && !max) {
1108	<	return 1;
1109	<	} else {
1110	<	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111	<	name, (min == max ? "" : "at least "), min);
1112	<	return 0;
1113	<	}
1114	<	}
1115	<	if (!PyTuple_Check(args)) {
1116	<	PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117	<	return 0;
1118	<	} else {
1119	<	register int l = PyTuple_GET_SIZE(args);
1120	<	if (l < min) {
1121	<	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122	<	name, (min == max ? "" : "at least "), min, l);
1123	<	return 0;
1124	<	} else if (l > max) {
1125	<	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126	<	name, (min == max ? "" : "at most "), max, l);
1127	<	return 0;
1128	<	} else {
1129	<	register int i;
1130	<	for (i = 0; i < l; ++i) {
1131	<	objs[i] = PyTuple_GET_ITEM(args, i);
1132	<	}
1133	<	for (; l < max; ++l) {
1134	<	objs[l] = 0;
1135	<	}
1136	<	return i + 1;
1137	<	}
1138	<	}
1139	<	}
267	>	/* Constant information structure */
268	>	typedef struct swig_const_info {
269	>	int type;
270	>	char *name;
271	>	long lvalue;
272	>	double dvalue;
273	>	void   *pvalue;
274	>	swig_type_info **ptype;
275	>	} swig_const_info;
276
277	<	/* A functor is a function object with one single object argument */
1142	<	#if PY_VERSION_HEX >= 0x02020000
1143	<	#define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144	<	#else
1145	<	#define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1146	<	#endif
277	>	#ifdef SWIG_NOINCLUDE
278
279	<	/*
280	<	Helper for static pointer initialization for both C and C++ code, for example
281	<	static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
282	<	*/
283	<	#ifdef __cplusplus
284	<	#define SWIG_STATIC_POINTER(var)  var
279	>	SWIGEXPORT(PyObject *)        SWIG_newvarlink(void);
280	>	SWIGEXPORT(void)              SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
281	>	SWIGEXPORT(int)               SWIG_ConvertPtr(PyObject *, void **, swig_type_info *, int);
282	>	SWIGEXPORT(int)               SWIG_ConvertPacked(PyObject *, void *, int sz, swig_type_info *, int);
283	>	SWIGEXPORT(char *)            SWIG_PackData(char *c, void *, int);
284	>	SWIGEXPORT(char *)            SWIG_UnpackData(char *c, void *, int);
285	>	SWIGEXPORT(PyObject *)        SWIG_NewPointerObj(void *, swig_type_info *,int own);
286	>	SWIGEXPORT(PyObject *)        SWIG_NewPackedObj(void *, int sz, swig_type_info *);
287	>	SWIGEXPORT(void)              SWIG_InstallConstants(PyObject *d, swig_const_info constants[]);
288		#else
1155	–	#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1156	–	#endif
289
290		/* -----------------------------------------------------------------------------
291	<	* Pointer declarations
291	>	* global variable support code.
292		* ----------------------------------------------------------------------------- */
293
294	<	/* Flags for new pointer objects */
295	<	#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
296	<	#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
297	<
298	<	#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
294	>	typedef struct swig_globalvar {
295	>	char       *name;                  /* Name of global variable */
296	>	PyObject *(*get_attr)(void);       /* Return the current value */
297	>	int       (*set_attr)(PyObject *); /* Set the value */
298	>	struct swig_globalvar *next;
299	>	} swig_globalvar;
300
301	<	#ifdef __cplusplus
1169	<	extern "C" {
1170	<	#if 0
1171	<	} /* cc-mode */
1172	<	#endif
1173	<	#endif
1174	<
1175	<	/*  How to access Py_None */
1176	<	#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177	<	#  ifndef SWIG_PYTHON_NO_BUILD_NONE
1178	<	#    ifndef SWIG_PYTHON_BUILD_NONE
1179	<	#      define SWIG_PYTHON_BUILD_NONE
1180	<	#    endif
1181	<	#  endif
1182	<	#endif
1183	<
1184	<	#ifdef SWIG_PYTHON_BUILD_NONE
1185	<	#  ifdef Py_None
1186	<	#   undef Py_None
1187	<	#   define Py_None SWIG_Py_None()
1188	<	#  endif
1189	<	SWIGRUNTIMEINLINE PyObject *
1190	<	_SWIG_Py_None(void)
1191	<	{
1192	<	PyObject *none = Py_BuildValue("");
1193	<	Py_DECREF(none);
1194	<	return none;
1195	<	}
1196	<	SWIGRUNTIME PyObject *
1197	<	SWIG_Py_None(void)
1198	<	{
1199	<	static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200	<	return none;
1201	<	}
1202	<	#endif
1203	<
1204	<	/* The python void return value */
1205	<
1206	<	SWIGRUNTIMEINLINE PyObject *
1207	<	SWIG_Py_Void(void)
1208	<	{
1209	<	PyObject *none = Py_None;
1210	<	Py_INCREF(none);
1211	<	return none;
1212	<	}
1213	<
1214	<	/* PySwigClientData */
1215	<
1216	<	typedef struct {
1217	<	PyObject *klass;
1218	<	PyObject *newraw;
1219	<	PyObject *newargs;
1220	<	PyObject *destroy;
1221	<	int delargs;
1222	<	int implicitconv;
1223	<	} PySwigClientData;
1224	<
1225	<	SWIGRUNTIMEINLINE int
1226	<	SWIG_Python_CheckImplicit(swig_type_info *ty)
1227	<	{
1228	<	PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229	<	return data ? data->implicitconv : 0;
1230	<	}
1231	<
1232	<	SWIGRUNTIMEINLINE PyObject *
1233	<	SWIG_Python_ExceptionType(swig_type_info *desc) {
1234	<	PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235	<	PyObject *klass = data ? data->klass : 0;
1236	<	return (klass ? klass : PyExc_RuntimeError);
1237	<	}
1238	<
1239	<
1240	<	SWIGRUNTIME PySwigClientData *
1241	<	PySwigClientData_New(PyObject* obj)
1242	<	{
1243	<	if (!obj) {
1244	<	return 0;
1245	<	} else {
1246	<	PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247	<	/* the klass element */
1248	<	data->klass = obj;
1249	<	Py_INCREF(data->klass);
1250	<	/* the newraw method and newargs arguments used to create a new raw instance */
1251	<	if (PyClass_Check(obj)) {
1252	<	data->newraw = 0;
1253	<	data->newargs = obj;
1254	<	Py_INCREF(obj);
1255	<	} else {
1256	<	#if (PY_VERSION_HEX < 0x02020000)
1257	<	data->newraw = 0;
1258	<	#else
1259	<	data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260	<	#endif
1261	<	if (data->newraw) {
1262	<	Py_INCREF(data->newraw);
1263	<	data->newargs = PyTuple_New(1);
1264	<	PyTuple_SetItem(data->newargs, 0, obj);
1265	<	} else {
1266	<	data->newargs = obj;
1267	<	}
1268	<	Py_INCREF(data->newargs);
1269	<	}
1270	<	/* the destroy method, aka as the C++ delete method */
1271	<	data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272	<	if (PyErr_Occurred()) {
1273	<	PyErr_Clear();
1274	<	data->destroy = 0;
1275	<	}
1276	<	if (data->destroy) {
1277	<	int flags;
1278	<	Py_INCREF(data->destroy);
1279	<	flags = PyCFunction_GET_FLAGS(data->destroy);
1280	<	#ifdef METH_O
1281	<	data->delargs = !(flags & (METH_O));
1282	<	#else
1283	<	data->delargs = 0;
1284	<	#endif
1285	<	} else {
1286	<	data->delargs = 0;
1287	<	}
1288	<	data->implicitconv = 0;
1289	<	return data;
1290	<	}
1291	<	}
1292	<
1293	<	SWIGRUNTIME void
1294	<	PySwigClientData_Del(PySwigClientData* data)
1295	<	{
1296	<	Py_XDECREF(data->newraw);
1297	<	Py_XDECREF(data->newargs);
1298	<	Py_XDECREF(data->destroy);
1299	<	}
1300	<
1301	<	/* =============== PySwigObject =====================*/
1302	<
1303	<	typedef struct {
301	>	typedef struct swig_varlinkobject {
302		PyObject_HEAD
303	<	void *ptr;
304	<	swig_type_info *ty;
1307	<	int own;
1308	<	PyObject *next;
1309	<	} PySwigObject;
1310	<
1311	<	SWIGRUNTIME PyObject *
1312	<	PySwigObject_long(PySwigObject *v)
1313	<	{
1314	<	return PyLong_FromVoidPtr(v->ptr);
1315	<	}
1316	<
1317	<	SWIGRUNTIME PyObject *
1318	<	PySwigObject_format(const char* fmt, PySwigObject *v)
1319	<	{
1320	<	PyObject *res = NULL;
1321	<	PyObject *args = PyTuple_New(1);
1322	<	if (args) {
1323	<	if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324	<	PyObject *ofmt = PyString_FromString(fmt);
1325	<	if (ofmt) {
1326	<	res = PyString_Format(ofmt,args);
1327	<	Py_DECREF(ofmt);
1328	<	}
1329	<	Py_DECREF(args);
1330	<	}
1331	<	}
1332	<	return res;
1333	<	}
1334	<
1335	<	SWIGRUNTIME PyObject *
1336	<	PySwigObject_oct(PySwigObject *v)
1337	<	{
1338	<	return PySwigObject_format("%o",v);
1339	<	}
1340	<
1341	<	SWIGRUNTIME PyObject *
1342	<	PySwigObject_hex(PySwigObject *v)
1343	<	{
1344	<	return PySwigObject_format("%x",v);
1345	<	}
303	>	swig_globalvar *vars;
304	>	} swig_varlinkobject;
305
306	<	SWIGRUNTIME PyObject *
307	<	#ifdef METH_NOARGS
308	<	PySwigObject_repr(PySwigObject *v)
309	<	#else
1351	<	PySwigObject_repr(PySwigObject *v, PyObject *args)
1352	<	#endif
1353	<	{
1354	<	const char *name = SWIG_TypePrettyName(v->ty);
1355	<	PyObject *hex = PySwigObject_hex(v);
1356	<	PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357	<	Py_DECREF(hex);
1358	<	if (v->next) {
1359	<	#ifdef METH_NOARGS
1360	<	PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361	<	#else
1362	<	PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363	<	#endif
1364	<	PyString_ConcatAndDel(&repr,nrep);
1365	<	}
1366	<	return repr;
1367	<	}
1368	<
1369	<	SWIGRUNTIME int
1370	<	PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371	<	{
1372	<	#ifdef METH_NOARGS
1373	<	PyObject *repr = PySwigObject_repr(v);
1374	<	#else
1375	<	PyObject *repr = PySwigObject_repr(v, NULL);
1376	<	#endif
1377	<	if (repr) {
1378	<	fputs(PyString_AsString(repr), fp);
1379	<	Py_DECREF(repr);
1380	<	return 0;
1381	<	} else {
1382	<	return 1;
1383	<	}
1384	<	}
1385	<
1386	<	SWIGRUNTIME PyObject *
1387	<	PySwigObject_str(PySwigObject *v)
1388	<	{
1389	<	char result[SWIG_BUFFER_SIZE];
1390	<	return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391	<	PyString_FromString(result) : 0;
1392	<	}
1393	<
1394	<	SWIGRUNTIME int
1395	<	PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396	<	{
1397	<	void *i = v->ptr;
1398	<	void *j = w->ptr;
1399	<	return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400	<	}
1401	<
1402	<	SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403	<
1404	<	SWIGRUNTIME PyTypeObject*
1405	<	PySwigObject_type(void) {
1406	<	static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407	<	return type;
1408	<	}
1409	<
1410	<	SWIGRUNTIMEINLINE int
1411	<	PySwigObject_Check(PyObject *op) {
1412	<	return ((op)->ob_type == PySwigObject_type())
1413	<	|| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414	<	}
1415	<
1416	<	SWIGRUNTIME PyObject *
1417	<	PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418	<
1419	<	SWIGRUNTIME void
1420	<	PySwigObject_dealloc(PyObject *v)
1421	<	{
1422	<	PySwigObject *sobj = (PySwigObject *) v;
1423	<	PyObject *next = sobj->next;
1424	<	if (sobj->own) {
1425	<	swig_type_info *ty = sobj->ty;
1426	<	PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427	<	PyObject *destroy = data ? data->destroy : 0;
1428	<	if (destroy) {
1429	<	/* destroy is always a VARARGS method */
1430	<	PyObject *res;
1431	<	if (data->delargs) {
1432	<	/* we need to create a temporal object to carry the destroy operation */
1433	<	PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434	<	res = SWIG_Python_CallFunctor(destroy, tmp);
1435	<	Py_DECREF(tmp);
1436	<	} else {
1437	<	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438	<	PyObject *mself = PyCFunction_GET_SELF(destroy);
1439	<	res = ((*meth)(mself, v));
1440	<	}
1441	<	Py_XDECREF(res);
1442	<	} else {
1443	<	const char *name = SWIG_TypePrettyName(ty);
1444	<	#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445	<	printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446	<	#endif
1447	<	}
1448	<	}
1449	<	Py_XDECREF(next);
1450	<	PyObject_DEL(v);
1451	<	}
1452	<
1453	<	SWIGRUNTIME PyObject*
1454	<	PySwigObject_append(PyObject* v, PyObject* next)
1455	<	{
1456	<	PySwigObject *sobj = (PySwigObject *) v;
1457	<	#ifndef METH_O
1458	<	PyObject *tmp = 0;
1459	<	if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460	<	next = tmp;
1461	<	#endif
1462	<	if (!PySwigObject_Check(next)) {
1463	<	return NULL;
1464	<	}
1465	<	sobj->next = next;
1466	<	Py_INCREF(next);
1467	<	return SWIG_Py_Void();
306	>	static PyObject *
307	>	swig_varlink_repr(swig_varlinkobject *v) {
308	>	v = v;
309	>	return PyString_FromString("<Global variables>");
310		}
311
312	<	SWIGRUNTIME PyObject*
313	<	#ifdef METH_NOARGS
314	<	PySwigObject_next(PyObject* v)
315	<	#else
316	<	PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
317	<	#endif
318	<	{
319	<	PySwigObject *sobj = (PySwigObject *) v;
1478	<	if (sobj->next) {
1479	<	Py_INCREF(sobj->next);
1480	<	return sobj->next;
1481	<	} else {
1482	<	return SWIG_Py_Void();
312	>	static int
313	>	swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
314	>	swig_globalvar  *var;
315	>	flags = flags;
316	>	fprintf(fp,"Global variables { ");
317	>	for (var = v->vars; var; var=var->next) {
318	>	fprintf(fp,"%s", var->name);
319	>	if (var->next) fprintf(fp,", ");
320		}
321	+	fprintf(fp," }\n");
322	+	return 0;
323		}
324
325	<	SWIGINTERN PyObject*
326	<	#ifdef METH_NOARGS
327	<	PySwigObject_disown(PyObject *v)
328	<	#else
329	<	PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
330	<	#endif
331	<	{
332	<	PySwigObject *sobj = (PySwigObject *)v;
333	<	sobj->own = 0;
334	<	return SWIG_Py_Void();
335	<	}
1497	<
1498	<	SWIGINTERN PyObject*
1499	<	#ifdef METH_NOARGS
1500	<	PySwigObject_acquire(PyObject *v)
1501	<	#else
1502	<	PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503	<	#endif
1504	<	{
1505	<	PySwigObject *sobj = (PySwigObject *)v;
1506	<	sobj->own = SWIG_POINTER_OWN;
1507	<	return SWIG_Py_Void();
1508	<	}
1509	<
1510	<	SWIGINTERN PyObject*
1511	<	PySwigObject_own(PyObject *v, PyObject *args)
1512	<	{
1513	<	PyObject *val = 0;
1514	<	#if (PY_VERSION_HEX < 0x02020000)
1515	<	if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516	<	#else
1517	<	if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518	<	#endif
1519	<	{
1520	<	return NULL;
1521	<	}
1522	<	else
1523	<	{
1524	<	PySwigObject *sobj = (PySwigObject *)v;
1525	<	PyObject *obj = PyBool_FromLong(sobj->own);
1526	<	if (val) {
1527	<	#ifdef METH_NOARGS
1528	<	if (PyObject_IsTrue(val)) {
1529	<	PySwigObject_acquire(v);
1530	<	} else {
1531	<	PySwigObject_disown(v);
1532	<	}
1533	<	#else
1534	<	if (PyObject_IsTrue(val)) {
1535	<	PySwigObject_acquire(v,args);
1536	<	} else {
1537	<	PySwigObject_disown(v,args);
1538	<	}
1539	<	#endif
1540	<	}
1541	<	return obj;
1542	<	}
325	>	static PyObject *
326	>	swig_varlink_getattr(swig_varlinkobject *v, char *n) {
327	>	swig_globalvar *var = v->vars;
328	>	while (var) {
329	>	if (strcmp(var->name,n) == 0) {
330	>	return (*var->get_attr)();
331	>	}
332	>	var = var->next;
333	>	}
334	>	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
335	>	return NULL;
336		}
337
338	<	#ifdef METH_O
339	<	static PyMethodDef
340	<	swigobject_methods[] = {
341	<	{(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
342	<	{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
343	<	{(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
344	<	{(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
345	<	{(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
346	<	{(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
347	<	{0, 0, 0, 0}
338	>	static int
339	>	swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
340	>	swig_globalvar *var = v->vars;
341	>	while (var) {
342	>	if (strcmp(var->name,n) == 0) {
343	>	return (*var->set_attr)(p);
344	>	}
345	>	var = var->next;
346	>	}
347	>	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
348	>	return 1;
349	>	}
350	>
351	>	statichere PyTypeObject varlinktype = {
352	>	PyObject_HEAD_INIT(0)
353	>	0,
354	>	(char *)"swigvarlink",                      /* Type name    */
355	>	sizeof(swig_varlinkobject),         /* Basic size   */
356	>	0,                                  /* Itemsize     */
357	>	0,                                  /* Deallocator  */
358	>	(printfunc) swig_varlink_print,     /* Print        */
359	>	(getattrfunc) swig_varlink_getattr, /* get attr     */
360	>	(setattrfunc) swig_varlink_setattr, /* Set attr     */
361	>	0,                                  /* tp_compare   */
362	>	(reprfunc) swig_varlink_repr,       /* tp_repr      */
363	>	0,                                  /* tp_as_number */
364	>	0,                                  /* tp_as_mapping*/
365	>	0,                                  /* tp_hash      */
366		};
1556	–	#else
1557	–	static PyMethodDef
1558	–	swigobject_methods[] = {
1559	–	{(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1560	–	{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1561	–	{(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1562	–	{(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1563	–	{(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1564	–	{(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1565	–	{0, 0, 0, 0}
1566	–	};
1567	–	#endif
1568	–
1569	–	#if PY_VERSION_HEX < 0x02020000
1570	–	SWIGINTERN PyObject *
1571	–	PySwigObject_getattr(PySwigObject *sobj,char *name)
1572	–	{
1573	–	return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574	–	}
1575	–	#endif
1576	–
1577	–	SWIGRUNTIME PyTypeObject*
1578	–	_PySwigObject_type(void) {
1579	–	static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580	–
1581	–	static PyNumberMethods PySwigObject_as_number = {
1582	–	(binaryfunc)0, /*nb_add*/
1583	–	(binaryfunc)0, /*nb_subtract*/
1584	–	(binaryfunc)0, /*nb_multiply*/
1585	–	(binaryfunc)0, /*nb_divide*/
1586	–	(binaryfunc)0, /*nb_remainder*/
1587	–	(binaryfunc)0, /*nb_divmod*/
1588	–	(ternaryfunc)0,/*nb_power*/
1589	–	(unaryfunc)0,  /*nb_negative*/
1590	–	(unaryfunc)0,  /*nb_positive*/
1591	–	(unaryfunc)0,  /*nb_absolute*/
1592	–	(inquiry)0,    /*nb_nonzero*/
1593	–	0,             /*nb_invert*/
1594	–	0,             /*nb_lshift*/
1595	–	0,             /*nb_rshift*/
1596	–	0,             /*nb_and*/
1597	–	0,             /*nb_xor*/
1598	–	0,             /*nb_or*/
1599	–	(coercion)0,   /*nb_coerce*/
1600	–	(unaryfunc)PySwigObject_long, /*nb_int*/
1601	–	(unaryfunc)PySwigObject_long, /*nb_long*/
1602	–	(unaryfunc)0,                 /*nb_float*/
1603	–	(unaryfunc)PySwigObject_oct,  /*nb_oct*/
1604	–	(unaryfunc)PySwigObject_hex,  /*nb_hex*/
1605	–	#if PY_VERSION_HEX >= 0x02020000
1606	–	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607	–	#elif PY_VERSION_HEX >= 0x02000000
1608	–	0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609	–	#endif
1610	–	};
1611	–
1612	–	static PyTypeObject pyswigobject_type;
1613	–	static int type_init = 0;
1614	–	if (!type_init) {
1615	–	const PyTypeObject tmp
1616	–	= {
1617	–	PyObject_HEAD_INIT(NULL)
1618	–	0,                                  /* ob_size */
1619	–	(char *)"PySwigObject",             /* tp_name */
1620	–	sizeof(PySwigObject),               /* tp_basicsize */
1621	–	0,                                  /* tp_itemsize */
1622	–	(destructor)PySwigObject_dealloc,   /* tp_dealloc */
1623	–	(printfunc)PySwigObject_print,      /* tp_print */
1624	–	#if PY_VERSION_HEX < 0x02020000
1625	–	(getattrfunc)PySwigObject_getattr,  /* tp_getattr */
1626	–	#else
1627	–	(getattrfunc)0,                     /* tp_getattr */
1628	–	#endif
1629	–	(setattrfunc)0,                     /* tp_setattr */
1630	–	(cmpfunc)PySwigObject_compare,      /* tp_compare */
1631	–	(reprfunc)PySwigObject_repr,        /* tp_repr */
1632	–	&PySwigObject_as_number,            /* tp_as_number */
1633	–	0,                                  /* tp_as_sequence */
1634	–	0,                                  /* tp_as_mapping */
1635	–	(hashfunc)0,                        /* tp_hash */
1636	–	(ternaryfunc)0,                     /* tp_call */
1637	–	(reprfunc)PySwigObject_str,         /* tp_str */
1638	–	PyObject_GenericGetAttr,            /* tp_getattro */
1639	–	0,                                  /* tp_setattro */
1640	–	0,                                  /* tp_as_buffer */
1641	–	Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1642	–	swigobject_doc,                     /* tp_doc */
1643	–	0,                                  /* tp_traverse */
1644	–	0,                                  /* tp_clear */
1645	–	0,                                  /* tp_richcompare */
1646	–	0,                                  /* tp_weaklistoffset */
1647	–	#if PY_VERSION_HEX >= 0x02020000
1648	–	0,                                  /* tp_iter */
1649	–	0,                                  /* tp_iternext */
1650	–	swigobject_methods,                 /* tp_methods */
1651	–	0,                                  /* tp_members */
1652	–	0,                                  /* tp_getset */
1653	–	0,                                  /* tp_base */
1654	–	0,                                  /* tp_dict */
1655	–	0,                                  /* tp_descr_get */
1656	–	0,                                  /* tp_descr_set */
1657	–	0,                                  /* tp_dictoffset */
1658	–	0,                                  /* tp_init */
1659	–	0,                                  /* tp_alloc */
1660	–	0,                                  /* tp_new */
1661	–	0,                                  /* tp_free */
1662	–	0,                                  /* tp_is_gc */
1663	–	0,                                  /* tp_bases */
1664	–	0,                                  /* tp_mro */
1665	–	0,                                  /* tp_cache */
1666	–	0,                                  /* tp_subclasses */
1667	–	0,                                  /* tp_weaklist */
1668	–	#endif
1669	–	#if PY_VERSION_HEX >= 0x02030000
1670	–	0,                                  /* tp_del */
1671	–	#endif
1672	–	#ifdef COUNT_ALLOCS
1673	–	0,0,0,0                             /* tp_alloc -> tp_next */
1674	–	#endif
1675	–	};
1676	–	pyswigobject_type = tmp;
1677	–	pyswigobject_type.ob_type = &PyType_Type;
1678	–	type_init = 1;
1679	–	}
1680	–	return &pyswigobject_type;
1681	–	}
1682	–
1683	–	SWIGRUNTIME PyObject *
1684	–	PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685	–	{
1686	–	PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687	–	if (sobj) {
1688	–	sobj->ptr  = ptr;
1689	–	sobj->ty   = ty;
1690	–	sobj->own  = own;
1691	–	sobj->next = 0;
1692	–	}
1693	–	return (PyObject *)sobj;
1694	–	}
1695	–
1696	–	/* -----------------------------------------------------------------------------
1697	–	* Implements a simple Swig Packed type, and use it instead of string
1698	–	* ----------------------------------------------------------------------------- */
1699	–
1700	–	typedef struct {
1701	–	PyObject_HEAD
1702	–	void *pack;
1703	–	swig_type_info *ty;
1704	–	size_t size;
1705	–	} PySwigPacked;
1706	–
1707	–	SWIGRUNTIME int
1708	–	PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709	–	{
1710	–	char result[SWIG_BUFFER_SIZE];
1711	–	fputs("<Swig Packed ", fp);
1712	–	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713	–	fputs("at ", fp);
1714	–	fputs(result, fp);
1715	–	}
1716	–	fputs(v->ty->name,fp);
1717	–	fputs(">", fp);
1718	–	return 0;
1719	–	}
1720	–
1721	–	SWIGRUNTIME PyObject *
1722	–	PySwigPacked_repr(PySwigPacked *v)
1723	–	{
1724	–	char result[SWIG_BUFFER_SIZE];
1725	–	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726	–	return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727	–	} else {
1728	–	return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729	–	}
1730	–	}
1731	–
1732	–	SWIGRUNTIME PyObject *
1733	–	PySwigPacked_str(PySwigPacked *v)
1734	–	{
1735	–	char result[SWIG_BUFFER_SIZE];
1736	–	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737	–	return PyString_FromFormat("%s%s", result, v->ty->name);
1738	–	} else {
1739	–	return PyString_FromString(v->ty->name);
1740	–	}
1741	–	}
1742	–
1743	–	SWIGRUNTIME int
1744	–	PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745	–	{
1746	–	size_t i = v->size;
1747	–	size_t j = w->size;
1748	–	int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749	–	return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750	–	}
1751	–
1752	–	SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753	–
1754	–	SWIGRUNTIME PyTypeObject*
1755	–	PySwigPacked_type(void) {
1756	–	static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757	–	return type;
1758	–	}
1759	–
1760	–	SWIGRUNTIMEINLINE int
1761	–	PySwigPacked_Check(PyObject *op) {
1762	–	return ((op)->ob_type == _PySwigPacked_type())
1763	–	|| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764	–	}
367
368	<	SWIGRUNTIME void
369	<	PySwigPacked_dealloc(PyObject *v)
370	<	{
371	<	if (PySwigPacked_Check(v)) {
372	<	PySwigPacked *sobj = (PySwigPacked *) v;
373	<	free(sobj->pack);
368	>	/* Create a variable linking object for use later */
369	>	SWIGRUNTIME(PyObject *)
370	>	SWIG_newvarlink(void) {
371	>	swig_varlinkobject *result = 0;
372	>	result = PyMem_NEW(swig_varlinkobject,1);
373	>	varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
374	>	result->ob_type = &varlinktype;
375	>	result->vars = 0;
376	>	result->ob_refcnt = 0;
377	>	Py_XINCREF((PyObject *) result);
378	>	return ((PyObject*) result);
379	>	}
380	>
381	>	SWIGRUNTIME(void)
382	>	SWIG_addvarlink(PyObject *p, char *name,
383	>	PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
384	>	swig_varlinkobject *v;
385	>	swig_globalvar *gv;
386	>	v= (swig_varlinkobject *) p;
387	>	gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
388	>	gv->name = (char *) malloc(strlen(name)+1);
389	>	strcpy(gv->name,name);
390	>	gv->get_attr = get_attr;
391	>	gv->set_attr = set_attr;
392	>	gv->next = v->vars;
393	>	v->vars = gv;
394	>	}
395	>
396	>	/* Pack binary data into a string */
397	>	SWIGRUNTIME(char *)
398	>	SWIG_PackData(char *c, void *ptr, int sz) {
399	>	static char hex[17] = "0123456789abcdef";
400	>	int i;
401	>	unsigned char *u = (unsigned char *) ptr;
402	>	register unsigned char uu;
403	>	for (i = 0; i < sz; i++,u++) {
404	>	uu = *u;
405	>	*(c++) = hex[(uu & 0xf0) >> 4];
406	>	*(c++) = hex[uu & 0xf];
407		}
408	<	PyObject_DEL(v);
408	>	return c;
409		}
410
411	<	SWIGRUNTIME PyTypeObject*
412	<	_PySwigPacked_type(void) {
413	<	static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
414	<	static PyTypeObject pyswigpacked_type;
415	<	static int type_init = 0;
416	<	if (!type_init) {
417	<	const PyTypeObject tmp
418	<	= {
419	<	PyObject_HEAD_INIT(NULL)
420	<	0,                                  /* ob_size */
421	<	(char *)"PySwigPacked",             /* tp_name */
422	<	sizeof(PySwigPacked),               /* tp_basicsize */
423	<	0,                                  /* tp_itemsize */
424	<	(destructor)PySwigPacked_dealloc,   /* tp_dealloc */
425	<	(printfunc)PySwigPacked_print,      /* tp_print */
426	<	(getattrfunc)0,                     /* tp_getattr */
427	<	(setattrfunc)0,                     /* tp_setattr */
428	<	(cmpfunc)PySwigPacked_compare,      /* tp_compare */
429	<	(reprfunc)PySwigPacked_repr,        /* tp_repr */
1795	<	0,                                  /* tp_as_number */
1796	<	0,                                  /* tp_as_sequence */
1797	<	0,                                  /* tp_as_mapping */
1798	<	(hashfunc)0,                        /* tp_hash */
1799	<	(ternaryfunc)0,                     /* tp_call */
1800	<	(reprfunc)PySwigPacked_str,         /* tp_str */
1801	<	PyObject_GenericGetAttr,            /* tp_getattro */
1802	<	0,                                  /* tp_setattro */
1803	<	0,                                  /* tp_as_buffer */
1804	<	Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1805	<	swigpacked_doc,                     /* tp_doc */
1806	<	0,                                  /* tp_traverse */
1807	<	0,                                  /* tp_clear */
1808	<	0,                                  /* tp_richcompare */
1809	<	0,                                  /* tp_weaklistoffset */
1810	<	#if PY_VERSION_HEX >= 0x02020000
1811	<	0,                                  /* tp_iter */
1812	<	0,                                  /* tp_iternext */
1813	<	0,                                  /* tp_methods */
1814	<	0,                                  /* tp_members */
1815	<	0,                                  /* tp_getset */
1816	<	0,                                  /* tp_base */
1817	<	0,                                  /* tp_dict */
1818	<	0,                                  /* tp_descr_get */
1819	<	0,                                  /* tp_descr_set */
1820	<	0,                                  /* tp_dictoffset */
1821	<	0,                                  /* tp_init */
1822	<	0,                                  /* tp_alloc */
1823	<	0,                                  /* tp_new */
1824	<	0,                                  /* tp_free */
1825	<	0,                                  /* tp_is_gc */
1826	<	0,                                  /* tp_bases */
1827	<	0,                                  /* tp_mro */
1828	<	0,                                  /* tp_cache */
1829	<	0,                                  /* tp_subclasses */
1830	<	0,                                  /* tp_weaklist */
1831	<	#endif
1832	<	#if PY_VERSION_HEX >= 0x02030000
1833	<	0,                                  /* tp_del */
1834	<	#endif
1835	<	#ifdef COUNT_ALLOCS
1836	<	0,0,0,0                             /* tp_alloc -> tp_next */
1837	<	#endif
1838	<	};
1839	<	pyswigpacked_type = tmp;
1840	<	pyswigpacked_type.ob_type = &PyType_Type;
1841	<	type_init = 1;
411	>	/* Unpack binary data from a string */
412	>	SWIGRUNTIME(char *)
413	>	SWIG_UnpackData(char *c, void *ptr, int sz) {
414	>	register unsigned char uu = 0;
415	>	register int d;
416	>	unsigned char *u = (unsigned char *) ptr;
417	>	int i;
418	>	for (i = 0; i < sz; i++, u++) {
419	>	d = *(c++);
420	>	if ((d >= '0') && (d <= '9'))
421	>	uu = ((d - '0') << 4);
422	>	else if ((d >= 'a') && (d <= 'f'))
423	>	uu = ((d - ('a'-10)) << 4);
424	>	d = *(c++);
425	>	if ((d >= '0') && (d <= '9'))
426	>	uu |= (d - '0');
427	>	else if ((d >= 'a') && (d <= 'f'))
428	>	uu |= (d - ('a'-10));
429	>	*u = uu;
430		}
431	<	return &pyswigpacked_type;
431	>	return c;
432		}
433
434	<	SWIGRUNTIME PyObject *
435	<	PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
436	<	{
437	<	PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
438	<	if (sobj) {
439	<	void *pack = malloc(size);
440	<	if (pack) {
441	<	memcpy(pack, ptr, size);
1854	<	sobj->pack = pack;
1855	<	sobj->ty   = ty;
1856	<	sobj->size = size;
1857	<	} else {
1858	<	PyObject_DEL((PyObject *) sobj);
1859	<	sobj = 0;
1860	<	}
1861	<	}
1862	<	return (PyObject *) sobj;
1863	<	}
434	>	/* Convert a pointer value */
435	>	SWIGRUNTIME(int)
436	>	SWIG_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
437	>	swig_type_info *tc;
438	>	char  *c;
439	>	static PyObject *SWIG_this = 0;
440	>	int    newref = 0;
441	>	PyObject  *pyobj = 0;
442
443	<	SWIGRUNTIME swig_type_info *
444	<	PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
445	<	{
1868	<	if (PySwigPacked_Check(obj)) {
1869	<	PySwigPacked *sobj = (PySwigPacked *)obj;
1870	<	if (sobj->size != size) return 0;
1871	<	memcpy(ptr, sobj->pack, size);
1872	<	return sobj->ty;
1873	<	} else {
443	>	if (!obj) return 0;
444	>	if (obj == Py_None) {
445	>	*ptr = 0;
446		return 0;
447		}
448	<	}
449	<
450	<	/* -----------------------------------------------------------------------------
451	<	* pointers/data manipulation
452	<	* ----------------------------------------------------------------------------- */
453	<
454	<	SWIGRUNTIMEINLINE PyObject *
455	<	_SWIG_This(void)
456	<	{
457	<	return PyString_FromString("this");
458	<	}
1887	<
1888	<	SWIGRUNTIME PyObject *
1889	<	SWIG_This(void)
1890	<	{
1891	<	static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892	<	return swig_this;
1893	<	}
1894	<
1895	<	/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896	<
1897	<	SWIGRUNTIME PySwigObject *
1898	<	SWIG_Python_GetSwigThis(PyObject *pyobj)
1899	<	{
1900	<	if (PySwigObject_Check(pyobj)) {
1901	<	return (PySwigObject *) pyobj;
1902	<	} else {
1903	<	PyObject *obj = 0;
1904	<	#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905	<	if (PyInstance_Check(pyobj)) {
1906	<	obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907	<	} else {
1908	<	PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909	<	if (dictptr != NULL) {
1910	<	PyObject *dict = *dictptr;
1911	<	obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912	<	} else {
1913	<	#ifdef PyWeakref_CheckProxy
1914	<	if (PyWeakref_CheckProxy(pyobj)) {
1915	<	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916	<	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917	<	}
1918	<	#endif
1919	<	obj = PyObject_GetAttr(pyobj,SWIG_This());
1920	<	if (obj) {
1921	<	Py_DECREF(obj);
1922	<	} else {
1923	<	if (PyErr_Occurred()) PyErr_Clear();
1924	<	return 0;
1925	<	}
1926	<	}
448	>	#ifdef SWIG_COBJECT_TYPES
449	>	if (!(PyCObject_Check(obj))) {
450	>	if (!SWIG_this)
451	>	SWIG_this = PyString_FromString("this");
452	>	pyobj = obj;
453	>	obj = PyObject_GetAttr(obj,SWIG_this);
454	>	newref = 1;
455	>	if (!obj) goto type_error;
456	>	if (!PyCObject_Check(obj)) {
457	>	Py_DECREF(obj);
458	>	goto type_error;
459		}
460	+	}
461	+	*ptr = PyCObject_AsVoidPtr(obj);
462	+	c = (char *) PyCObject_GetDesc(obj);
463	+	if (newref) Py_DECREF(obj);
464	+	goto cobject;
465		#else
466	<	obj = PyObject_GetAttr(pyobj,SWIG_This());
467	<	if (obj) {
466	>	if (!(PyString_Check(obj))) {
467	>	if (!SWIG_this)
468	>	SWIG_this = PyString_FromString("this");
469	>	pyobj = obj;
470	>	obj = PyObject_GetAttr(obj,SWIG_this);
471	>	newref = 1;
472	>	if (!obj) goto type_error;
473	>	if (!PyString_Check(obj)) {
474		Py_DECREF(obj);
475	<	} else {
1933	<	if (PyErr_Occurred()) PyErr_Clear();
1934	<	return 0;
475	>	goto type_error;
476		}
477	<	#endif
478	<	if (obj && !PySwigObject_Check(obj)) {
479	<	/* a PyObject is called 'this', try to get the 'real this'
480	<	PySwigObject from it */
481	<	return SWIG_Python_GetSwigThis(obj);
477	>	}
478	>	c = PyString_AsString(obj);
479	>	/* Pointer values must start with leading underscore */
480	>	if (*c != '_') {
481	>	*ptr = (void *) 0;
482	>	if (strcmp(c,"NULL") == 0) {
483	>	if (newref) { Py_DECREF(obj); }
484	>	return 0;
485	>	} else {
486	>	if (newref) { Py_DECREF(obj); }
487	>	goto type_error;
488		}
1942	–	return (PySwigObject *)obj;
489		}
490	<	}
490	>	c++;
491	>	c = SWIG_UnpackData(c,ptr,sizeof(void *));
492	>	if (newref) { Py_DECREF(obj); }
493	>	#endif
494
495	<	/* Acquire a pointer value */
495	>	#ifdef SWIG_COBJECT_TYPES
496	>	cobject:
497	>	#endif
498
499	<	SWIGRUNTIME int
500	<	SWIG_Python_AcquirePtr(PyObject *obj, int own) {
501	<	if (own) {
502	<	PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952	<	if (sobj) {
1953	<	int oldown = sobj->own;
1954	<	sobj->own = own;
1955	<	return oldown;
1956	<	}
499	>	if (ty) {
500	>	tc = SWIG_TypeCheck(c,ty);
501	>	if (!tc) goto type_error;
502	>	*ptr = SWIG_TypeCast(tc,(void*) *ptr);
503		}
1958	–	return 0;
1959	–	}
1960	–
1961	–	/* Convert a pointer value */
504
505	<	SWIGRUNTIME int
506	<	SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
507	<	if (!obj) return SWIG_ERROR;
508	<	if (obj == Py_None) {
1967	<	if (ptr) *ptr = 0;
1968	<	return SWIG_OK;
1969	<	} else {
1970	<	PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971	<	while (sobj) {
1972	<	void *vptr = sobj->ptr;
1973	<	if (ty) {
1974	<	swig_type_info *to = sobj->ty;
1975	<	if (to == ty) {
1976	<	/* no type cast needed */
1977	<	if (ptr) *ptr = vptr;
1978	<	break;
1979	<	} else {
1980	<	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981	<	if (!tc) {
1982	<	sobj = (PySwigObject *)sobj->next;
1983	<	} else {
1984	<	if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985	<	break;
1986	<	}
1987	<	}
1988	<	} else {
1989	<	if (ptr) *ptr = vptr;
1990	<	break;
1991	<	}
1992	<	}
1993	<	if (sobj) {
1994	<	if (own) *own = sobj->own;
1995	<	if (flags & SWIG_POINTER_DISOWN) {
1996	<	sobj->own = 0;
1997	<	}
1998	<	return SWIG_OK;
1999	<	} else {
2000	<	int res = SWIG_ERROR;
2001	<	if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002	<	PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003	<	if (data && !data->implicitconv) {
2004	<	PyObject *klass = data->klass;
2005	<	if (klass) {
2006	<	PyObject *impconv;
2007	<	data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008	<	impconv = SWIG_Python_CallFunctor(klass, obj);
2009	<	data->implicitconv = 0;
2010	<	if (PyErr_Occurred()) {
2011	<	PyErr_Clear();
2012	<	impconv = 0;
2013	<	}
2014	<	if (impconv) {
2015	<	PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016	<	if (iobj) {
2017	<	void *vptr;
2018	<	res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019	<	if (SWIG_IsOK(res)) {
2020	<	if (ptr) {
2021	<	*ptr = vptr;
2022	<	/* transfer the ownership to 'ptr' */
2023	<	iobj->own = 0;
2024	<	res = SWIG_AddCast(res);
2025	<	res = SWIG_AddNewMask(res);
2026	<	} else {
2027	<	res = SWIG_AddCast(res);
2028	<	}
2029	<	}
2030	<	}
2031	<	Py_DECREF(impconv);
2032	<	}
2033	<	}
2034	<	}
2035	<	}
2036	<	return res;
2037	<	}
505	>	if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
506	>	PyObject *zero = PyInt_FromLong(0);
507	>	PyObject_SetAttrString(pyobj,(char*)"thisown",zero);
508	>	Py_DECREF(zero);
509		}
510	<	}
2040	<
2041	<	/* Convert a function ptr value */
510	>	return 0;
511
512	<	SWIGRUNTIME int
513	<	SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045	<	if (!PyCFunction_Check(obj)) {
2046	<	return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047	<	} else {
2048	<	void *vptr = 0;
2049	<
2050	<	/* here we get the method pointer for callbacks */
2051	<	char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052	<	const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053	<	if (desc) {
2054	<	desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055	<	if (!desc) return SWIG_ERROR;
2056	<	}
512	>	type_error:
513	>	if (flags & SWIG_POINTER_EXCEPTION) {
514		if (ty) {
515	<	swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
516	<	if (!tc) return SWIG_ERROR;
517	<	*ptr = SWIG_TypeCast(tc,vptr);
515	>	char *temp = (char *) malloc(64+strlen(ty->name));
516	>	sprintf(temp,"Type error. Expected %s", ty->name);
517	>	PyErr_SetString(PyExc_TypeError, temp);
518	>	free((char *) temp);
519		} else {
520	<	*ptr = vptr;
520	>	PyErr_SetString(PyExc_TypeError,"Expected a pointer");
521		}
2064	–	return SWIG_OK;
522		}
523	+	return -1;
524		}
525
526		/* Convert a packed value value */
527	<
528	<	SWIGRUNTIME int
529	<	SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
530	<	swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
531	<	if (!to) return SWIG_ERROR;
527	>	SWIGRUNTIME(int)
528	>	SWIG_ConvertPacked(PyObject *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
529	>	swig_type_info *tc;
530	>	char  *c;
531	>
532	>	if ((!obj) || (!PyString_Check(obj))) goto type_error;
533	>	c = PyString_AsString(obj);
534	>	/* Pointer values must start with leading underscore */
535	>	if (*c != '_') goto type_error;
536	>	c++;
537	>	c = SWIG_UnpackData(c,ptr,sz);
538		if (ty) {
539	<	if (to != ty) {
540	<	/* check type cast? */
2077	<	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078	<	if (!tc) return SWIG_ERROR;
2079	<	}
2080	<	}
2081	<	return SWIG_OK;
2082	<	}
2083	<
2084	<	/* -----------------------------------------------------------------------------
2085	<	* Create a new pointer object
2086	<	* ----------------------------------------------------------------------------- */
2087	<
2088	<	/*
2089	<	Create a new instance object, whitout calling __init__, and set the
2090	<	'this' attribute.
2091	<	*/
2092	<
2093	<	SWIGRUNTIME PyObject*
2094	<	SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095	<	{
2096	<	#if (PY_VERSION_HEX >= 0x02020000)
2097	<	PyObject *inst = 0;
2098	<	PyObject *newraw = data->newraw;
2099	<	if (newraw) {
2100	<	inst = PyObject_Call(newraw, data->newargs, NULL);
2101	<	if (inst) {
2102	<	#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103	<	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104	<	if (dictptr != NULL) {
2105	<	PyObject *dict = *dictptr;
2106	<	if (dict == NULL) {
2107	<	dict = PyDict_New();
2108	<	*dictptr = dict;
2109	<	PyDict_SetItem(dict, SWIG_This(), swig_this);
2110	<	}
2111	<	}
2112	<	#else
2113	<	PyObject *key = SWIG_This();
2114	<	PyObject_SetAttr(inst, key, swig_this);
2115	<	#endif
2116	<	}
2117	<	} else {
2118	<	PyObject *dict = PyDict_New();
2119	<	PyDict_SetItem(dict, SWIG_This(), swig_this);
2120	<	inst = PyInstance_NewRaw(data->newargs, dict);
2121	<	Py_DECREF(dict);
2122	<	}
2123	<	return inst;
2124	<	#else
2125	<	#if (PY_VERSION_HEX >= 0x02010000)
2126	<	PyObject *inst;
2127	<	PyObject *dict = PyDict_New();
2128	<	PyDict_SetItem(dict, SWIG_This(), swig_this);
2129	<	inst = PyInstance_NewRaw(data->newargs, dict);
2130	<	Py_DECREF(dict);
2131	<	return (PyObject *) inst;
2132	<	#else
2133	<	PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134	<	if (inst == NULL) {
2135	<	return NULL;
539	>	tc = SWIG_TypeCheck(c,ty);
540	>	if (!tc) goto type_error;
541		}
542	<	inst->in_class = (PyClassObject *)data->newargs;
2138	<	Py_INCREF(inst->in_class);
2139	<	inst->in_dict = PyDict_New();
2140	<	if (inst->in_dict == NULL) {
2141	<	Py_DECREF(inst);
2142	<	return NULL;
2143	<	}
2144	<	#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145	<	inst->in_weakreflist = NULL;
2146	<	#endif
2147	<	#ifdef Py_TPFLAGS_GC
2148	<	PyObject_GC_Init(inst);
2149	<	#endif
2150	<	PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151	<	return (PyObject *) inst;
2152	<	#endif
2153	<	#endif
2154	<	}
2155	<
2156	<	SWIGRUNTIME void
2157	<	SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158	<	{
2159	<	PyObject *dict;
2160	<	#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161	<	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162	<	if (dictptr != NULL) {
2163	<	dict = *dictptr;
2164	<	if (dict == NULL) {
2165	<	dict = PyDict_New();
2166	<	*dictptr = dict;
2167	<	}
2168	<	PyDict_SetItem(dict, SWIG_This(), swig_this);
2169	<	return;
2170	<	}
2171	<	#endif
2172	<	dict = PyObject_GetAttrString(inst, "__dict__");
2173	<	PyDict_SetItem(dict, SWIG_This(), swig_this);
2174	<	Py_DECREF(dict);
2175	<	}
542	>	return 0;
543
544	+	type_error:
545
546	<	SWIGINTERN PyObject *
547	<	SWIG_Python_InitShadowInstance(PyObject *args) {
548	<	PyObject *obj[2];
549	<	if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
550	<	return NULL;
551	<	} else {
2184	<	PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185	<	if (sthis) {
2186	<	PySwigObject_append((PyObject*) sthis, obj[1]);
546	>	if (flags) {
547	>	if (ty) {
548	>	char *temp = (char *) malloc(64+strlen(ty->name));
549	>	sprintf(temp,"Type error. Expected %s", ty->name);
550	>	PyErr_SetString(PyExc_TypeError, temp);
551	>	free((char *) temp);
552		} else {
553	<	SWIG_Python_SetSwigThis(obj[0], obj[1]);
553	>	PyErr_SetString(PyExc_TypeError,"Expected a pointer");
554		}
2190	–	return SWIG_Py_Void();
555		}
556	+	return -1;
557		}
558
559		/* Create a new pointer object */
560	<
561	<	SWIGRUNTIME PyObject *
562	<	SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
560	>	SWIGRUNTIME(PyObject *)
561	>	SWIG_NewPointerObj(void *ptr, swig_type_info *type, int own) {
562	>	PyObject *robj;
563		if (!ptr) {
564	<	return SWIG_Py_Void();
565	<	} else {
2201	<	int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202	<	PyObject *robj = PySwigObject_New(ptr, type, own);
2203	<	PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204	<	if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205	<	PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206	<	if (inst) {
2207	<	Py_DECREF(robj);
2208	<	robj = inst;
2209	<	}
2210	<	}
2211	<	return robj;
564	>	Py_INCREF(Py_None);
565	>	return Py_None;
566		}
567	<	}
568	<
2215	<	/* Create a new packed object */
2216	<
2217	<	SWIGRUNTIMEINLINE PyObject *
2218	<	SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219	<	return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220	<	}
2221	<
2222	<	/* -----------------------------------------------------------------------------*
2223	<	*  Get type list
2224	<	* -----------------------------------------------------------------------------*/
2225	<
2226	<	#ifdef SWIG_LINK_RUNTIME
2227	<	void *SWIG_ReturnGlobalTypeList(void *);
2228	<	#endif
2229	<
2230	<	SWIGRUNTIME swig_module_info *
2231	<	SWIG_Python_GetModule(void) {
2232	<	static void *type_pointer = (void *)0;
2233	<	/* first check if module already created */
2234	<	if (!type_pointer) {
2235	<	#ifdef SWIG_LINK_RUNTIME
2236	<	type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
567	>	#ifdef SWIG_COBJECT_TYPES
568	>	robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL);
569		#else
570	<	type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
571	<	(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
572	<	if (PyErr_Occurred()) {
573	<	PyErr_Clear();
574	<	type_pointer = (void *)0;
575	<	}
576	<	#endif
2245	<	}
2246	<	return (swig_module_info *) type_pointer;
2247	<	}
2248	<
2249	<	#if PY_MAJOR_VERSION < 2
2250	<	/* PyModule_AddObject function was introduced in Python 2.0.  The following function
2251	<	is copied out of Python/modsupport.c in python version 2.3.4 */
2252	<	SWIGINTERN int
2253	<	PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254	<	{
2255	<	PyObject *dict;
2256	<	if (!PyModule_Check(m)) {
2257	<	PyErr_SetString(PyExc_TypeError,
2258	<	"PyModule_AddObject() needs module as first arg");
2259	<	return SWIG_ERROR;
2260	<	}
2261	<	if (!o) {
2262	<	PyErr_SetString(PyExc_TypeError,
2263	<	"PyModule_AddObject() needs non-NULL value");
2264	<	return SWIG_ERROR;
2265	<	}
2266	<
2267	<	dict = PyModule_GetDict(m);
2268	<	if (dict == NULL) {
2269	<	/* Internal error -- modules must have a dict! */
2270	<	PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271	<	PyModule_GetName(m));
2272	<	return SWIG_ERROR;
570	>	{
571	>	char result[1024];
572	>	char *r = result;
573	>	*(r++) = '_';
574	>	r = SWIG_PackData(r,&ptr,sizeof(void *));
575	>	strcpy(r,type->name);
576	>	robj = PyString_FromString(result);
577		}
2274	–	if (PyDict_SetItemString(dict, name, o))
2275	–	return SWIG_ERROR;
2276	–	Py_DECREF(o);
2277	–	return SWIG_OK;
2278	–	}
578		#endif
579	<
580	<	SWIGRUNTIME void
581	<	SWIG_Python_DestroyModule(void *vptr)
582	<	{
583	<	swig_module_info *swig_module = (swig_module_info *) vptr;
584	<	swig_type_info **types = swig_module->types;
585	<	size_t i;
586	<	for (i =0; i < swig_module->size; ++i) {
587	<	swig_type_info *ty = types[i];
588	<	if (ty->owndata) {
589	<	PySwigClientData *data = (PySwigClientData *) ty->clientdata;
590	<	if (data) PySwigClientData_Del(data);
2292	<	}
2293	<	}
2294	<	Py_DECREF(SWIG_This());
2295	<	}
2296	<
2297	<	SWIGRUNTIME void
2298	<	SWIG_Python_SetModule(swig_module_info *swig_module) {
2299	<	static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300	<
2301	<	PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302	<	swig_empty_runtime_method_table);
2303	<	PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304	<	if (pointer && module) {
2305	<	PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306	<	} else {
2307	<	Py_XDECREF(pointer);
2308	<	}
2309	<	}
2310	<
2311	<	/* The python cached type query */
2312	<	SWIGRUNTIME PyObject *
2313	<	SWIG_Python_TypeCache() {
2314	<	static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315	<	return cache;
2316	<	}
2317	<
2318	<	SWIGRUNTIME swig_type_info *
2319	<	SWIG_Python_TypeQuery(const char *type)
2320	<	{
2321	<	PyObject *cache = SWIG_Python_TypeCache();
2322	<	PyObject *key = PyString_FromString(type);
2323	<	PyObject *obj = PyDict_GetItem(cache, key);
2324	<	swig_type_info *descriptor;
2325	<	if (obj) {
2326	<	descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327	<	} else {
2328	<	swig_module_info *swig_module = SWIG_Python_GetModule();
2329	<	descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330	<	if (descriptor) {
2331	<	obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332	<	PyDict_SetItem(cache, key, obj);
2333	<	Py_DECREF(obj);
2334	<	}
2335	<	}
2336	<	Py_DECREF(key);
2337	<	return descriptor;
2338	<	}
2339	<
2340	<	/*
2341	<	For backward compatibility only
2342	<	*/
2343	<	#define SWIG_POINTER_EXCEPTION  0
2344	<	#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2345	<	#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346	<
2347	<	SWIGRUNTIME int
2348	<	SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349	<	{
2350	<	if (PyErr_Occurred()) {
2351	<	PyObject *type = 0;
2352	<	PyObject *value = 0;
2353	<	PyObject *traceback = 0;
2354	<	PyErr_Fetch(&type, &value, &traceback);
2355	<	if (value) {
2356	<	PyObject *old_str = PyObject_Str(value);
2357	<	Py_XINCREF(type);
2358	<	PyErr_Clear();
2359	<	if (infront) {
2360	<	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361	<	} else {
2362	<	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
579	>	if (!robj || (robj == Py_None)) return robj;
580	>	if (type->clientdata) {
581	>	PyObject *inst;
582	>	PyObject *args = Py_BuildValue((char*)"(O)", robj);
583	>	Py_DECREF(robj);
584	>	inst = PyObject_CallObject((PyObject *) type->clientdata, args);
585	>	Py_DECREF(args);
586	>	if (inst) {
587	>	if (own) {
588	>	PyObject *n = PyInt_FromLong(1);
589	>	PyObject_SetAttrString(inst,(char*)"thisown",n);
590	>	Py_DECREF(n);
591		}
592	<	Py_DECREF(old_str);
592	>	robj = inst;
593		}
2366	–	return 1;
2367	–	} else {
2368	–	return 0;
594		}
595	<	}
2371	<
2372	<	SWIGRUNTIME int
2373	<	SWIG_Python_ArgFail(int argnum)
2374	<	{
2375	<	if (PyErr_Occurred()) {
2376	<	/* add information about failing argument */
2377	<	char mesg[256];
2378	<	PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379	<	return SWIG_Python_AddErrMesg(mesg, 1);
2380	<	} else {
2381	<	return 0;
2382	<	}
2383	<	}
2384	<
2385	<	SWIGRUNTIMEINLINE const char *
2386	<	PySwigObject_GetDesc(PyObject *self)
2387	<	{
2388	<	PySwigObject *v = (PySwigObject *)self;
2389	<	swig_type_info *ty = v ? v->ty : 0;
2390	<	return ty ? ty->str : (char*)"";
595	>	return robj;
596		}
597
598	<	SWIGRUNTIME void
599	<	SWIG_Python_TypeError(const char *type, PyObject *obj)
600	<	{
601	<	if (type) {
602	<	#if defined(SWIG_COBJECT_TYPES)
603	<	if (obj && PySwigObject_Check(obj)) {
604	<	const char *otype = (const char *) PySwigObject_GetDesc(obj);
605	<	if (otype) {
606	<	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402	<	type, otype);
2403	<	return;
2404	<	}
2405	<	} else
2406	<	#endif
2407	<	{
2408	<	const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409	<	if (otype) {
2410	<	PyObject *str = PyObject_Str(obj);
2411	<	const char *cstr = str ? PyString_AsString(str) : 0;
2412	<	if (cstr) {
2413	<	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414	<	type, otype, cstr);
2415	<	} else {
2416	<	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417	<	type, otype);
2418	<	}
2419	<	Py_XDECREF(str);
2420	<	return;
2421	<	}
2422	<	}
2423	<	PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424	<	} else {
2425	<	PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426	<	}
598	>	SWIGRUNTIME(PyObject *)
599	>	SWIG_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
600	>	char result[1024];
601	>	char *r = result;
602	>	if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
603	>	*(r++) = '_';
604	>	r = SWIG_PackData(r,ptr,sz);
605	>	strcpy(r,type->name);
606	>	return PyString_FromString(result);
607		}
608
609	<
610	<	/* Convert a pointer value, signal an exception on a type mismatch */
611	<	SWIGRUNTIME void *
612	<	SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
613	<	void *result;
614	<	if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
615	<	PyErr_Clear();
616	<	if (flags & SWIG_POINTER_EXCEPTION) {
617	<	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
618	<	SWIG_Python_ArgFail(argnum);
609	>	/* Install Constants */
610	>	SWIGRUNTIME(void)
611	>	SWIG_InstallConstants(PyObject *d, swig_const_info constants[]) {
612	>	int i;
613	>	PyObject *obj;
614	>	for (i = 0; constants[i].type; i++) {
615	>	switch(constants[i].type) {
616	>	case SWIG_PY_INT:
617	>	obj = PyInt_FromLong(constants[i].lvalue);
618	>	break;
619	>	case SWIG_PY_FLOAT:
620	>	obj = PyFloat_FromDouble(constants[i].dvalue);
621	>	break;
622	>	case SWIG_PY_STRING:
623	>	obj = PyString_FromString((char *) constants[i].pvalue);
624	>	break;
625	>	case SWIG_PY_POINTER:
626	>	obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
627	>	break;
628	>	case SWIG_PY_BINARY:
629	>	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
630	>	break;
631	>	default:
632	>	obj = 0;
633	>	break;
634	>	}
635	>	if (obj) {
636	>	PyDict_SetItemString(d,constants[i].name,obj);
637	>	Py_DECREF(obj);
638		}
639		}
2441	–	return result;
640		}
641
642	+	#endif
643
644		#ifdef __cplusplus
2446	–	#if 0
2447	–	{ /* cc-mode */
2448	–	#endif
645		}
646		#endif
647
648
649
2454	–	#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455	–
2456	–	#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
650
651
652
2460	–	#define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
653
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define SWIGTYPE_p_BossAdministratorSession swig_types[0]
658	<	#define SWIGTYPE_p_BossAttributeContainer swig_types[1]
659	<	#define SWIGTYPE_p_BossDatabase swig_types[2]
660	<	#define SWIGTYPE_p_BossJob swig_types[3]
661	<	#define SWIGTYPE_p_BossSession swig_types[4]
662	<	#define SWIGTYPE_p_BossTask swig_types[5]
663	<	#define SWIGTYPE_p_BossTaskException swig_types[6]
664	<	#define SWIGTYPE_p_XMLDoc swig_types[7]
665	<	#define SWIGTYPE_p_allocator_type swig_types[8]
666	<	#define SWIGTYPE_p_char swig_types[9]
667	<	#define SWIGTYPE_p_difference_type swig_types[10]
668	<	#define SWIGTYPE_p_job_iterator swig_types[11]
669	<	#define SWIGTYPE_p_key_type swig_types[12]
670	<	#define SWIGTYPE_p_mapped_type swig_types[13]
671	<	#define SWIGTYPE_p_p_PyObject swig_types[14]
672	<	#define SWIGTYPE_p_size_type swig_types[15]
673	<	#define SWIGTYPE_p_std__exception swig_types[16]
674	<	#define SWIGTYPE_p_std__invalid_argument swig_types[17]
675	<	#define SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_t_t_t swig_types[18]
676	<	#define SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t swig_types[19]
2485	<	#define SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t__allocator_type swig_types[20]
2486	<	#define SWIGTYPE_p_std__ostream swig_types[21]
2487	<	#define SWIGTYPE_p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator swig_types[22]
2488	<	#define SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t swig_types[23]
2489	<	#define SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t swig_types[24]
2490	<	#define SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t__const_iterator swig_types[25]
2491	<	#define SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t swig_types[26]
2492	<	#define SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t__allocator_type swig_types[27]
2493	<	#define SWIGTYPE_p_swig__PySwigIterator swig_types[28]
2494	<	#define SWIGTYPE_p_value_type swig_types[29]
2495	<	static swig_type_info *swig_types[31];
2496	<	static swig_module_info swig_module = {swig_types, 30, 0, 0, 0, 0};
2497	<	#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2498	<	#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
657	>	#define  SWIGTYPE_p_XMLDoc swig_types[0]
658	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
659	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
660	>	#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[3]
661	>	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662	>	#define  SWIGTYPE_p_std__ostream swig_types[5]
663	>	#define  SWIGTYPE_p_BossTask swig_types[6]
664	>	#define  SWIGTYPE_p_BossTaskException swig_types[7]
665	>	#define  SWIGTYPE_p_printOption swig_types[8]
666	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[9]
667	>	#define  SWIGTYPE_p_BossJob swig_types[10]
668	>	#define  SWIGTYPE_p_BossDatabase swig_types[11]
669	>	#define  SWIGTYPE_p_BossSession swig_types[12]
670	>	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671	>	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672	>	#define  SWIGTYPE_p_BossAdministratorSession swig_types[15]
673	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
674	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[17]
675	>	#define  SWIGTYPE_p_jobStates swig_types[18]
676	>	static swig_type_info *swig_types[20];
677
678		/* -------- TYPES TABLE (END) -------- */
679
2502	–	#if (PY_VERSION_HEX <= 0x02000000)
2503	–	# if !defined(SWIG_PYTHON_CLASSIC)
2504	–	#  error "This python version requires to use swig with the '-classic' option"
2505	–	# endif
2506	–	#endif
680
681		/*-----------------------------------------------
682		@(target):= _BossSession.so
#	Line 2512 | Line 685 | static swig_module_info swig_module = {s
685
686		#define SWIG_name    "_BossSession"
687
688	<	#define SWIGVERSION 0x010329
689	<
690	<
691	<	#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
692	<	#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
693	<
694	<
695	<	#include <stdexcept>
696	<
697	<
698	<	namespace swig {
2526	<	class PyObject_ptr {
2527	<	protected:
2528	<	PyObject *_obj;
2529	<
2530	<	public:
2531	<	PyObject_ptr() :_obj(0)
2532	<	{
2533	<	}
2534	<
2535	<	PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2536	<	{
2537	<	Py_XINCREF(_obj);
2538	<	}
2539	<
2540	<	PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2541	<	{
2542	<	if (initial_ref) Py_XINCREF(_obj);
2543	<	}
2544	<
2545	<	PyObject_ptr & operator=(const PyObject_ptr& item)
2546	<	{
2547	<	Py_XINCREF(item._obj);
2548	<	Py_XDECREF(_obj);
2549	<	_obj = item._obj;
2550	<	return *this;
2551	<	}
2552	<
2553	<	~PyObject_ptr()
2554	<	{
2555	<	Py_XDECREF(_obj);
2556	<	}
2557	<
2558	<	operator PyObject *() const
2559	<	{
2560	<	return _obj;
2561	<	}
2562	<
2563	<	PyObject *operator->() const
2564	<	{
2565	<	return _obj;
2566	<	}
2567	<	};
2568	<	}
688	>	#define  SWIG_MemoryError    1
689	>	#define  SWIG_IOError        2
690	>	#define  SWIG_RuntimeError   3
691	>	#define  SWIG_IndexError     4
692	>	#define  SWIG_TypeError      5
693	>	#define  SWIG_DivisionByZero 6
694	>	#define  SWIG_OverflowError  7
695	>	#define  SWIG_SyntaxError    8
696	>	#define  SWIG_ValueError     9
697	>	#define  SWIG_SystemError   10
698	>	#define  SWIG_UnknownError  99
699
700
701	<	namespace swig {
702	<	struct PyObject_var : PyObject_ptr {
703	<	PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
704	<
705	<	PyObject_var & operator = (PyObject* obj)
706	<	{
707	<	Py_XDECREF(_obj);
708	<	_obj = obj;
709	<	return *this;
710	<	}
711	<	};
701	>	static void _SWIG_exception(int code, const char *msg) {
702	>	switch(code) {
703	>	case SWIG_MemoryError:
704	>	PyErr_SetString(PyExc_MemoryError,msg);
705	>	break;
706	>	case SWIG_IOError:
707	>	PyErr_SetString(PyExc_IOError,msg);
708	>	break;
709	>	case SWIG_RuntimeError:
710	>	PyErr_SetString(PyExc_RuntimeError,msg);
711	>	break;
712	>	case SWIG_IndexError:
713	>	PyErr_SetString(PyExc_IndexError,msg);
714	>	break;
715	>	case SWIG_TypeError:
716	>	PyErr_SetString(PyExc_TypeError,msg);
717	>	break;
718	>	case SWIG_DivisionByZero:
719	>	PyErr_SetString(PyExc_ZeroDivisionError,msg);
720	>	break;
721	>	case SWIG_OverflowError:
722	>	PyErr_SetString(PyExc_OverflowError,msg);
723	>	break;
724	>	case SWIG_SyntaxError:
725	>	PyErr_SetString(PyExc_SyntaxError,msg);
726	>	break;
727	>	case SWIG_ValueError:
728	>	PyErr_SetString(PyExc_ValueError,msg);
729	>	break;
730	>	case SWIG_SystemError:
731	>	PyErr_SetString(PyExc_SystemError,msg);
732	>	break;
733	>	default:
734	>	PyErr_SetString(PyExc_RuntimeError,msg);
735	>	break;
736	>	}
737		}
738
739	<
2585	<	#include <stdexcept>
2586	<
2587	<
2588	<
2589	<	#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
2590	<	#  define SWIG_STD_NOASSIGN_STL
2591	<	#  define SWIG_STD_NOINSERT_TEMPLATE_STL
2592	<	#  define SWIG_STD_NOITERATOR_TRAITS_STL
2593	<	#endif
2594	<
2595	<	#if defined(__GNUC__)
2596	<	#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
2597	<	#     define SWIG_STD_NOMODERN_STL
2598	<	#  endif
2599	<	#endif
2600	<
2601	<
739	>	#define SWIG_exception(a,b) { _SWIG_exception(a,b); SWIG_fail; }
740
741
742		#include <string>
2605	–	#include <stdexcept>
743
744
745		#include <string>
746
747	<
748	<	#include <iostream>
2612	<
2613	<
2614	<	namespace swig {
2615	<	struct stop_iteration {
2616	<	};
2617	<
2618	<	struct PySwigIterator {
2619	<	private:
2620	<	PyObject_ptr _seq;
2621	<
2622	<	protected:
2623	<	PySwigIterator(PyObject *seq) : _seq(seq)
2624	<	{
2625	<	}
2626	<
2627	<	public:
2628	<	virtual ~PySwigIterator() {}
2629	<
2630	<	// Access iterator method, required by Python
2631	<	virtual PyObject *value() const = 0;
2632	<
2633	<	// Forward iterator method, required by Python
2634	<	virtual PySwigIterator *incr(size_t n = 1) = 0;
2635	<
2636	<	// Backward iterator method, very common in C++, but not required in Python
2637	<	virtual PySwigIterator *decr(size_t n = 1)
2638	<	{
2639	<	throw stop_iteration();
2640	<	}
2641	<
2642	<	// Random access iterator methods, but not required in Python
2643	<	virtual ptrdiff_t distance(const PySwigIterator &x) const
2644	<	{
2645	<	throw std::invalid_argument("operation not supported");
2646	<	}
2647	<
2648	<	virtual bool equal (const PySwigIterator &x) const
2649	<	{
2650	<	throw std::invalid_argument("operation not supported");
2651	<	}
2652	<
2653	<	// C++ common/needed methods
2654	<	virtual PySwigIterator *copy() const = 0;
2655	<
2656	<	PyObject *next()
2657	<	{
2658	<	PyObject *obj = value();
2659	<	incr();
2660	<	return obj;
2661	<	}
2662	<
2663	<	PyObject *previous()
2664	<	{
2665	<	decr();
2666	<	return value();
2667	<	}
2668	<
2669	<	PySwigIterator *advance(ptrdiff_t n)
2670	<	{
2671	<	return  (n > 0) ?  incr(n) : decr(-n);
2672	<	}
2673	<
2674	<	bool operator == (const PySwigIterator& x)  const
2675	<	{
2676	<	return equal(x);
2677	<	}
2678	<
2679	<	bool operator != (const PySwigIterator& x) const
2680	<	{
2681	<	return ! operator==(x);
2682	<	}
2683	<
2684	<	PySwigIterator& operator += (ptrdiff_t n)
2685	<	{
2686	<	return *advance(n);
2687	<	}
2688	<
2689	<	PySwigIterator& operator -= (ptrdiff_t n)
2690	<	{
2691	<	return *advance(-n);
2692	<	}
2693	<
2694	<	PySwigIterator* operator + (ptrdiff_t n) const
2695	<	{
2696	<	return copy()->advance(n);
2697	<	}
2698	<
2699	<	PySwigIterator* operator - (ptrdiff_t n) const
2700	<	{
2701	<	return copy()->advance(-n);
2702	<	}
2703	<
2704	<	ptrdiff_t operator - (const PySwigIterator& x) const
2705	<	{
2706	<	return x.distance(*this);
2707	<	}
2708	<
2709	<	static swig_type_info* descriptor() {
2710	<	static int init = 0;
2711	<	static swig_type_info* desc = 0;
2712	<	if (!init) {
2713	<	desc = SWIG_TypeQuery("swig::PySwigIterator *");
2714	<	init = 1;
2715	<	}
2716	<	return desc;
2717	<	}
2718	<	};
2719	<	}
2720	<
2721	<
2722	<	SWIGINTERN int
2723	<	SWIG_AsVal_double (PyObject *obj, double *val)
2724	<	{
2725	<	int res = SWIG_TypeError;
2726	<	if (PyFloat_Check(obj)) {
2727	<	if (val) *val = PyFloat_AsDouble(obj);
2728	<	return SWIG_OK;
2729	<	} else if (PyInt_Check(obj)) {
2730	<	if (val) *val = PyInt_AsLong(obj);
2731	<	return SWIG_OK;
2732	<	} else if (PyLong_Check(obj)) {
2733	<	double v = PyLong_AsDouble(obj);
2734	<	if (!PyErr_Occurred()) {
2735	<	if (val) *val = v;
2736	<	return SWIG_OK;
2737	<	} else {
2738	<	PyErr_Clear();
2739	<	}
2740	<	}
2741	<	#ifdef SWIG_PYTHON_CAST_MODE
2742	<	{
2743	<	int dispatch = 0;
2744	<	double d = PyFloat_AsDouble(obj);
2745	<	if (!PyErr_Occurred()) {
2746	<	if (val) *val = d;
2747	<	return SWIG_AddCast(SWIG_OK);
2748	<	} else {
2749	<	PyErr_Clear();
2750	<	}
2751	<	if (!dispatch) {
2752	<	long v = PyLong_AsLong(obj);
2753	<	if (!PyErr_Occurred()) {
2754	<	if (val) *val = v;
2755	<	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2756	<	} else {
2757	<	PyErr_Clear();
2758	<	}
2759	<	}
2760	<	}
2761	<	#endif
2762	<	return res;
2763	<	}
2764	<
2765	<
2766	<	#include <float.h>
2767	<
2768	<
2769	<	#include <math.h>
2770	<
2771	<
2772	<	SWIGINTERNINLINE int
2773	<	SWIG_CanCastAsInteger(double *d, double min, double max) {
2774	<	double x = *d;
2775	<	if ((min <= x && x <= max)) {
2776	<	double fx = floor(x);
2777	<	double cx = ceil(x);
2778	<	double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2779	<	if ((errno == EDOM) || (errno == ERANGE)) {
2780	<	errno = 0;
2781	<	} else {
2782	<	double summ, reps, diff;
2783	<	if (rd < x) {
2784	<	diff = x - rd;
2785	<	} else if (rd > x) {
2786	<	diff = rd - x;
2787	<	} else {
2788	<	return 1;
2789	<	}
2790	<	summ = rd + x;
2791	<	reps = diff/summ;
2792	<	if (reps < 8*DBL_EPSILON) {
2793	<	*d = rd;
2794	<	return 1;
2795	<	}
2796	<	}
2797	<	}
2798	<	return 0;
2799	<	}
2800	<
2801	<
2802	<	SWIGINTERN int
2803	<	SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2804	<	{
2805	<	if (PyInt_Check(obj)) {
2806	<	long v = PyInt_AsLong(obj);
2807	<	if (v >= 0) {
2808	<	if (val) *val = v;
2809	<	return SWIG_OK;
2810	<	} else {
2811	<	return SWIG_OverflowError;
2812	<	}
2813	<	} else if (PyLong_Check(obj)) {
2814	<	unsigned long v = PyLong_AsUnsignedLong(obj);
2815	<	if (!PyErr_Occurred()) {
2816	<	if (val) *val = v;
2817	<	return SWIG_OK;
2818	<	} else {
2819	<	PyErr_Clear();
2820	<	}
2821	<	}
2822	<	#ifdef SWIG_PYTHON_CAST_MODE
2823	<	{
2824	<	int dispatch = 0;
2825	<	unsigned long v = PyLong_AsUnsignedLong(obj);
2826	<	if (!PyErr_Occurred()) {
2827	<	if (val) *val = v;
2828	<	return SWIG_AddCast(SWIG_OK);
2829	<	} else {
2830	<	PyErr_Clear();
2831	<	}
2832	<	if (!dispatch) {
2833	<	double d;
2834	<	int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2835	<	if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2836	<	if (val) *val = (unsigned long)(d);
2837	<	return res;
2838	<	}
2839	<	}
2840	<	}
2841	<	#endif
2842	<	return SWIG_TypeError;
2843	<	}
2844	<
2845	<
2846	<	SWIGINTERNINLINE int
2847	<	SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2848	<	{
2849	<	unsigned long v;
2850	<	int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2851	<	if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2852	<	return res;
747	>	PyObject* SwigInt_FromBool(bool b) {
748	>	return PyInt_FromLong(b ? 1L : 0L);
749		}
750	<
751	<
2856	<	#define SWIG_From_long   PyInt_FromLong
2857	<
2858	<
2859	<	SWIGINTERNINLINE PyObject *
2860	<	SWIG_From_ptrdiff_t  (ptrdiff_t value)
2861	<	{
2862	<	return SWIG_From_long  (static_cast< long >(value));
750	>	double SwigNumber_Check(PyObject* o) {
751	>	return PyFloat_Check(o) || PyInt_Check(o) || PyLong_Check(o);
752		}
753	<
754	<
755	<	SWIGINTERNINLINE PyObject*
756	<	SWIG_From_bool  (bool value)
2868	<	{
2869	<	return PyBool_FromLong(value ? 1 : 0);
753	>	double SwigNumber_AsDouble(PyObject* o) {
754	>	return PyFloat_Check(o) ? PyFloat_AsDouble(o)
755	>	: (PyInt_Check(o) ?   double(PyInt_AsLong(o))
756	>	: double(PyLong_AsLong(o)));
757		}
758	<
759	<
2873	<	SWIGINTERN int
2874	<	SWIG_AsVal_long (PyObject *obj, long* val)
2875	<	{
2876	<	if (PyInt_Check(obj)) {
2877	<	if (val) *val = PyInt_AsLong(obj);
2878	<	return SWIG_OK;
2879	<	} else if (PyLong_Check(obj)) {
2880	<	long v = PyLong_AsLong(obj);
2881	<	if (!PyErr_Occurred()) {
2882	<	if (val) *val = v;
2883	<	return SWIG_OK;
2884	<	} else {
2885	<	PyErr_Clear();
2886	<	}
2887	<	}
2888	<	#ifdef SWIG_PYTHON_CAST_MODE
2889	<	{
2890	<	int dispatch = 0;
2891	<	long v = PyInt_AsLong(obj);
2892	<	if (!PyErr_Occurred()) {
2893	<	if (val) *val = v;
2894	<	return SWIG_AddCast(SWIG_OK);
2895	<	} else {
2896	<	PyErr_Clear();
2897	<	}
2898	<	if (!dispatch) {
2899	<	double d;
2900	<	int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2901	<	if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2902	<	if (val) *val = (long)(d);
2903	<	return res;
2904	<	}
2905	<	}
2906	<	}
2907	<	#endif
2908	<	return SWIG_TypeError;
758	>	PyObject* SwigString_FromString(const std::string& s) {
759	>	return PyString_FromStringAndSize(s.data(),s.size());
760		}
761	<
762	<
2912	<	SWIGINTERNINLINE int
2913	<	SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
2914	<	{
2915	<	long v;
2916	<	int res = SWIG_AsVal_long (obj, val ? &v : 0);
2917	<	if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
2918	<	return res;
761	>	std::string SwigString_AsString(PyObject* o) {
762	>	return std::string(PyString_AsString(o));
763		}
764
765
2922	–	#include <stdexcept>
2923	–
2924	–
2925	–	#include <algorithm>
2926	–
2927	–
766		#include <vector>
767	<
768	<
2931	<	#include <utility>
767	>	#include <algorithm>
768	>	#include <stdexcept>
769
770
771		#include <map>
772		#include <algorithm>
773		#include <stdexcept>
774
775	+	bool std_maplstd_stringcstd_string_g___nonzero_____(std::map<std::string,std::string > *self){
776	+	return !(self->empty());
777	+	}
778	+	std::string std_maplstd_stringcstd_string_g___getitem_____(std::map<std::string,std::string > *self,std::string key){
779	+	std::map<std::string,std::string >::iterator i = self->find(key);
780	+	if (i != self->end())
781	+	return i->second;
782	+	else
783	+	throw std::out_of_range("key not found");
784	+	}
785	+	void std_maplstd_stringcstd_string_g___setitem_____(std::map<std::string,std::string > *self,std::string key,std::string x){
786	+	(*self)[key] = x;
787	+	}
788	+	void std_maplstd_stringcstd_string_g___delitem_____(std::map<std::string,std::string > *self,std::string key){
789	+	std::map<std::string,std::string >::iterator i = self->find(key);
790	+	if (i != self->end())
791	+	self->erase(i);
792	+	else
793	+	throw std::out_of_range("key not found");
794	+	}
795	+	bool std_maplstd_stringcstd_string_g_has_key___(std::map<std::string,std::string > *self,std::string key){
796	+	std::map<std::string,std::string >::iterator i = self->find(key);
797	+	return i != self->end();
798	+	}
799	+	PyObject *std_maplstd_stringcstd_string_g_keys___(std::map<std::string,std::string > *self){
800	+	PyObject* keyList = PyList_New(self->size());
801	+	std::map<std::string,std::string >::iterator i;
802	+	unsigned int j;
803	+	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
804	+	PyList_SetItem(keyList,j,
805	+	SwigString_FromString(i->first));
806	+	}
807	+	return keyList;
808	+	}
809	+	PyObject *std_maplstd_stringcstd_string_g_values___(std::map<std::string,std::string > *self){
810	+	PyObject* valueList = PyList_New(self->size());
811	+	std::map<std::string,std::string >::iterator i;
812	+	unsigned int j;
813	+	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
814	+	PyList_SetItem(valueList,j,
815	+	SwigString_FromString(i->second));
816	+	}
817	+	return valueList;
818	+	}
819	+	PyObject *std_maplstd_stringcstd_string_g_items___(std::map<std::string,std::string > *self){
820	+	PyObject* itemList = PyList_New(self->size());
821	+	std::map<std::string,std::string >::iterator i;
822	+	unsigned int j;
823	+	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
824	+	PyObject* item = PyTuple_New(2);
825	+	PyTuple_SetItem(item,0,
826	+	SwigString_FromString(i->first));
827	+	PyTuple_SetItem(item,1,
828	+	SwigString_FromString(i->second));
829	+	PyList_SetItem(itemList,j,item);
830	+	}
831	+	return itemList;
832	+	}
833	+	bool std_maplstd_stringcstd_string_g___contains_____(std::map<std::string,std::string > *self,std::string key){
834	+	std::map<std::string,std::string >::iterator i = self->find(key);
835	+	return i != self->end();
836	+	}
837	+	PyObject *std_maplstd_stringcstd_string_g___iter_____(std::map<std::string,std::string > *self){
838	+	#if PY_VERSION_HEX >= 0x02020000
839	+	PyObject* keyList = PyList_New(self->size());
840	+	std::map<std::string,std::string >::iterator i;
841	+	unsigned int j;
842	+	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
843	+	PyList_SetItem(keyList,j,
844	+	SwigString_FromString(i->first));
845	+	}
846	+	PyObject* iter = PyObject_GetIter(keyList);
847	+	Py_DECREF(keyList);
848	+	return iter;
849	+	#else
850	+	throw std::runtime_error("Python 2.2 or later is needed"
851	+	" for iterator support");
852	+	#endif
853	+	}
854	+	std::string std_vectorlstd_string_g_pop___(std::vector<std::string > *self){
855	+	if (self->size() == 0)
856	+	throw std::out_of_range("pop from empty vector");
857	+	std::string x = self->back();
858	+	self->pop_back();
859	+	return x;
860	+	}
861	+	std::string std_vectorlstd_string_g___getitem_____(std::vector<std::string > *self,int i){
862	+	int size = int(self->size());
863	+	if (i<0) i += size;
864	+	if (i>=0 && i<size)
865	+	return (*self)[i];
866	+	else
867	+	throw std::out_of_range("vector index out of range");
868	+	}
869	+	std::vector<std::string > std_vectorlstd_string_g___getslice_____(std::vector<std::string > *self,int i,int j){
870	+	int size = int(self->size());
871	+	if (i<0) i = size+i;
872	+	if (j<0) j = size+j;
873	+	if (i<0) i = 0;
874	+	if (j>size) j = size;
875	+	std::vector<std::string > tmp(j-i);
876	+	std::copy(self->begin()+i,self->begin()+j,tmp.begin());
877	+	return tmp;
878	+	}
879	+	void std_vectorlstd_string_g___setitem_____(std::vector<std::string > *self,int i,std::string x){
880	+	int size = int(self->size());
881	+	if (i<0) i+= size;
882	+	if (i>=0 && i<size)
883	+	(*self)[i] = x;
884	+	else
885	+	throw std::out_of_range("vector index out of range");
886	+	}
887	+	void std_vectorlstd_string_g___setslice_____(std::vector<std::string > *self,int i,int j,std::vector<std::string > const &v){
888	+	int size = int(self->size());
889	+	if (i<0) i = size+i;
890	+	if (j<0) j = size+j;
891	+	if (i<0) i = 0;
892	+	if (j>size) j = size;
893	+	if (int(v.size()) == j-i) {
894	+	std::copy(v.begin(),v.end(),self->begin()+i);
895	+	} else {
896	+	self->erase(self->begin()+i,self->begin()+j);
897	+	if (i+1 <= int(self->size()))
898	+	self->insert(self->begin()+i,v.begin(),v.end());
899	+	else
900	+	self->insert(self->end(),v.begin(),v.end());
901	+	}
902	+	}
903	+	void std_vectorlstd_string_g___delitem_____(std::vector<std::string > *self,int i){
904	+	int size = int(self->size());
905	+	if (i<0) i+= size;
906	+	if (i>=0 && i<size)
907	+	self->erase(self->begin()+i);
908	+	else
909	+	throw std::out_of_range("vector index out of range");
910	+	}
911	+	void std_vectorlstd_string_g___delslice_____(std::vector<std::string > *self,int i,int j){
912	+	int size = int(self->size());
913	+	if (i<0) i = size+i;
914	+	if (j<0) j = size+j;
915	+	if (i<0) i = 0;
916	+	if (j>size) j = size;
917	+	self->erase(self->begin()+i,self->begin()+j);
918	+	}
919
920	<	namespace swig {
921	<	template <class Type>
2941	<	struct noconst_traits {
2942	<	typedef Type noconst_type;
2943	<	};
2944	<
2945	<	template <class Type>
2946	<	struct noconst_traits<const Type> {
2947	<	typedef Type noconst_type;
2948	<	};
2949	<
2950	<	/*
2951	<	type categories
2952	<	*/
2953	<	struct pointer_category { };
2954	<	struct value_category { };
2955	<
2956	<	/*
2957	<	General traits that provides type_name and type_info
2958	<	*/
2959	<	template <class Type> struct traits { };
2960	<
2961	<	template <class Type>
2962	<	inline const char* type_name() {
2963	<	return traits<typename noconst_traits<Type >::noconst_type >::type_name();
2964	<	}
2965	<
2966	<	template <class Type>
2967	<	struct traits_info {
2968	<	static swig_type_info *type_query(std::string name) {
2969	<	name += " *";
2970	<	return SWIG_TypeQuery(name.c_str());
2971	<	}
2972	<	static swig_type_info *type_info() {
2973	<	static swig_type_info *info = type_query(type_name<Type>());
2974	<	return info;
2975	<	}
2976	<	};
2977	<
2978	<	template <class Type>
2979	<	inline swig_type_info *type_info() {
2980	<	return traits_info<Type>::type_info();
2981	<	}
2982	<
2983	<	/*
2984	<	Partial specialization for pointers
2985	<	*/
2986	<	template <class Type> struct traits <Type *> {
2987	<	typedef pointer_category category;
2988	<	static std::string make_ptr_name(const char* name) {
2989	<	std::string ptrname = name;
2990	<	ptrname += " *";
2991	<	return ptrname;
2992	<	}
2993	<	static const char* type_name() {
2994	<	static std::string name = make_ptr_name(swig::type_name<Type>());
2995	<	return name.c_str();
2996	<	}
2997	<	};
2998	<
2999	<	template <class Type, class Category>
3000	<	struct traits_as { };
3001	<
3002	<	template <class Type, class Category>
3003	<	struct traits_check { };
3004	<
3005	<	}
3006	<
3007	<
3008	<	namespace swig {
3009	<	/*
3010	<	Traits that provides the from method
3011	<	*/
3012	<	template <class Type> struct traits_from_ptr {
3013	<	static PyObject *from(Type *val, int owner = 0) {
3014	<	return SWIG_NewPointerObj(val, type_info<Type>(), owner);
3015	<	}
3016	<	};
3017	<
3018	<	template <class Type> struct traits_from {
3019	<	static PyObject *from(const Type& val) {
3020	<	return traits_from_ptr<Type>::from(new Type(val), 1);
3021	<	}
3022	<	};
3023	<
3024	<	template <class Type> struct traits_from<Type *> {
3025	<	static PyObject *from(Type* val) {
3026	<	return traits_from_ptr<Type>::from(val, 0);
3027	<	}
3028	<	};
3029	<
3030	<	template <class Type>
3031	<	inline PyObject *from(const Type& val) {
3032	<	return traits_from<Type>::from(val);
3033	<	}
3034	<
3035	<	template <class Type>
3036	<	inline PyObject *from_ptr(Type* val, int owner) {
3037	<	return traits_from_ptr<Type>::from(val, owner);
3038	<	}
3039	<
3040	<	/*
3041	<	Traits that provides the asval/as/check method
3042	<	*/
3043	<	template <class Type>
3044	<	struct traits_asptr {
3045	<	static int asptr(PyObject *obj, Type **val) {
3046	<	Type *p;
3047	<	int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
3048	<	if (SWIG_IsOK(res)) {
3049	<	if (val) *val = p;
3050	<	}
3051	<	return res;
3052	<	}
3053	<	};
3054	<
3055	<	template <class Type>
3056	<	inline int asptr(PyObject *obj, Type **vptr) {
3057	<	return traits_asptr<Type>::asptr(obj, vptr);
3058	<	}
3059	<
3060	<	template <class Type>
3061	<	struct traits_asval {
3062	<	static int asval(PyObject *obj, Type *val) {
3063	<	if (val) {
3064	<	Type *p = 0;
3065	<	int res = traits_asptr<Type>::asptr(obj, &p);
3066	<	if (!SWIG_IsOK(res)) return res;
3067	<	if (p) {
3068	<	typedef typename noconst_traits<Type>::noconst_type noconst_type;
3069	<	*(const_cast<noconst_type*>(val)) = *p;
3070	<	if (SWIG_IsNewObj(res)){
3071	<	delete p;
3072	<	res = SWIG_DelNewMask(res);
3073	<	}
3074	<	return res;
3075	<	} else {
3076	<	return SWIG_ERROR;
3077	<	}
3078	<	} else {
3079	<	return traits_asptr<Type>::asptr(obj, (Type **)(0));
3080	<	}
3081	<	}
3082	<	};
3083	<
3084	<	template <class Type> struct traits_asval<Type*> {
3085	<	static int asval(PyObject *obj, Type **val) {
3086	<	if (val) {
3087	<	typedef typename noconst_traits<Type>::noconst_type noconst_type;
3088	<	noconst_type *p = 0;
3089	<	int res = traits_asptr<noconst_type>::asptr(obj,  &p);
3090	<	if (SWIG_IsOK(res)) {
3091	<	*(const_cast<noconst_type**>(val)) = p;
3092	<	}
3093	<	return res;
3094	<	} else {
3095	<	return traits_asptr<Type>::asptr(obj, (Type **)(0));
3096	<	}
3097	<	}
3098	<	};
3099	<
3100	<	template <class Type>
3101	<	inline int asval(PyObject *obj, Type *val) {
3102	<	return traits_asval<Type>::asval(obj, val);
3103	<	}
3104	<
3105	<	template <class Type>
3106	<	struct traits_as<Type, value_category> {
3107	<	static Type as(PyObject *obj, bool throw_error) {
3108	<	Type v;
3109	<	int res = asval(obj, &v);
3110	<	if (!obj || !SWIG_IsOK(res)) {
3111	<	if (!PyErr_Occurred()) {
3112	<	SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3113	<	}
3114	<	if (throw_error) throw std::invalid_argument("bad type");
3115	<	}
3116	<	return v;
3117	<	}
3118	<	};
3119	<
3120	<	template <class Type>
3121	<	struct traits_as<Type, pointer_category> {
3122	<	static Type as(PyObject *obj, bool throw_error) {
3123	<	Type *v = 0;
3124	<	int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3125	<	if (SWIG_IsOK(res) && v) {
3126	<	if (SWIG_IsNewObj(res)) {
3127	<	Type r(*v);
3128	<	delete v;
3129	<	return r;
3130	<	} else {
3131	<	return *v;
3132	<	}
3133	<	} else {
3134	<	// Uninitialized return value, no Type() constructor required.
3135	<	static Type *v_def = (Type*) malloc(sizeof(Type));
3136	<	if (!PyErr_Occurred()) {
3137	<	SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3138	<	}
3139	<	if (throw_error) throw std::invalid_argument("bad type");
3140	<	memset(v_def,0,sizeof(Type));
3141	<	return *v_def;
3142	<	}
3143	<	}
3144	<	};
3145	<
3146	<	template <class Type>
3147	<	struct traits_as<Type*, pointer_category> {
3148	<	static Type* as(PyObject *obj, bool throw_error) {
3149	<	Type *v = 0;
3150	<	int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3151	<	if (SWIG_IsOK(res)) {
3152	<	return v;
3153	<	} else {
3154	<	if (!PyErr_Occurred()) {
3155	<	SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3156	<	}
3157	<	if (throw_error) throw std::invalid_argument("bad type");
3158	<	return 0;
3159	<	}
3160	<	}
3161	<	};
3162	<
3163	<	template <class Type>
3164	<	inline Type as(PyObject *obj, bool te = false) {
3165	<	return traits_as<Type, typename traits<Type>::category>::as(obj, te);
3166	<	}
3167	<
3168	<	template <class Type>
3169	<	struct traits_check<Type, value_category> {
3170	<	static bool check(PyObject *obj) {
3171	<	int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
3172	<	return SWIG_IsOK(res) ? true : false;
3173	<	}
3174	<	};
3175	<
3176	<	template <class Type>
3177	<	struct traits_check<Type, pointer_category> {
3178	<	static bool check(PyObject *obj) {
3179	<	int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
3180	<	return SWIG_IsOK(res) ? true : false;
3181	<	}
3182	<	};
3183	<
3184	<	template <class Type>
3185	<	inline bool check(PyObject *obj) {
3186	<	return traits_check<Type, typename traits<Type>::category>::check(obj);
3187	<	}
3188	<	}
3189	<
3190	<
3191	<	#include <functional>
3192	<
3193	<	namespace std {
3194	<	template <>
3195	<	struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
3196	<	{
3197	<	bool
3198	<	operator()(PyObject * v, PyObject *w) const
3199	<	{
3200	<	bool res;
3201	<	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3202	<	res = PyObject_Compare(v, w) < 0;
3203	<	SWIG_PYTHON_THREAD_END_BLOCK;
3204	<	return res;
3205	<	}
3206	<	};
3207	<
3208	<	template <>
3209	<	struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
3210	<	{
3211	<	bool
3212	<	operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
3213	<	{
3214	<	return std::less<PyObject *>()(v, w);
3215	<	}
3216	<	};
3217	<
3218	<	template <>
3219	<	struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
3220	<	{
3221	<	bool
3222	<	operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
3223	<	{
3224	<	return std::less<PyObject *>()(v, w);
3225	<	}
3226	<	};
3227	<
3228	<	}
3229	<
3230	<	namespace swig {
3231	<	template <> struct traits<PyObject *> {
3232	<	typedef value_category category;
3233	<	static const char* type_name() { return "PyObject *"; }
3234	<	};
3235	<
3236	<	template <>  struct traits_asval<PyObject * > {
3237	<	typedef PyObject * value_type;
3238	<	static int asval(PyObject *obj, value_type *val) {
3239	<	if (val) *val = obj;
3240	<	return SWIG_OK;
3241	<	}
3242	<	};
3243	<
3244	<	template <>
3245	<	struct traits_check<PyObject *, value_category> {
3246	<	static bool check(PyObject *) {
3247	<	return true;
3248	<	}
3249	<	};
3250	<
3251	<	template <>  struct traits_from<PyObject *> {
3252	<	typedef PyObject * value_type;
3253	<	static PyObject *from(const value_type& val) {
3254	<	Py_XINCREF(val);
3255	<	return val;
3256	<	}
3257	<	};
3258	<
3259	<	}
3260	<
3261	<	namespace swig {
3262	<	inline size_t
3263	<	check_index(ptrdiff_t i, size_t size, bool insert = false) {
3264	<	if ( i < 0 ) {
3265	<	if ((size_t) (-i) <= size)
3266	<	return (size_t) (i + size);
3267	<	} else if ( (size_t) i < size ) {
3268	<	return (size_t) i;
3269	<	} else if (insert && ((size_t) i == size)) {
3270	<	return size;
3271	<	}
3272	<
3273	<	throw std::out_of_range("index out of range");
3274	<	}
3275	<
3276	<	inline size_t
3277	<	slice_index(ptrdiff_t i, size_t size) {
3278	<	if ( i < 0 ) {
3279	<	if ((size_t) (-i) <= size) {
3280	<	return (size_t) (i + size);
3281	<	} else {
3282	<	throw std::out_of_range("index out of range");
3283	<	}
3284	<	} else {
3285	<	return ( (size_t) i < size ) ? ((size_t) i) : size;
3286	<	}
3287	<	}
3288	<
3289	<	template <class Sequence, class Difference>
3290	<	inline typename Sequence::iterator
3291	<	getpos(Sequence* self, Difference i)  {
3292	<	typename Sequence::iterator pos = self->begin();
3293	<	std::advance(pos, check_index(i,self->size()));
3294	<	return pos;
3295	<	}
3296	<
3297	<	template <class Sequence, class Difference>
3298	<	inline typename Sequence::const_iterator
3299	<	cgetpos(const Sequence* self, Difference i)  {
3300	<	typename Sequence::const_iterator pos = self->begin();
3301	<	std::advance(pos, check_index(i,self->size()));
3302	<	return pos;
3303	<	}
3304	<
3305	<	template <class Sequence, class Difference>
3306	<	inline Sequence*
3307	<	getslice(const Sequence* self, Difference i, Difference j) {
3308	<	typename Sequence::size_type size = self->size();
3309	<	typename Sequence::size_type ii = swig::check_index(i, size);
3310	<	typename Sequence::size_type jj = swig::slice_index(j, size);
3311	<
3312	<	if (jj > ii) {
3313	<	typename Sequence::const_iterator vb = self->begin();
3314	<	typename Sequence::const_iterator ve = self->begin();
3315	<	std::advance(vb,ii);
3316	<	std::advance(ve,jj);
3317	<	return new Sequence(vb, ve);
3318	<	} else {
3319	<	return new Sequence();
3320	<	}
3321	<	}
3322	<
3323	<	template <class Sequence, class Difference, class InputSeq>
3324	<	inline void
3325	<	setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
3326	<	typename Sequence::size_type size = self->size();
3327	<	typename Sequence::size_type ii = swig::check_index(i, size, true);
3328	<	typename Sequence::size_type jj = swig::slice_index(j, size);
3329	<	if (jj < ii) jj = ii;
3330	<	size_t ssize = jj - ii;
3331	<	if (ssize <= v.size()) {
3332	<	typename Sequence::iterator sb = self->begin();
3333	<	typename InputSeq::const_iterator vmid = v.begin();
3334	<	std::advance(sb,ii);
3335	<	std::advance(vmid, jj - ii);
3336	<	self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
3337	<	} else {
3338	<	typename Sequence::iterator sb = self->begin();
3339	<	typename Sequence::iterator se = self->begin();
3340	<	std::advance(sb,ii);
3341	<	std::advance(se,jj);
3342	<	self->erase(sb,se);
3343	<	self->insert(sb, v.begin(), v.end());
3344	<	}
3345	<	}
3346	<
3347	<	template <class Sequence, class Difference>
3348	<	inline void
3349	<	delslice(Sequence* self, Difference i, Difference j) {
3350	<	typename Sequence::size_type size = self->size();
3351	<	typename Sequence::size_type ii = swig::check_index(i, size, true);
3352	<	typename Sequence::size_type jj = swig::slice_index(j, size);
3353	<	if (jj > ii) {
3354	<	typename Sequence::iterator sb = self->begin();
3355	<	typename Sequence::iterator se = self->begin();
3356	<	std::advance(sb,ii);
3357	<	std::advance(se,jj);
3358	<	self->erase(sb,se);
3359	<	}
3360	<	}
3361	<	}
3362	<
3363	<
3364	<	#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
3365	<	#include <iterator>
3366	<	#else
3367	<	namespace std  {
3368	<	template <class Iterator>
3369	<	struct iterator_traits {
3370	<	typedef ptrdiff_t difference_type;
3371	<	typedef typename Iterator::value_type value_type;
3372	<	};
3373	<
3374	<	#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
3375	<	template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
3376	<	struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
3377	<	typedef Distance difference_type;
3378	<	typedef T value_type;
3379	<	};
3380	<	#endif
3381	<
3382	<	template <class T>
3383	<	struct iterator_traits<T*> {
3384	<	typedef T value_type;
3385	<	typedef ptrdiff_t difference_type;
3386	<	};
3387	<
3388	<	template<typename _InputIterator>
3389	<	inline typename iterator_traits<_InputIterator>::difference_type
3390	<	distance(_InputIterator __first, _InputIterator __last)
3391	<	{
3392	<	typename iterator_traits<_InputIterator>::difference_type __n = 0;
3393	<	while (__first != __last) {
3394	<	++__first; ++__n;
3395	<	}
3396	<	return __n;
3397	<	}
3398	<
3399	<	}
3400	<	#endif
3401	<
3402	<
3403	<	namespace swig {
3404	<	template<typename OutIterator>
3405	<	class PySwigIterator_T :  public PySwigIterator
3406	<	{
3407	<	public:
3408	<	typedef OutIterator out_iterator;
3409	<	typedef typename std::iterator_traits<out_iterator>::value_type value_type;
3410	<	typedef PySwigIterator_T<out_iterator> self_type;
3411	<
3412	<	PySwigIterator_T(out_iterator curr, PyObject *seq)
3413	<	: PySwigIterator(seq), current(curr)
3414	<	{
3415	<	}
3416	<
3417	<	const out_iterator& get_current() const
3418	<	{
3419	<	return current;
3420	<	}
3421	<
3422	<
3423	<	bool equal (const PySwigIterator &iter) const
3424	<	{
3425	<	const self_type *iters = dynamic_cast<const self_type *>(&iter);
3426	<	if (iters) {
3427	<	return (current == iters->get_current());
3428	<	} else {
3429	<	throw std::invalid_argument("bad iterator type");
3430	<	}
3431	<	}
3432	<
3433	<	ptrdiff_t distance(const PySwigIterator &iter) const
3434	<	{
3435	<	const self_type *iters = dynamic_cast<const self_type *>(&iter);
3436	<	if (iters) {
3437	<	return std::distance(current, iters->get_current());
3438	<	} else {
3439	<	throw std::invalid_argument("bad iterator type");
3440	<	}
3441	<	}
3442	<
3443	<	protected:
3444	<	out_iterator current;
3445	<	};
3446	<
3447	<	template <class ValueType>
3448	<	struct from_oper
3449	<	{
3450	<	typedef const ValueType& argument_type;
3451	<	typedef PyObject *result_type;
3452	<	result_type operator()(argument_type v) const
3453	<	{
3454	<	return swig::from(v);
3455	<	}
3456	<	};
3457	<
3458	<	template<typename OutIterator,
3459	<	typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3460	<	typename FromOper = from_oper<ValueType> >
3461	<	class PySwigIteratorOpen_T :  public PySwigIterator_T<OutIterator>
3462	<	{
3463	<	public:
3464	<	FromOper from;
3465	<	typedef OutIterator out_iterator;
3466	<	typedef ValueType value_type;
3467	<	typedef PySwigIterator_T<out_iterator>  base;
3468	<	typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
3469	<
3470	<	PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
3471	<	: PySwigIterator_T<OutIterator>(curr, seq)
3472	<	{
3473	<	}
3474	<
3475	<	PyObject *value() const {
3476	<	return from(static_cast<const value_type&>(*(base::current)));
3477	<	}
3478	<
3479	<	PySwigIterator *copy() const
3480	<	{
3481	<	return new self_type(*this);
3482	<	}
3483	<
3484	<	PySwigIterator *incr(size_t n = 1)
3485	<	{
3486	<	while (n--) {
3487	<	++base::current;
3488	<	}
3489	<	return this;
3490	<	}
3491	<
3492	<	PySwigIterator *decr(size_t n = 1)
3493	<	{
3494	<	while (n--) {
3495	<	--base::current;
3496	<	}
3497	<	return this;
3498	<	}
3499	<	};
3500	<
3501	<	template<typename OutIterator,
3502	<	typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3503	<	typename FromOper = from_oper<ValueType> >
3504	<	class PySwigIteratorClosed_T :  public PySwigIterator_T<OutIterator>
3505	<	{
3506	<	public:
3507	<	FromOper from;
3508	<	typedef OutIterator out_iterator;
3509	<	typedef ValueType value_type;
3510	<	typedef PySwigIterator_T<out_iterator>  base;
3511	<	typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
3512	<
3513	<	PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
3514	<	: PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
3515	<	{
3516	<	}
3517	<
3518	<	PyObject *value() const {
3519	<	if (base::current == end) {
3520	<	throw stop_iteration();
3521	<	} else {
3522	<	return from(static_cast<const value_type&>(*(base::current)));
3523	<	}
3524	<	}
3525	<
3526	<	PySwigIterator *copy() const
3527	<	{
3528	<	return new self_type(*this);
3529	<	}
3530	<
3531	<	PySwigIterator *incr(size_t n = 1)
3532	<	{
3533	<	while (n--) {
3534	<	if (base::current == end) {
3535	<	throw stop_iteration();
3536	<	} else {
3537	<	++base::current;
3538	<	}
3539	<	}
3540	<	return this;
3541	<	}
3542	<
3543	<	PySwigIterator *decr(size_t n = 1)
3544	<	{
3545	<	while (n--) {
3546	<	if (base::current == begin) {
3547	<	throw stop_iteration();
3548	<	} else {
3549	<	--base::current;
3550	<	}
3551	<	}
3552	<	return this;
3553	<	}
3554	<
3555	<	private:
3556	<	out_iterator begin;
3557	<	out_iterator end;
3558	<	};
3559	<
3560	<	template<typename OutIter>
3561	<	inline PySwigIterator*
3562	<	make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
3563	<	{
3564	<	return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
3565	<	}
3566	<
3567	<	template<typename OutIter>
3568	<	inline PySwigIterator*
3569	<	make_output_iterator(const OutIter& current, PyObject *seq = 0)
3570	<	{
3571	<	return new PySwigIteratorOpen_T<OutIter>(current, seq);
3572	<	}
3573	<	}
3574	<
3575	<
3576	<	namespace swig
3577	<	{
3578	<	template <class T>
3579	<	struct PySequence_Ref
3580	<	{
3581	<	PySequence_Ref(PyObject* seq, int index)
3582	<	: _seq(seq), _index(index)
3583	<	{
3584	<	}
3585	<
3586	<	operator T () const
3587	<	{
3588	<	swig::PyObject_var item = PySequence_GetItem(_seq, _index);
3589	<	try {
3590	<	return swig::as<T>(item, true);
3591	<	} catch (std::exception& e) {
3592	<	char msg[1024];
3593	<	sprintf(msg, "in sequence element %d ", _index);
3594	<	if (!PyErr_Occurred()) {
3595	<	SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
3596	<	}
3597	<	SWIG_Python_AddErrorMsg(msg);
3598	<	SWIG_Python_AddErrorMsg(e.what());
3599	<	throw;
3600	<	}
3601	<	}
3602	<
3603	<	PySequence_Ref& operator=(const T& v)
3604	<	{
3605	<	PySequence_SetItem(_seq, _index, swig::from<T>(v));
3606	<	return *this;
3607	<	}
3608	<
3609	<	private:
3610	<	PyObject* _seq;
3611	<	int _index;
3612	<	};
3613	<
3614	<	template <class T>
3615	<	struct PySequence_ArrowProxy
3616	<	{
3617	<	PySequence_ArrowProxy(const T& x): m_value(x) {}
3618	<	const T* operator->() const { return &m_value; }
3619	<	operator const T*() const { return &m_value; }
3620	<	T m_value;
3621	<	};
3622	<
3623	<	template <class T, class Reference >
3624	<	struct PySequence_InputIterator
3625	<	{
3626	<	typedef PySequence_InputIterator<T, Reference > self;
3627	<
3628	<	typedef std::random_access_iterator_tag iterator_category;
3629	<	typedef Reference reference;
3630	<	typedef T value_type;
3631	<	typedef T* pointer;
3632	<	typedef int difference_type;
3633	<
3634	<	PySequence_InputIterator()
3635	<	{
3636	<	}
3637	<
3638	<	PySequence_InputIterator(PyObject* seq, int index)
3639	<	: _seq(seq), _index(index)
3640	<	{
3641	<	}
3642	<
3643	<	reference operator*() const
3644	<	{
3645	<	return reference(_seq, _index);
3646	<	}
3647	<
3648	<	PySequence_ArrowProxy<T>
3649	<	operator->() const {
3650	<	return PySequence_ArrowProxy<T>(operator*());
3651	<	}
3652	<
3653	<	bool operator==(const self& ri) const
3654	<	{
3655	<	return (_index == ri._index) && (_seq == ri._seq);
3656	<	}
3657	<
3658	<	bool operator!=(const self& ri) const
3659	<	{
3660	<	return !(operator==(ri));
3661	<	}
3662	<
3663	<	self& operator ++ ()
3664	<	{
3665	<	++_index;
3666	<	return *this;
3667	<	}
3668	<
3669	<	self& operator -- ()
3670	<	{
3671	<	--_index;
3672	<	return *this;
3673	<	}
3674	<
3675	<	self& operator += (difference_type n)
3676	<	{
3677	<	_index += n;
3678	<	return *this;
3679	<	}
3680	<
3681	<	self operator +(difference_type n) const
3682	<	{
3683	<	return self(_seq, _index + n);
3684	<	}
3685	<
3686	<	self& operator -= (difference_type n)
3687	<	{
3688	<	_index -= n;
3689	<	return *this;
3690	<	}
3691	<
3692	<	self operator -(difference_type n) const
3693	<	{
3694	<	return self(_seq, _index - n);
3695	<	}
3696	<
3697	<	difference_type operator - (const self& ri) const
3698	<	{
3699	<	return _index - ri._index;
3700	<	}
3701	<
3702	<	bool operator < (const self& ri) const
3703	<	{
3704	<	return _index < ri._index;
3705	<	}
3706	<
3707	<	reference
3708	<	operator[](difference_type n) const
3709	<	{
3710	<	return reference(_seq, _index + n);
3711	<	}
3712	<
3713	<	private:
3714	<	PyObject* _seq;
3715	<	difference_type _index;
3716	<	};
3717	<
3718	<	template <class T>
3719	<	struct PySequence_Cont
3720	<	{
3721	<	typedef PySequence_Ref<T> reference;
3722	<	typedef const PySequence_Ref<T> const_reference;
3723	<	typedef T value_type;
3724	<	typedef T* pointer;
3725	<	typedef int difference_type;
3726	<	typedef int size_type;
3727	<	typedef const pointer const_pointer;
3728	<	typedef PySequence_InputIterator<T, reference> iterator;
3729	<	typedef PySequence_InputIterator<T, const_reference> const_iterator;
3730	<
3731	<	PySequence_Cont(PyObject* seq) : _seq(0)
3732	<	{
3733	<	if (!PySequence_Check(seq)) {
3734	<	throw std::invalid_argument("a sequence is expected");
3735	<	}
3736	<	_seq = seq;
3737	<	Py_INCREF(_seq);
3738	<	}
3739	<
3740	<	~PySequence_Cont()
3741	<	{
3742	<	if (_seq) Py_DECREF(_seq);
3743	<	}
3744	<
3745	<	size_type size() const
3746	<	{
3747	<	return PySequence_Size(_seq);
3748	<	}
3749	<
3750	<	bool empty() const
3751	<	{
3752	<	return size() == 0;
3753	<	}
3754	<
3755	<	iterator begin()
3756	<	{
3757	<	return iterator(_seq, 0);
3758	<	}
3759	<
3760	<	const_iterator begin() const
3761	<	{
3762	<	return const_iterator(_seq, 0);
3763	<	}
3764	<
3765	<	iterator end()
3766	<	{
3767	<	return iterator(_seq, size());
3768	<	}
3769	<
3770	<	const_iterator end() const
3771	<	{
3772	<	return const_iterator(_seq, size());
3773	<	}
3774	<
3775	<	reference operator[](difference_type n)
3776	<	{
3777	<	return reference(_seq, n);
3778	<	}
3779	<
3780	<	const_reference operator[](difference_type n)  const
3781	<	{
3782	<	return const_reference(_seq, n);
3783	<	}
3784	<
3785	<	bool check(bool set_err = true) const
3786	<	{
3787	<	int s = size();
3788	<	for (int i = 0; i < s; ++i) {
3789	<	swig::PyObject_var item = PySequence_GetItem(_seq, i);
3790	<	if (!swig::check<value_type>(item)) {
3791	<	if (set_err) {
3792	<	char msg[1024];
3793	<	sprintf(msg, "in sequence element %d", i);
3794	<	SWIG_Error(SWIG_RuntimeError, msg);
3795	<	}
3796	<	return false;
3797	<	}
3798	<	}
3799	<	return true;
3800	<	}
3801	<
3802	<	private:
3803	<	PyObject* _seq;
3804	<	};
3805	<
3806	<	}
3807	<
3808	<
3809	<	SWIGINTERN swig_type_info*
3810	<	SWIG_pchar_descriptor()
3811	<	{
3812	<	static int init = 0;
3813	<	static swig_type_info* info = 0;
3814	<	if (!init) {
3815	<	info = SWIG_TypeQuery("_p_char");
3816	<	init = 1;
3817	<	}
3818	<	return info;
3819	<	}
3820	<
3821	<
3822	<	SWIGINTERN int
3823	<	SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3824	<	{
3825	<	if (PyString_Check(obj)) {
3826	<	char *cstr; int len;
3827	<	PyString_AsStringAndSize(obj, &cstr, &len);
3828	<	if (cptr)  {
3829	<	if (alloc) {
3830	<	/*
3831	<	In python the user should not be able to modify the inner
3832	<	string representation. To warranty that, if you define
3833	<	SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3834	<	buffer is always returned.
3835	<
3836	<	The default behavior is just to return the pointer value,
3837	<	so, be careful.
3838	<	*/
3839	<	#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3840	<	if (*alloc != SWIG_OLDOBJ)
3841	<	#else
3842	<	if (*alloc == SWIG_NEWOBJ)
3843	<	#endif
3844	<	{
3845	<	*cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3846	<	*alloc = SWIG_NEWOBJ;
3847	<	}
3848	<	else {
3849	<	*cptr = cstr;
3850	<	*alloc = SWIG_OLDOBJ;
3851	<	}
3852	<	} else {
3853	<	*cptr = PyString_AsString(obj);
3854	<	}
3855	<	}
3856	<	if (psize) *psize = len + 1;
3857	<	return SWIG_OK;
3858	<	} else {
3859	<	swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3860	<	if (pchar_descriptor) {
3861	<	void* vptr = 0;
3862	<	if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3863	<	if (cptr) *cptr = (char *) vptr;
3864	<	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3865	<	if (alloc) *alloc = SWIG_OLDOBJ;
3866	<	return SWIG_OK;
3867	<	}
3868	<	}
3869	<	}
3870	<	return SWIG_TypeError;
3871	<	}
3872	<
3873	<
3874	<	SWIGINTERN int
3875	<	SWIG_AsPtr_std_string (PyObject * obj, std::string **val)
3876	<	{
3877	<	char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
3878	<	if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
3879	<	if (buf) {
3880	<	if (val) *val = new std::string(buf, size - 1);
3881	<	if (alloc == SWIG_NEWOBJ) delete[] buf;
3882	<	return SWIG_NEWOBJ;
3883	<	} else {
3884	<	if (val) *val = 0;
3885	<	return SWIG_OLDOBJ;
3886	<	}
3887	<	} else {
3888	<	static int init = 0;
3889	<	static swig_type_info* descriptor = 0;
3890	<	if (!init) {
3891	<	descriptor = SWIG_TypeQuery("std::string" " *");
3892	<	init = 1;
3893	<	}
3894	<	if (descriptor) {
3895	<	std::string *vptr;
3896	<	int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
3897	<	if (SWIG_IsOK(res) && val) *val = vptr;
3898	<	return res;
3899	<	}
3900	<	}
3901	<	return SWIG_ERROR;
3902	<	}
3903	<
3904	<
3905	<	SWIGINTERN int
3906	<	SWIG_AsVal_std_string (PyObject * obj, std::string *val)
3907	<	{
3908	<	std::string* v = (std::string *) 0;
3909	<	int res = SWIG_AsPtr_std_string (obj, &v);
3910	<	if (!SWIG_IsOK(res)) return res;
3911	<	if (v) {
3912	<	if (val) *val = *v;
3913	<	if (SWIG_IsNewObj(res)) {
3914	<	delete v;
3915	<	res = SWIG_DelNewMask(res);
3916	<	}
3917	<	return res;
3918	<	}
3919	<	return SWIG_ERROR;
3920	<	}
3921	<
3922	<
3923	<	SWIGINTERNINLINE PyObject *
3924	<	SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3925	<	{
3926	<	if (carray) {
3927	<	if (size > INT_MAX) {
3928	<	swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3929	<	return pchar_descriptor ?
3930	<	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3931	<	} else {
3932	<	return PyString_FromStringAndSize(carray, static_cast< int >(size));
3933	<	}
3934	<	} else {
3935	<	return SWIG_Py_Void();
3936	<	}
3937	<	}
3938	<
3939	<
3940	<	SWIGINTERNINLINE PyObject *
3941	<	SWIG_From_std_string  (const std::string& s)
3942	<	{
3943	<	return SWIG_FromCharPtrAndSize(s.data(), s.size());
3944	<	}
3945	<
3946	<
3947	<	namespace swig {
3948	<	template <> struct traits<std::string > {
3949	<	typedef value_category category;
3950	<	static const char* type_name() { return"std::string"; }
3951	<	};
3952	<	template <>  struct traits_asval<std::string > {
3953	<	typedef std::string value_type;
3954	<	static int asval(PyObject *obj, value_type *val) {
3955	<	return SWIG_AsVal_std_string (obj, val);
3956	<	}
3957	<	};
3958	<	template <>  struct traits_from<std::string > {
3959	<	typedef std::string value_type;
3960	<	static PyObject *from(const value_type& val) {
3961	<	return SWIG_From_std_string  (val);
3962	<	}
3963	<	};
3964	<	}
3965	<
3966	<
3967	<	namespace swig {
3968	<
3969	<
3970	<
3971	<
3972	<
3973	<
3974	<
3975	<
3976	<
3977	<
3978	<
3979	<
3980	<
3981	<
3982	<
3983	<
3984	<
3985	<
3986	<
3987	<
3988	<
3989	<
3990	<
3991	<
3992	<
3993	<
3994	<
3995	<
3996	<
3997	<
3998	<
3999	<
4000	<
4001	<
4002	<
4003	<
4004	<
4005	<
4006	<
4007	<
4008	<
4009	<
4010	<
4011	<
4012	<
4013	<
4014	<
4015	<
4016	<
4017	<	template <class T, class U >
4018	<	struct traits_asptr<std::pair<T,U> >  {
4019	<	typedef std::pair<T,U> value_type;
4020	<
4021	<	static int get_pair(PyObject* first, PyObject* second,
4022	<	std::pair<T,U> **val)
4023	<	{
4024	<	if (val) {
4025	<	value_type *vp = (new std::pair<T,U>);
4026	<	T *pfirst = &(vp->first);
4027	<	int res1 = swig::asval((PyObject*)first, pfirst);
4028	<	if (!SWIG_IsOK(res1)) return res1;
4029	<	U *psecond = &(vp->second);
4030	<	int res2 = swig::asval((PyObject*)second, psecond);
4031	<	if (!SWIG_IsOK(res2)) return res2;
4032	<	*val = vp;
4033	<	return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
4034	<	} else {
4035	<	T *pfirst = 0;
4036	<	int res1 = swig::asval((PyObject*)first, pfirst);
4037	<	if (!SWIG_IsOK(res1)) return res1;
4038	<	U *psecond = 0;
4039	<	int res2 = swig::asval((PyObject*)second, psecond);
4040	<	if (!SWIG_IsOK(res2)) return res2;
4041	<	return res1 > res2 ? res1 : res2;
4042	<	}
4043	<	}
4044	<
4045	<	static int asptr(PyObject *obj, std::pair<T,U> **val) {
4046	<	int res = SWIG_ERROR;
4047	<	if (PyTuple_Check(obj)) {
4048	<	if (PyTuple_GET_SIZE(obj) == 2) {
4049	<	res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
4050	<	}
4051	<	} else if (PySequence_Check(obj)) {
4052	<	if (PySequence_Size(obj) == 2) {
4053	<	swig::PyObject_var first = PySequence_GetItem(obj,0);
4054	<	swig::PyObject_var second = PySequence_GetItem(obj,1);
4055	<	res = get_pair(first, second, val);
4056	<	}
4057	<	} else {
4058	<	value_type *p;
4059	<	res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<value_type>(),0);
4060	<	if (SWIG_IsOK(res) && val)  *val = p;
4061	<	}
4062	<	return res;
4063	<	}
4064	<	};
4065	<
4066	<
4067	<	template <class T, class U >
4068	<	struct traits_from<std::pair<T,U> >   {
4069	<	static PyObject *from(const std::pair<T,U>& val) {
4070	<	PyObject* obj = PyTuple_New(2);
4071	<	PyTuple_SetItem(obj,0,swig::from(val.first));
4072	<	PyTuple_SetItem(obj,1,swig::from(val.second));
4073	<	return obj;
4074	<	}
4075	<	};
4076	<	}
4077	<
4078	<
4079	<	namespace swig {
4080	<	template <>  struct traits<std::pair< std::string, std::string > > {
4081	<	typedef pointer_category category;
4082	<	static const char* type_name() {
4083	<	return "std::pair<" "std::string" "," "std::string" " >";
4084	<	}
4085	<	};
4086	<	}
4087	<
4088	<
4089	<	namespace swig {
4090	<	template <class PySeq, class Seq>
4091	<	inline void
4092	<	assign(const PySeq& pyseq, Seq* seq) {
4093	<	#ifdef SWIG_STD_NOASSIGN_STL
4094	<	typedef typename PySeq::value_type value_type;
4095	<	typename PySeq::const_iterator it = pyseq.begin();
4096	<	for (;it != pyseq.end(); ++it) {
4097	<	seq->insert(seq->end(),(value_type)(*it));
4098	<	}
4099	<	#else
4100	<	seq->assign(pyseq.begin(), pyseq.end());
4101	<	#endif
4102	<	}
4103	<
4104	<	template <class Seq, class T = typename Seq::value_type >
4105	<	struct traits_asptr_stdseq {
4106	<	typedef Seq sequence;
4107	<	typedef T value_type;
4108	<
4109	<	static int asptr(PyObject *obj, sequence **seq) {
4110	<	if (PySequence_Check(obj)) {
4111	<	try {
4112	<	PySequence_Cont<value_type> pyseq(obj);
4113	<	if (seq) {
4114	<	sequence *pseq = new sequence();
4115	<	assign(pyseq, pseq);
4116	<	*seq = pseq;
4117	<	return SWIG_NEWOBJ;
4118	<	} else {
4119	<	return pyseq.check() ? SWIG_OK : SWIG_ERROR;
4120	<	}
4121	<	} catch (std::exception& e) {
4122	<	if (seq) {
4123	<	if (!PyErr_Occurred()) {
4124	<	PyErr_SetString(PyExc_TypeError, e.what());
4125	<	}
4126	<	}
4127	<	return SWIG_ERROR;
4128	<	}
4129	<	} else {
4130	<	sequence *p;
4131	<	if (SWIG_ConvertPtr(obj,(void**)&p,
4132	<	swig::type_info<sequence>(),0) == SWIG_OK) {
4133	<	if (seq) *seq = p;
4134	<	return SWIG_OLDOBJ;
4135	<	}
4136	<	}
4137	<	return SWIG_ERROR;
4138	<	}
4139	<	};
4140	<
4141	<	template <class Seq, class T = typename Seq::value_type >
4142	<	struct traits_from_stdseq {
4143	<	typedef Seq sequence;
4144	<	typedef T value_type;
4145	<	typedef typename Seq::size_type size_type;
4146	<	typedef typename sequence::const_iterator const_iterator;
4147	<
4148	<	static PyObject *from(const sequence& seq) {
4149	<
4150	<
4151	<
4152	<
4153	<
4154	<
4155	<	size_type size = seq.size();
4156	<	if (size <= (size_type)INT_MAX) {
4157	<	PyObject *obj = PyTuple_New((int)size);
4158	<	int i = 0;
4159	<	for (const_iterator it = seq.begin();
4160	<	it != seq.end(); ++it, ++i) {
4161	<	PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
4162	<	}
4163	<	return obj;
4164	<	} else {
4165	<	PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
4166	<	return NULL;
4167	<	}
4168	<	}
4169	<	};
4170	<	}
4171	<
4172	<
4173	<	namespace swig {
4174	<	template <class PySeq, class K, class T >
4175	<	inline void
4176	<	assign(const PySeq& pyseq, std::map<K,T > *map) {
4177	<	typedef typename std::map<K,T>::value_type value_type;
4178	<	typename PySeq::const_iterator it = pyseq.begin();
4179	<	for (;it != pyseq.end(); ++it) {
4180	<	map->insert(value_type(it->first, it->second));
4181	<	}
4182	<	}
4183	<
4184	<	template <class K, class T>
4185	<	struct traits_asptr<std::map<K,T> >  {
4186	<	typedef std::map<K,T> map_type;
4187	<	static int asptr(PyObject *obj, map_type **val) {
4188	<	int res = SWIG_ERROR;
4189	<	if (PyDict_Check(obj)) {
4190	<	PyObject_var items = PyMapping_Items(obj);
4191	<	res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
4192	<	} else {
4193	<	map_type *p;
4194	<	res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
4195	<	if (SWIG_IsOK(res) && val)  *val = p;
4196	<	}
4197	<	return res;
4198	<	}
4199	<	};
4200	<
4201	<	template <class K, class T >
4202	<	struct traits_from<std::map<K,T> >  {
4203	<	typedef std::map<K,T> map_type;
4204	<	typedef typename map_type::const_iterator const_iterator;
4205	<	typedef typename map_type::size_type size_type;
4206	<
4207	<	static PyObject *from(const map_type& map) {
4208	<	swig_type_info *desc = swig::type_info<map_type>();
4209	<	if (desc && desc->clientdata) {
4210	<	return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
4211	<	} else {
4212	<	size_type size = map.size();
4213	<	int pysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
4214	<	if (pysize < 0) {
4215	<	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4216	<	PyErr_SetString(PyExc_OverflowError,
4217	<	"map size not valid in python");
4218	<	SWIG_PYTHON_THREAD_END_BLOCK;
4219	<	return NULL;
4220	<	}
4221	<	PyObject *obj = PyDict_New();
4222	<	for (const_iterator i= map.begin(); i!= map.end(); ++i) {
4223	<	swig::PyObject_var key = swig::from(i->first);
4224	<	swig::PyObject_var val = swig::from(i->second);
4225	<	PyDict_SetItem(obj, key, val);
4226	<	}
4227	<	return obj;
4228	<	}
4229	<	}
4230	<	};
4231	<
4232	<	template <class ValueType>
4233	<	struct from_key_oper
4234	<	{
4235	<	typedef const ValueType& argument_type;
4236	<	typedef  PyObject *result_type;
4237	<	result_type operator()(argument_type v) const
4238	<	{
4239	<	return swig::from(v.first);
4240	<	}
4241	<	};
4242	<
4243	<	template <class ValueType>
4244	<	struct from_value_oper
4245	<	{
4246	<	typedef const ValueType& argument_type;
4247	<	typedef  PyObject *result_type;
4248	<	result_type operator()(argument_type v) const
4249	<	{
4250	<	return swig::from(v.second);
4251	<	}
4252	<	};
4253	<
4254	<	template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
4255	<	struct PyMapIterator_T : PySwigIteratorClosed_T<OutIterator, ValueType, FromOper>
4256	<	{
4257	<	PyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
4258	<	: PySwigIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
4259	<	{
4260	<	}
4261	<	};
4262	<
4263	<
4264	<	template<class OutIterator,
4265	<	class FromOper = from_key_oper<typename OutIterator::value_type> >
4266	<	struct PyMapKeyIterator_T : PyMapIterator_T<OutIterator, FromOper>
4267	<	{
4268	<	PyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
4269	<	: PyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
4270	<	{
4271	<	}
4272	<	};
4273	<
4274	<	template<typename OutIter>
4275	<	inline PySwigIterator*
4276	<	make_output_key_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
4277	<	{
4278	<	return new PyMapKeyIterator_T<OutIter>(current, begin, end, seq);
4279	<	}
4280	<
4281	<	template<class OutIterator,
4282	<	class FromOper = from_value_oper<typename OutIterator::value_type> >
4283	<	struct PyMapValueIterator_T : PyMapIterator_T<OutIterator, FromOper>
4284	<	{
4285	<	PyMapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
4286	<	: PyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
4287	<	{
4288	<	}
4289	<	};
4290	<
4291	<
4292	<	template<typename OutIter>
4293	<	inline PySwigIterator*
4294	<	make_output_value_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, PyObject *seq = 0)
4295	<	{
4296	<	return new PyMapValueIterator_T<OutIter>(current, begin, end, seq);
4297	<	}
4298	<	}
4299	<
4300	<
4301	<	namespace swig {
4302	<	template <>  struct traits<std::map<std::string, std::string, std::less<std::string >, std::allocator<std::pair<std::string const,std::string > > > > {
4303	<	typedef pointer_category category;
4304	<	static const char* type_name() {
4305	<	return "std::map<" "std::string" "," "std::string" "," "std::less<std::string >" "," "std::allocator<std::pair<std::string const,std::string > >" " >";
4306	<	}
4307	<	};
4308	<	}
4309	<
4310	<	SWIGINTERN swig::PySwigIterator *std_map_Sl_std_string_Sc_std_string_Sg__iterator(std::map<std::string,std::string > *self,PyObject **PYTHON_SELF){
4311	<	return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4312	<	}
4313	<	SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____nonzero__(std::map<std::string,std::string > const *self){
4314	<	return !(self->empty());
4315	<	}
4316	<	SWIGINTERN std::map<std::string,std::string >::size_type std_map_Sl_std_string_Sc_std_string_Sg____len__(std::map<std::string,std::string > const *self){
4317	<	return self->size();
4318	<	}
4319	<
4320	<	SWIGINTERNINLINE PyObject*
4321	<	SWIG_From_unsigned_SS_long  (unsigned long value)
4322	<	{
4323	<	return (value > LONG_MAX) ?
4324	<	PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
4325	<	}
4326	<
4327	<
4328	<	SWIGINTERNINLINE PyObject *
4329	<	SWIG_From_size_t  (size_t value)
4330	<	{
4331	<	return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
4332	<	}
4333	<
4334	<	SWIGINTERN std::map<std::string,std::string >::mapped_type std_map_Sl_std_string_Sc_std_string_Sg____getitem__(std::map<std::string,std::string > const *self,std::map<std::string,std::string >::key_type const &key){
4335	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::const_iterator i = self->find(key);
4336	<	if (i != self->end())
4337	<	return i->second;
4338	<	else
4339	<	throw std::out_of_range("key not found");
4340	<	}
4341	<	SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____setitem__(std::map<std::string,std::string > *self,std::map<std::string,std::string >::key_type const &key,std::map<std::string,std::string >::mapped_type const &x){
4342	<	self->insert(std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::value_type(key,x));
4343	<	}
4344	<	SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____delitem__(std::map<std::string,std::string > *self,std::map<std::string,std::string >::key_type const &key){
4345	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::iterator i = self->find(key);
4346	<	if (i != self->end())
4347	<	self->erase(i);
4348	<	else
4349	<	throw std::out_of_range("key not found");
4350	<	}
4351	<	SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__has_key(std::map<std::string,std::string > const *self,std::map<std::string,std::string >::key_type const &key){
4352	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::const_iterator i = self->find(key);
4353	<	return i != self->end();
4354	<	}
4355	<	SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__keys(std::map<std::string,std::string > *self){
4356	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::size_type size = self->size();
4357	<	int pysize = (size <= (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::size_type) INT_MAX) ? (int) size : -1;
4358	<	if (pysize < 0) {
4359	<	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4360	<	PyErr_SetString(PyExc_OverflowError,
4361	<	"map size not valid in python");
4362	<	SWIG_PYTHON_THREAD_END_BLOCK;
4363	<	return NULL;
4364	<	}
4365	<	PyObject* keyList = PyList_New(pysize);
4366	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::const_iterator i = self->begin();
4367	<	for (int j = 0; j < pysize; ++i, ++j) {
4368	<	PyList_SET_ITEM(keyList, j, swig::from(i->first));
4369	<	}
4370	<	return keyList;
4371	<	}
4372	<	SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__values(std::map<std::string,std::string > *self){
4373	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::size_type size = self->size();
4374	<	int pysize = (size <= (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::size_type) INT_MAX) ? (int) size : -1;
4375	<	if (pysize < 0) {
4376	<	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4377	<	PyErr_SetString(PyExc_OverflowError,
4378	<	"map size not valid in python");
4379	<	SWIG_PYTHON_THREAD_END_BLOCK;
4380	<	return NULL;
4381	<	}
4382	<	PyObject* valList = PyList_New(pysize);
4383	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::const_iterator i = self->begin();
4384	<	for (int j = 0; j < pysize; ++i, ++j) {
4385	<	PyList_SET_ITEM(valList, j, swig::from(i->second));
4386	<	}
4387	<	return valList;
4388	<	}
4389	<	SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__items(std::map<std::string,std::string > *self){
4390	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::size_type size = self->size();
4391	<	int pysize = (size <= (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::size_type) INT_MAX) ? (int) size : -1;
4392	<	if (pysize < 0) {
4393	<	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
4394	<	PyErr_SetString(PyExc_OverflowError,
4395	<	"map size not valid in python");
4396	<	SWIG_PYTHON_THREAD_END_BLOCK;
4397	<	return NULL;
4398	<	}
4399	<	PyObject* itemList = PyList_New(pysize);
4400	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >::const_iterator i = self->begin();
4401	<	for (int j = 0; j < pysize; ++i, ++j) {
4402	<	PyList_SET_ITEM(itemList, j, swig::from(*i));
4403	<	}
4404	<	return itemList;
4405	<	}
4406	<	SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____contains__(std::map<std::string,std::string > *self,std::map<std::string,std::string >::key_type const &key){
4407	<	return self->find(key) != self->end();
4408	<	}
4409	<	SWIGINTERN swig::PySwigIterator *std_map_Sl_std_string_Sc_std_string_Sg__key_iterator(std::map<std::string,std::string > *self,PyObject **PYTHON_SELF){
4410	<	return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4411	<	}
4412	<	SWIGINTERN swig::PySwigIterator *std_map_Sl_std_string_Sc_std_string_Sg__value_iterator(std::map<std::string,std::string > *self,PyObject **PYTHON_SELF){
4413	<	return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4414	<	}
4415	<
4416	<	namespace swig {
4417	<	template <class T>
4418	<	struct traits_asptr<std::vector<T> >  {
4419	<	static int asptr(PyObject *obj, std::vector<T> **vec) {
4420	<	return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
4421	<	}
4422	<	};
4423	<
4424	<	template <class T>
4425	<	struct traits_from<std::vector<T> > {
4426	<	static PyObject *from(const std::vector<T>& vec) {
4427	<	return traits_from_stdseq<std::vector<T> >::from(vec);
4428	<	}
4429	<	};
4430	<	}
4431	<
4432	<
4433	<	namespace swig {
4434	<	template <>  struct traits<std::vector<std::string, std::allocator<std::string > > > {
4435	<	typedef pointer_category category;
4436	<	static const char* type_name() {
4437	<	return "std::vector<" "std::string" "," "std::allocator<std::string >" " >";
4438	<	}
4439	<	};
4440	<	}
4441	<
4442	<	SWIGINTERN swig::PySwigIterator *std_vector_Sl_std_string_Sg__iterator(std::vector<std::string > *self,PyObject **PYTHON_SELF){
4443	<	return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4444	<	}
4445	<	SWIGINTERN bool std_vector_Sl_std_string_Sg____nonzero__(std::vector<std::string > const *self){
4446	<	return !(self->empty());
4447	<	}
4448	<	SWIGINTERN std::vector<std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector<std::string > const *self){
4449	<	return self->size();
4450	<	}
4451	<	SWIGINTERN std::vector<std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector<std::string > *self){
4452	<	if (self->size() == 0)
4453	<	throw std::out_of_range("pop from empty container");
4454	<	std::vector<std::string,std::allocator<std::string > >::value_type x = self->back();
4455	<	self->pop_back();
4456	<	return x;
4457	<	}
4458	<	SWIGINTERN std::vector<std::string,std::allocator<std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector<std::string > *self,std::vector<std::string >::difference_type i,std::vector<std::string >::difference_type j){
4459	<	return swig::getslice(self, i, j);
4460	<	}
4461	<	SWIGINTERN void std_vector_Sl_std_string_Sg____setslice__(std::vector<std::string > *self,std::vector<std::string >::difference_type i,std::vector<std::string >::difference_type j,std::vector<std::string,std::allocator<std::string > > const &v){
4462	<	swig::setslice(self, i, j, v);
4463	<	}
4464	<	SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector<std::string > *self,std::vector<std::string >::difference_type i,std::vector<std::string >::difference_type j){
4465	<	swig::delslice(self, i, j);
4466	<	}
4467	<	SWIGINTERN void std_vector_Sl_std_string_Sg____delitem__(std::vector<std::string > *self,std::vector<std::string >::difference_type i){
4468	<	self->erase(swig::getpos(self,i));
4469	<	}
4470	<	SWIGINTERN std::vector<std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem__(std::vector<std::string > const *self,std::vector<std::string >::difference_type i){
4471	<	return *(swig::cgetpos(self, i));
4472	<	}
4473	<	SWIGINTERN void std_vector_Sl_std_string_Sg____setitem__(std::vector<std::string > *self,std::vector<std::string >::difference_type i,std::vector<std::string >::value_type const &x){
4474	<	*(swig::getpos(self,i)) = x;
4475	<	}
4476	<	SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector<std::string > *self,std::vector<std::string >::value_type const &x){
4477	<	self->push_back(x);
4478	<	}
4479	<
920	>	static PyObject * BossError;
921	>	static PyObject * SchedulerError;
922		#include "BossSession.h"
923		#include "BossAdministratorSession.h"
924		#include "BossTask.h"
#	Line 4487 | Line 929 | SWIGINTERN void std_vector_Sl_std_string
929		#include "BossProgram.h"
930		#include "BossProgramExec.h"
931		#include "BossDatabase.h"
932	+	#include "BossScheduler.h"
933	+	#include "BossDeclaration.h"
934
935	<
4492	<	SWIGINTERNINLINE PyObject *
4493	<	SWIG_From_int  (int value)
4494	<	{
4495	<	return SWIG_From_long  (value);
4496	<	}
4497	<
4498	<
4499	<	SWIGINTERN int
4500	<	SWIG_AsVal_bool (PyObject *obj, bool *val)
4501	<	{
4502	<	if (obj == Py_True) {
4503	<	if (val) *val = true;
4504	<	return SWIG_OK;
4505	<	} else if (obj == Py_False) {
4506	<	if (val) *val = false;
4507	<	return SWIG_OK;
4508	<	} else {
4509	<	long v = 0;
4510	<	int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
4511	<	if (SWIG_IsOK(res) && val) *val = v ? true : false;
4512	<	return res;
4513	<	}
4514	<	}
4515	<
4516	<
4517	<	#include <limits.h>
4518	<	#ifndef LLONG_MIN
4519	<	# define LLONG_MIN      LONG_LONG_MIN
4520	<	#endif
4521	<	#ifndef LLONG_MAX
4522	<	# define LLONG_MAX      LONG_LONG_MAX
4523	<	#endif
4524	<	#ifndef ULLONG_MAX
4525	<	# define ULLONG_MAX     ULONG_LONG_MAX
4526	<	#endif
4527	<
4528	<
4529	<	SWIGINTERN int
4530	<	SWIG_AsVal_int (PyObject * obj, int *val)
4531	<	{
4532	<	long v;
4533	<	int res = SWIG_AsVal_long (obj, &v);
4534	<	if (SWIG_IsOK(res)) {
4535	<	if ((v < INT_MIN || v > INT_MAX)) {
4536	<	return SWIG_OverflowError;
4537	<	} else {
4538	<	if (val) *val = static_cast< int >(v);
4539	<	}
4540	<	}
4541	<	return res;
4542	<	}
4543	<
4544	<	SWIGINTERN PyObject *BossSession_show(BossSession *self,std::vector<std::string,std::allocator<std::string > > &my_vec){
935	>	PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
936		PyObject *  my_list = PyList_New( my_vec.size());
937		unsigned int index = 0;
938		for ( std::vector<std::string>::const_iterator it = my_vec.begin ();
#	Line 4550 | Line 941 | SWIGINTERN PyObject *BossSession_show(Bo
941		}
942		return my_list;
943		}
944	<	SWIGINTERN PyObject *BossSession_CHTools(BossSession *self){
944	>	PyObject *BossSession_CHTools(BossSession *self){
945		std::vector<std::string> my_vec = self->showCHTools();
946		return BossSession_show( self, my_vec );
947		}
948	<	SWIGINTERN PyObject *BossSession_ProgramTypes(BossSession *self){
948	>	PyObject *BossSession_ProgramTypes(BossSession *self){
949		std::vector<std::string> my_vec = self->showProgramTypes();
950		return BossSession_show( self, my_vec );
951		}
952	<	SWIGINTERN PyObject *BossSession_RTMons(BossSession *self){
952	>	PyObject *BossSession_RTMons(BossSession *self){
953		std::vector<std::string> my_vec = self->showRTMon();
954		return BossSession_show( self, my_vec );
955		}
956	<	SWIGINTERN PyObject *BossSession_schedulers(BossSession *self){
956	>	PyObject *BossSession_schedulers(BossSession *self){
957		std::vector<std::string> my_vec = self->showSchedulers();
958		return BossSession_show( self, my_vec );
959		}
960	<	SWIGINTERN PyObject *BossSession_schedListMatch__SWIG_0(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid="",std::string const &jobid="",bool keepfile=false){
960	>	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
961		std::vector<std::string> my_vec = self->listMatch( scheduler,
962		schclassad,
963		keepfile,
#	Line 4574 | Line 965 | SWIGINTERN PyObject *BossSession_schedLi
965		jobid);
966		return BossSession_show( self, my_vec );
967		}
968	<	SWIGINTERN PyObject *BossSession_queryTasks__SWIG_0(BossSession *self,int filter_opt=SCHEDULED,std::string const &taskRange="all",std::string const &jobRange="all",std::string const &subn="",std::string type="",std::string user="",std::string after="",std::string before="",bool avoidCheck=false){
968	>	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,bool avoidCheck){
969		if ( !avoidCheck ) {
970		self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
971		type, user, after, before);
#	Line 4586 | Line 977 | SWIGINTERN PyObject *BossSession_queryTa
977		it!= taskList.end(); ++it ) {
978		PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
979		}
4589	–
4590	–	//       int size = taskList.size();
4591	–	//       PyObject * job_dict = PyList_New(0);
4592	–	//       for ( unsigned int i = 0; i < size; ++i ) {
4593	–	//      PyList_SetItem(job_dict,i, );
4594	–	//      self->makeBossTask( *it );
4595	–	//       }
980		return  job_dict;
981		}
982	<
4599	<
4600	<
4601	<
4602	<	SWIGINTERNINLINE PyObject *
4603	<	SWIG_FromCharPtr(const char *cptr)
4604	<	{
4605	<	return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
4606	<	}
4607	<
4608	<
4609	<	SWIGINTERN int
4610	<	SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
4611	<	{
4612	<	unsigned long v;
4613	<	int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
4614	<	if (SWIG_IsOK(res)) {
4615	<	if ((v > UINT_MAX)) {
4616	<	return SWIG_OverflowError;
4617	<	} else {
4618	<	if (val) *val = static_cast< unsigned int >(v);
4619	<	}
4620	<	}
4621	<	return res;
4622	<	}
4623	<
4624	<	SWIGINTERN PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
982	>	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
983		std::string tmp;
984		BossAttributeContainer::const_iterator it_end = obj.end ();
985		for (BossAttributeContainer::const_iterator it = obj.begin ();
#	Line 4636 | Line 994 | SWIGINTERN PyObject *BossTask_appendToPy
994		}
995		return dict;
996		}
997	<	SWIGINTERN PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator &jit){
997	>	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
998
999		PyObject * job_dict = PyDict_New();
1000		std::string tmp;
#	Line 4658 | Line 1016 | SWIGINTERN PyObject *BossTask_jobDict(Bo
1016		}
1017		return job_dict;
1018		}
1019	<	SWIGINTERN PyObject *BossTask_jobsDict(BossTask const *self){
1019	>	PyObject *BossTask_jobsDict(BossTask *self){
1020
1021		PyObject * job_dict = PyDict_New();
1022	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1023		for (BossTask::job_iterator jit = self->job_begin ();
1024		jit != self->job_end (); ++jit) {
1025		std::string id = (*jit)->chainId();
#	Line 4670 | Line 1029 | SWIGINTERN PyObject *BossTask_jobsDict(B
1029		}
1030		return job_dict;
1031		}
1032	<	SWIGINTERN PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >::const_iterator &programs_it){
1032	>	PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator &programs_it){
1033
1034		PyObject * job_dict = PyDict_New();
1035
#	Line 4694 | Line 1053 | SWIGINTERN PyObject *BossTask_progDict(B
1053		}
1054		return job_dict;
1055		}
1056	<	SWIGINTERN PyObject *BossTask_jobPrograms(BossTask const *self,std::string const &jobid){
1056	>	PyObject *BossTask_jobPrograms(BossTask const *self,std::string const &jobid){
1057
1058		const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1059		std::map< std::string, std::map< std::string, std::string > > ret_val;
#	Line 4720 | Line 1079 | SWIGINTERN PyObject *BossTask_jobProgram
1079		#ifdef __cplusplus
1080		extern "C" {
1081		#endif
1082	<	SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1083	<	PyObject *resultobj = 0;
1084	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1085	<	void *argp1 = 0 ;
1086	<	int res1 = 0 ;
1087	<	PyObject * obj0 = 0 ;
1088	<
1089	<	if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
1090	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
1091	<	if (!SWIG_IsOK(res1)) {
1092	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1093	<	}
1094	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
1095	<	{
1096	<	try {
4738	<	delete arg1;
4739	<
4740	<	} catch (const std::exception& e) {
4741	<	SWIG_exception(SWIG_RuntimeError, e.what());
4742	<	}
4743	<	}
4744	<	resultobj = SWIG_Py_Void();
4745	<	return resultobj;
4746	<	fail:
4747	<	return NULL;
4748	<	}
4749	<
4750	<
4751	<	SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4752	<	PyObject *resultobj = 0;
4753	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4754	<	PyObject *result = 0 ;
4755	<	void *argp1 = 0 ;
4756	<	int res1 = 0 ;
4757	<	PyObject * obj0 = 0 ;
4758	<
4759	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
4760	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4761	<	if (!SWIG_IsOK(res1)) {
4762	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4763	<	}
4764	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4765	<	{
4766	<	try {
4767	<	try {
4768	<	result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
4769	<	}
4770	<	catch(swig::stop_iteration &_e) {
4771	<	{
4772	<	(void)_e;
4773	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4774	<	SWIG_fail;
1082	>	static PyObject *_wrap_new_objectMap__SWIG_0(PyObject *self, PyObject *args) {
1083	>	PyObject *resultobj;
1084	>	std::map<std::string,std::string > *result;
1085	>
1086	>	if(!PyArg_ParseTuple(args,(char *)":new_objectMap")) goto fail;
1087	>	{
1088	>	try {
1089	>	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1090	>
1091	>	}catch (const BossSchedFailure & e) {
1092	>	PyErr_SetString ( SchedulerError, e.what() );
1093	>	return NULL;
1094	>	}catch (const std::exception& e) {
1095	>	PyErr_SetString ( BossError, e.what() );
1096	>	return NULL;
1097		}
4776	–	}
4777	–
4778	–	} catch (const std::exception& e) {
4779	–	SWIG_exception(SWIG_RuntimeError, e.what());
1098		}
1099	<	}
1100	<	resultobj = result;
1101	<	return resultobj;
1102	<	fail:
4785	<	return NULL;
1099	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
1100	>	return resultobj;
1101	>	fail:
1102	>	return NULL;
1103		}
1104
1105
1106	<	SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1107	<	PyObject *resultobj = 0;
1108	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1109	<	size_t arg2 ;
1110	<	swig::PySwigIterator *result = 0 ;
1111	<	void *argp1 = 0 ;
1112	<	int res1 = 0 ;
1113	<	size_t val2 ;
1114	<	int ecode2 = 0 ;
1115	<	PyObject * obj0 = 0 ;
1116	<	PyObject * obj1 = 0 ;
1117	<
1118	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
1119	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1120	<	if (!SWIG_IsOK(res1)) {
1121	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1122	<	}
1123	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
1124	<	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
1125	<	if (!SWIG_IsOK(ecode2)) {
1126	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
1127	<	}
1128	<	arg2 = static_cast< size_t >(val2);
1129	<	{
1130	<	try {
1131	<	try {
1132	<	result = (swig::PySwigIterator *)(arg1)->incr(arg2);
1133	<	}
1134	<	catch(swig::stop_iteration &_e) {
1135	<	{
1136	<	(void)_e;
1137	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
1138	<	SWIG_fail;
1106	>	static PyObject *_wrap_new_objectMap__SWIG_1(PyObject *self, PyObject *args) {
1107	>	PyObject *resultobj;
1108	>	std::map<std::string,std::string > *arg1 = 0 ;
1109	>	std::map<std::string,std::string > *result;
1110	>	std::map<std::string,std::string > temp1 ;
1111	>	std::map<std::string,std::string > *m1 ;
1112	>	PyObject * obj0 = 0 ;
1113	>
1114	>	if(!PyArg_ParseTuple(args,(char *)"O:new_objectMap",&obj0)) goto fail;
1115	>	{
1116	>	if (PyDict_Check(obj0)) {
1117	>	PyObject* items = PyMapping_Items(obj0);
1118	>	unsigned int size = PyList_Size(items);
1119	>	temp1 = std::map<std::string,std::string >();
1120	>	arg1 = &temp1;
1121	>	for (unsigned int i=0; i<size; i++) {
1122	>	PyObject* pair = PySequence_GetItem(items,i);
1123	>	PyObject* key = PySequence_GetItem(pair,0);
1124	>	PyObject* o = PySequence_GetItem(pair,1);
1125	>	if (PyString_Check(key) && PyString_Check(o)) {
1126	>	temp1[SwigString_AsString(key)] = SwigString_AsString(o);
1127	>	Py_DECREF(key);
1128	>	Py_DECREF(o);
1129	>	Py_DECREF(pair);
1130	>	}else {
1131	>	Py_DECREF(key);
1132	>	Py_DECREF(o);
1133	>	Py_DECREF(pair);
1134	>	Py_DECREF(items);
1135	>	PyErr_SetString(PyExc_TypeError,
1136	>	"map<""std::string"",""std::string""> expected");
1137	>	SWIG_fail;
1138	>	}
1139	>	}
1140	>	Py_DECREF(items);
1141	>	}else if (SWIG_ConvertPtr(obj0,(void **) &m1,
1142	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
1143	>	arg1 = m1;
1144	>	}else {
1145	>	PyErr_SetString(PyExc_TypeError,
1146	>	"map<""std::string"",""std::string""> expected");
1147	>	SWIG_fail;
1148		}
4823	–	}
4824	–
4825	–	} catch (const std::exception& e) {
4826	–	SWIG_exception(SWIG_RuntimeError, e.what());
1149		}
1150	<	}
1151	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1152	<	return resultobj;
1153	<	fail:
1154	<	return NULL;
1155	<	}
1156	<
1157	<
1158	<	SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1159	<	PyObject *resultobj = 0;
4838	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4839	<	swig::PySwigIterator *result = 0 ;
4840	<	void *argp1 = 0 ;
4841	<	int res1 = 0 ;
4842	<	PyObject * obj0 = 0 ;
4843	<
4844	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
4845	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4846	<	if (!SWIG_IsOK(res1)) {
4847	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4848	<	}
4849	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4850	<	{
4851	<	try {
4852	<	try {
4853	<	result = (swig::PySwigIterator *)(arg1)->incr();
4854	<	}
4855	<	catch(swig::stop_iteration &_e) {
4856	<	{
4857	<	(void)_e;
4858	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4859	<	SWIG_fail;
1150	>	{
1151	>	try {
1152	>	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1153	>
1154	>	}catch (const BossSchedFailure & e) {
1155	>	PyErr_SetString ( SchedulerError, e.what() );
1156	>	return NULL;
1157	>	}catch (const std::exception& e) {
1158	>	PyErr_SetString ( BossError, e.what() );
1159	>	return NULL;
1160		}
4861	–	}
4862	–
4863	–	} catch (const std::exception& e) {
4864	–	SWIG_exception(SWIG_RuntimeError, e.what());
1161		}
1162	<	}
1163	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1164	<	return resultobj;
1165	<	fail:
4870	<	return NULL;
1162	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
1163	>	return resultobj;
1164	>	fail:
1165	>	return NULL;
1166		}
1167
1168
1169	<	SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
1170	<	int argc;
1171	<	PyObject *argv[3];
1172	<	int ii;
1173	<
1174	<	if (!PyTuple_Check(args)) SWIG_fail;
1175	<	argc = PyObject_Length(args);
1176	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4882	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4883	<	}
4884	<	if (argc == 1) {
4885	<	int _v;
4886	<	void *vptr = 0;
4887	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4888	<	_v = SWIG_CheckState(res);
4889	<	if (_v) {
4890	<	return _wrap_PySwigIterator_incr__SWIG_1(self, args);
1169	>	static PyObject *_wrap_new_objectMap(PyObject *self, PyObject *args) {
1170	>	int argc;
1171	>	PyObject *argv[2];
1172	>	int ii;
1173	>
1174	>	argc = PyObject_Length(args);
1175	>	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1176	>	argv[ii] = PyTuple_GetItem(args,ii);
1177		}
1178	<	}
1179	<	if (argc == 2) {
4894	<	int _v;
4895	<	void *vptr = 0;
4896	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4897	<	_v = SWIG_CheckState(res);
4898	<	if (_v) {
4899	<	{
4900	<	int res = SWIG_AsVal_size_t(argv[1], NULL);
4901	<	_v = SWIG_CheckState(res);
4902	<	}
4903	<	if (_v) {
4904	<	return _wrap_PySwigIterator_incr__SWIG_0(self, args);
4905	<	}
1178	>	if (argc == 0) {
1179	>	return _wrap_new_objectMap__SWIG_0(self,args);
1180		}
1181	<	}
1182	<
4909	<	fail:
4910	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'PySwigIterator_incr'");
4911	<	return NULL;
4912	<	}
4913	<
4914	<
4915	<	SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4916	<	PyObject *resultobj = 0;
4917	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4918	<	size_t arg2 ;
4919	<	swig::PySwigIterator *result = 0 ;
4920	<	void *argp1 = 0 ;
4921	<	int res1 = 0 ;
4922	<	size_t val2 ;
4923	<	int ecode2 = 0 ;
4924	<	PyObject * obj0 = 0 ;
4925	<	PyObject * obj1 = 0 ;
4926	<
4927	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
4928	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4929	<	if (!SWIG_IsOK(res1)) {
4930	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4931	<	}
4932	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4933	<	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
4934	<	if (!SWIG_IsOK(ecode2)) {
4935	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
4936	<	}
4937	<	arg2 = static_cast< size_t >(val2);
4938	<	{
4939	<	try {
4940	<	try {
4941	<	result = (swig::PySwigIterator *)(arg1)->decr(arg2);
4942	<	}
4943	<	catch(swig::stop_iteration &_e) {
4944	<	{
4945	<	(void)_e;
4946	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4947	<	SWIG_fail;
4948	<	}
4949	<	}
4950	<
4951	<	} catch (const std::exception& e) {
4952	<	SWIG_exception(SWIG_RuntimeError, e.what());
4953	<	}
4954	<	}
4955	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4956	<	return resultobj;
4957	<	fail:
4958	<	return NULL;
4959	<	}
4960	<
4961	<
4962	<	SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4963	<	PyObject *resultobj = 0;
4964	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4965	<	swig::PySwigIterator *result = 0 ;
4966	<	void *argp1 = 0 ;
4967	<	int res1 = 0 ;
4968	<	PyObject * obj0 = 0 ;
4969	<
4970	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
4971	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4972	<	if (!SWIG_IsOK(res1)) {
4973	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4974	<	}
4975	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4976	<	{
4977	<	try {
4978	<	try {
4979	<	result = (swig::PySwigIterator *)(arg1)->decr();
4980	<	}
4981	<	catch(swig::stop_iteration &_e) {
1181	>	if (argc == 1) {
1182	>	int _v;
1183		{
1184	<	(void)_e;
1185	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
1186	<	SWIG_fail;
1184	>	/* native sequence? */
1185	>	if (PyDict_Check(argv[0])) {
1186	>	PyObject* items = PyMapping_Items(argv[0]);
1187	>	unsigned int size = PyList_Size(items);
1188	>	if (size == 0) {
1189	>	/* an empty dictionary can be of any type */
1190	>	_v = 1;
1191	>	}else {
1192	>	/* check the first element only */
1193	>	PyObject* pair = PySequence_GetItem(items,0);
1194	>	PyObject* key = PySequence_GetItem(pair,0);
1195	>	PyObject* o = PySequence_GetItem(pair,1);
1196	>	if (PyString_Check(key) && PyString_Check(o))
1197	>	_v = 1;
1198	>	else
1199	>	_v = 0;
1200	>	Py_DECREF(key);
1201	>	Py_DECREF(o);
1202	>	Py_DECREF(pair);
1203	>	}
1204	>	Py_DECREF(items);
1205	>	}else {
1206	>	/* wrapped map? */
1207	>	std::map<std::string,std::string >* m;
1208	>	if (SWIG_ConvertPtr(argv[0],(void **) &m,
1209	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1)
1210	>	_v = 1;
1211	>	else
1212	>	_v = 0;
1213	>	}
1214		}
1215	<	}
1216	<
4989	<	} catch (const std::exception& e) {
4990	<	SWIG_exception(SWIG_RuntimeError, e.what());
4991	<	}
4992	<	}
4993	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4994	<	return resultobj;
4995	<	fail:
4996	<	return NULL;
4997	<	}
4998	<
4999	<
5000	<	SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
5001	<	int argc;
5002	<	PyObject *argv[3];
5003	<	int ii;
5004	<
5005	<	if (!PyTuple_Check(args)) SWIG_fail;
5006	<	argc = PyObject_Length(args);
5007	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5008	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5009	<	}
5010	<	if (argc == 1) {
5011	<	int _v;
5012	<	void *vptr = 0;
5013	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5014	<	_v = SWIG_CheckState(res);
5015	<	if (_v) {
5016	<	return _wrap_PySwigIterator_decr__SWIG_1(self, args);
5017	<	}
5018	<	}
5019	<	if (argc == 2) {
5020	<	int _v;
5021	<	void *vptr = 0;
5022	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5023	<	_v = SWIG_CheckState(res);
5024	<	if (_v) {
5025	<	{
5026	<	int res = SWIG_AsVal_size_t(argv[1], NULL);
5027	<	_v = SWIG_CheckState(res);
5028	<	}
5029	<	if (_v) {
5030	<	return _wrap_PySwigIterator_decr__SWIG_0(self, args);
5031	<	}
5032	<	}
5033	<	}
5034	<
5035	<	fail:
5036	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'PySwigIterator_decr'");
5037	<	return NULL;
5038	<	}
5039	<
5040	<
5041	<	SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5042	<	PyObject *resultobj = 0;
5043	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5044	<	swig::PySwigIterator *arg2 = 0 ;
5045	<	ptrdiff_t result;
5046	<	void *argp1 = 0 ;
5047	<	int res1 = 0 ;
5048	<	void *argp2 = 0 ;
5049	<	int res2 = 0 ;
5050	<	PyObject * obj0 = 0 ;
5051	<	PyObject * obj1 = 0 ;
5052	<
5053	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
5054	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5055	<	if (!SWIG_IsOK(res1)) {
5056	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5057	<	}
5058	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5059	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5060	<	if (!SWIG_IsOK(res2)) {
5061	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5062	<	}
5063	<	if (!argp2) {
5064	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5065	<	}
5066	<	arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5067	<	{
5068	<	try {
5069	<	try {
5070	<	result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
5071	<	}
5072	<	catch(std::invalid_argument &_e) {
5073	<	SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
5074	<	}
5075	<
5076	<	} catch (const std::exception& e) {
5077	<	SWIG_exception(SWIG_RuntimeError, e.what());
5078	<	}
5079	<	}
5080	<	resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5081	<	return resultobj;
5082	<	fail:
5083	<	return NULL;
5084	<	}
5085	<
5086	<
5087	<	SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5088	<	PyObject *resultobj = 0;
5089	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5090	<	swig::PySwigIterator *arg2 = 0 ;
5091	<	bool result;
5092	<	void *argp1 = 0 ;
5093	<	int res1 = 0 ;
5094	<	void *argp2 = 0 ;
5095	<	int res2 = 0 ;
5096	<	PyObject * obj0 = 0 ;
5097	<	PyObject * obj1 = 0 ;
5098	<
5099	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
5100	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5101	<	if (!SWIG_IsOK(res1)) {
5102	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5103	<	}
5104	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5105	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5106	<	if (!SWIG_IsOK(res2)) {
5107	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5108	<	}
5109	<	if (!argp2) {
5110	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5111	<	}
5112	<	arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5113	<	{
5114	<	try {
5115	<	try {
5116	<	result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
5117	<	}
5118	<	catch(std::invalid_argument &_e) {
5119	<	SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
5120	<	}
5121	<
5122	<	} catch (const std::exception& e) {
5123	<	SWIG_exception(SWIG_RuntimeError, e.what());
5124	<	}
5125	<	}
5126	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
5127	<	return resultobj;
5128	<	fail:
5129	<	return NULL;
5130	<	}
5131	<
5132	<
5133	<	SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5134	<	PyObject *resultobj = 0;
5135	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5136	<	swig::PySwigIterator *result = 0 ;
5137	<	void *argp1 = 0 ;
5138	<	int res1 = 0 ;
5139	<	PyObject * obj0 = 0 ;
5140	<
5141	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
5142	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5143	<	if (!SWIG_IsOK(res1)) {
5144	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5145	<	}
5146	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5147	<	{
5148	<	try {
5149	<	result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
5150	<	} catch (const std::exception& e) {
5151	<	SWIG_exception(SWIG_RuntimeError, e.what());
5152	<	}
5153	<	}
5154	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5155	<	return resultobj;
5156	<	fail:
5157	<	return NULL;
5158	<	}
5159	<
5160	<
5161	<	SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162	<	PyObject *resultobj = 0;
5163	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5164	<	PyObject *result = 0 ;
5165	<	void *argp1 = 0 ;
5166	<	int res1 = 0 ;
5167	<	PyObject * obj0 = 0 ;
5168	<
5169	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
5170	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5171	<	if (!SWIG_IsOK(res1)) {
5172	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5173	<	}
5174	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5175	<	{
5176	<	try {
5177	<	try {
5178	<	result = (PyObject *)(arg1)->next();
5179	<	}
5180	<	catch(swig::stop_iteration &_e) {
5181	<	{
5182	<	(void)_e;
5183	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5184	<	SWIG_fail;
1215	>	if (_v) {
1216	>	return _wrap_new_objectMap__SWIG_1(self,args);
1217		}
5186	–	}
5187	–
5188	–	} catch (const std::exception& e) {
5189	–	SWIG_exception(SWIG_RuntimeError, e.what());
1218		}
1219	<	}
1220	<	resultobj = result;
1221	<	return resultobj;
5194	<	fail:
5195	<	return NULL;
1219	>
1220	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_objectMap'");
1221	>	return NULL;
1222		}
1223
1224
1225	<	SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1226	<	PyObject *resultobj = 0;
1227	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1228	<	PyObject *result = 0 ;
1229	<	void *argp1 = 0 ;
1230	<	int res1 = 0 ;
1231	<	PyObject * obj0 = 0 ;
1232	<
1233	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
1234	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1235	<	if (!SWIG_IsOK(res1)) {
1236	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1237	<	}
1238	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
1239	<	{
1240	<	try {
1241	<	try {
1242	<	result = (PyObject *)(arg1)->previous();
1243	<	}
1244	<	catch(swig::stop_iteration &_e) {
1245	<	{
1246	<	(void)_e;
1247	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
1248	<	SWIG_fail;
1225	>	static PyObject *_wrap_objectMap___len__(PyObject *self, PyObject *args) {
1226	>	PyObject *resultobj;
1227	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1228	>	unsigned int result;
1229	>	std::map<std::string,std::string > temp1 ;
1230	>	std::map<std::string,std::string > *m1 ;
1231	>	PyObject * obj0 = 0 ;
1232	>
1233	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___len__",&obj0)) goto fail;
1234	>	{
1235	>	if (PyDict_Check(obj0)) {
1236	>	PyObject* items = PyMapping_Items(obj0);
1237	>	unsigned int size = PyList_Size(items);
1238	>	temp1 = std::map<std::string,std::string >();
1239	>	arg1 = &temp1;
1240	>	for (unsigned int i=0; i<size; i++) {
1241	>	PyObject* pair = PySequence_GetItem(items,i);
1242	>	PyObject* key = PySequence_GetItem(pair,0);
1243	>	PyObject* o = PySequence_GetItem(pair,1);
1244	>	if (PyString_Check(key) && PyString_Check(o)) {
1245	>	temp1[SwigString_AsString(key)] = SwigString_AsString(o);
1246	>	Py_DECREF(key);
1247	>	Py_DECREF(o);
1248	>	Py_DECREF(pair);
1249	>	}else {
1250	>	Py_DECREF(key);
1251	>	Py_DECREF(o);
1252	>	Py_DECREF(pair);
1253	>	Py_DECREF(items);
1254	>	PyErr_SetString(PyExc_TypeError,
1255	>	"map<""std::string"",""std::string""> expected");
1256	>	SWIG_fail;
1257	>	}
1258	>	}
1259	>	Py_DECREF(items);
1260	>	}else if (SWIG_ConvertPtr(obj0,(void **) &m1,
1261	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
1262	>	arg1 = m1;
1263	>	}else {
1264	>	PyErr_SetString(PyExc_TypeError,
1265	>	"map<""std::string"",""std::string""> expected");
1266	>	SWIG_fail;
1267		}
5224	–	}
5225	–
5226	–	} catch (const std::exception& e) {
5227	–	SWIG_exception(SWIG_RuntimeError, e.what());
1268		}
1269	<	}
1270	<	resultobj = result;
1271	<	return resultobj;
1272	<	fail:
1273	<	return NULL;
1274	<	}
1275	<
1276	<
1277	<	SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1278	<	PyObject *resultobj = 0;
5239	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5240	<	ptrdiff_t arg2 ;
5241	<	swig::PySwigIterator *result = 0 ;
5242	<	void *argp1 = 0 ;
5243	<	int res1 = 0 ;
5244	<	ptrdiff_t val2 ;
5245	<	int ecode2 = 0 ;
5246	<	PyObject * obj0 = 0 ;
5247	<	PyObject * obj1 = 0 ;
5248	<
5249	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
5250	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5251	<	if (!SWIG_IsOK(res1)) {
5252	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5253	<	}
5254	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5255	<	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5256	<	if (!SWIG_IsOK(ecode2)) {
5257	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
5258	<	}
5259	<	arg2 = static_cast< ptrdiff_t >(val2);
5260	<	{
5261	<	try {
5262	<	try {
5263	<	result = (swig::PySwigIterator *)(arg1)->advance(arg2);
5264	<	}
5265	<	catch(swig::stop_iteration &_e) {
5266	<	{
5267	<	(void)_e;
5268	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5269	<	SWIG_fail;
1269	>	{
1270	>	try {
1271	>	result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1272	>
1273	>	}catch (const BossSchedFailure & e) {
1274	>	PyErr_SetString ( SchedulerError, e.what() );
1275	>	return NULL;
1276	>	}catch (const std::exception& e) {
1277	>	PyErr_SetString ( BossError, e.what() );
1278	>	return NULL;
1279		}
5271	–	}
5272	–
5273	–	} catch (const std::exception& e) {
5274	–	SWIG_exception(SWIG_RuntimeError, e.what());
5275	–	}
5276	–	}
5277	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5278	–	return resultobj;
5279	–	fail:
5280	–	return NULL;
5281	–	}
5282	–
5283	–
5284	–	SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285	–	PyObject *resultobj = 0;
5286	–	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5287	–	swig::PySwigIterator *arg2 = 0 ;
5288	–	bool result;
5289	–	void *argp1 = 0 ;
5290	–	int res1 = 0 ;
5291	–	void *argp2 = 0 ;
5292	–	int res2 = 0 ;
5293	–	PyObject * obj0 = 0 ;
5294	–	PyObject * obj1 = 0 ;
5295	–
5296	–	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
5297	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5298	–	if (!SWIG_IsOK(res1)) {
5299	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5300	–	}
5301	–	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5302	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5303	–	if (!SWIG_IsOK(res2)) {
5304	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5305	–	}
5306	–	if (!argp2) {
5307	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5308	–	}
5309	–	arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5310	–	{
5311	–	try {
5312	–	result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
5313	–	} catch (const std::exception& e) {
5314	–	SWIG_exception(SWIG_RuntimeError, e.what());
5315	–	}
5316	–	}
5317	–	resultobj = SWIG_From_bool(static_cast< bool >(result));
5318	–	return resultobj;
5319	–	fail:
5320	–	return NULL;
5321	–	}
5322	–
5323	–
5324	–	SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5325	–	PyObject *resultobj = 0;
5326	–	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5327	–	swig::PySwigIterator *arg2 = 0 ;
5328	–	bool result;
5329	–	void *argp1 = 0 ;
5330	–	int res1 = 0 ;
5331	–	void *argp2 = 0 ;
5332	–	int res2 = 0 ;
5333	–	PyObject * obj0 = 0 ;
5334	–	PyObject * obj1 = 0 ;
5335	–
5336	–	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
5337	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5338	–	if (!SWIG_IsOK(res1)) {
5339	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5340	–	}
5341	–	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5342	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5343	–	if (!SWIG_IsOK(res2)) {
5344	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5345	–	}
5346	–	if (!argp2) {
5347	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5348	–	}
5349	–	arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5350	–	{
5351	–	try {
5352	–	result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
5353	–	} catch (const std::exception& e) {
5354	–	SWIG_exception(SWIG_RuntimeError, e.what());
1280		}
1281	<	}
1282	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
1283	<	return resultobj;
1284	<	fail:
5360	<	return NULL;
1281	>	resultobj = PyInt_FromLong((long)result);
1282	>	return resultobj;
1283	>	fail:
1284	>	return NULL;
1285		}
1286
1287
1288	<	SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1289	<	PyObject *resultobj = 0;
1290	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1291	<	ptrdiff_t arg2 ;
1292	<	swig::PySwigIterator *result = 0 ;
1293	<	void *argp1 = 0 ;
1294	<	int res1 = 0 ;
1295	<	ptrdiff_t val2 ;
1296	<	int ecode2 = 0 ;
1297	<	PyObject * obj0 = 0 ;
1298	<	PyObject * obj1 = 0 ;
1299	<
1300	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
1301	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
1302	<	if (!SWIG_IsOK(res1)) {
1303	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1304	<	}
5381	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5382	<	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5383	<	if (!SWIG_IsOK(ecode2)) {
5384	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
5385	<	}
5386	<	arg2 = static_cast< ptrdiff_t >(val2);
5387	<	{
5388	<	try {
5389	<	try {
5390	<	{
5391	<	swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
5392	<	result = (swig::PySwigIterator *) &_result_ref;
5393	<	}
5394	<	}
5395	<	catch(swig::stop_iteration &_e) {
5396	<	{
5397	<	(void)_e;
5398	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5399	<	SWIG_fail;
1288	>	static PyObject *_wrap_objectMap_clear(PyObject *self, PyObject *args) {
1289	>	PyObject *resultobj;
1290	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1291	>	PyObject * obj0 = 0 ;
1292	>
1293	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_clear",&obj0)) goto fail;
1294	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1295	>	{
1296	>	try {
1297	>	(arg1)->clear();
1298	>
1299	>	}catch (const BossSchedFailure & e) {
1300	>	PyErr_SetString ( SchedulerError, e.what() );
1301	>	return NULL;
1302	>	}catch (const std::exception& e) {
1303	>	PyErr_SetString ( BossError, e.what() );
1304	>	return NULL;
1305		}
5401	–	}
5402	–
5403	–	} catch (const std::exception& e) {
5404	–	SWIG_exception(SWIG_RuntimeError, e.what());
1306		}
1307	<	}
1308	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
1309	<	return resultobj;
1310	<	fail:
5410	<	return NULL;
1307	>	Py_INCREF(Py_None); resultobj = Py_None;
1308	>	return resultobj;
1309	>	fail:
1310	>	return NULL;
1311		}
1312
1313
1314	<	SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1315	<	PyObject *resultobj = 0;
1316	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1317	<	ptrdiff_t arg2 ;
1318	<	swig::PySwigIterator *result = 0 ;
1319	<	void *argp1 = 0 ;
1320	<	int res1 = 0 ;
1321	<	ptrdiff_t val2 ;
1322	<	int ecode2 = 0 ;
1323	<	PyObject * obj0 = 0 ;
1324	<	PyObject * obj1 = 0 ;
1325	<
1326	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
1327	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
1328	<	if (!SWIG_IsOK(res1)) {
1329	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1330	<	}
1331	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5432	<	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5433	<	if (!SWIG_IsOK(ecode2)) {
5434	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5435	<	}
5436	<	arg2 = static_cast< ptrdiff_t >(val2);
5437	<	{
5438	<	try {
5439	<	try {
5440	<	{
5441	<	swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
5442	<	result = (swig::PySwigIterator *) &_result_ref;
5443	<	}
5444	<	}
5445	<	catch(swig::stop_iteration &_e) {
5446	<	{
5447	<	(void)_e;
5448	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5449	<	SWIG_fail;
1314	>	static PyObject *_wrap_objectMap___nonzero__(PyObject *self, PyObject *args) {
1315	>	PyObject *resultobj;
1316	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1317	>	bool result;
1318	>	PyObject * obj0 = 0 ;
1319	>
1320	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___nonzero__",&obj0)) goto fail;
1321	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1322	>	{
1323	>	try {
1324	>	result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1325	>
1326	>	}catch (const BossSchedFailure & e) {
1327	>	PyErr_SetString ( SchedulerError, e.what() );
1328	>	return NULL;
1329	>	}catch (const std::exception& e) {
1330	>	PyErr_SetString ( BossError, e.what() );
1331	>	return NULL;
1332		}
5451	–	}
5452	–
5453	–	} catch (const std::exception& e) {
5454	–	SWIG_exception(SWIG_RuntimeError, e.what());
1333		}
1334	<	}
1335	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
1336	<	return resultobj;
1337	<	fail:
5460	<	return NULL;
1334	>	resultobj = PyInt_FromLong((long)result);
1335	>	return resultobj;
1336	>	fail:
1337	>	return NULL;
1338		}
1339
1340
1341	<	SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1342	<	PyObject *resultobj = 0;
1343	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1344	<	ptrdiff_t arg2 ;
1345	<	swig::PySwigIterator *result = 0 ;
1346	<	void *argp1 = 0 ;
1347	<	int res1 = 0 ;
1348	<	ptrdiff_t val2 ;
1349	<	int ecode2 = 0 ;
1350	<	PyObject * obj0 = 0 ;
1351	<	PyObject * obj1 = 0 ;
1352	<
1353	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
1354	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1355	<	if (!SWIG_IsOK(res1)) {
5479	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5480	<	}
5481	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5482	<	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5483	<	if (!SWIG_IsOK(ecode2)) {
5484	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
5485	<	}
5486	<	arg2 = static_cast< ptrdiff_t >(val2);
5487	<	{
5488	<	try {
5489	<	try {
5490	<	result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
5491	<	}
5492	<	catch(swig::stop_iteration &_e) {
5493	<	{
5494	<	(void)_e;
5495	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5496	<	SWIG_fail;
5497	<	}
5498	<	}
5499	<
5500	<	} catch (const std::exception& e) {
5501	<	SWIG_exception(SWIG_RuntimeError, e.what());
1341	>	static PyObject *_wrap_objectMap___getitem__(PyObject *self, PyObject *args) {
1342	>	PyObject *resultobj;
1343	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1344	>	std::string arg2 ;
1345	>	std::string result;
1346	>	PyObject * obj0 = 0 ;
1347	>	PyObject * obj1 = 0 ;
1348	>
1349	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___getitem__",&obj0,&obj1)) goto fail;
1350	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1351	>	{
1352	>	if (PyString_Check(obj1))
1353	>	arg2 = std::string(PyString_AsString(obj1));
1354	>	else
1355	>	SWIG_exception(SWIG_TypeError, "string expected");
1356		}
1357	<	}
1358	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
1359	<	return resultobj;
1360	<	fail:
1361	<	return NULL;
1362	<	}
1363	<
5510	<
5511	<	SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5512	<	PyObject *resultobj = 0;
5513	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5514	<	ptrdiff_t arg2 ;
5515	<	swig::PySwigIterator *result = 0 ;
5516	<	void *argp1 = 0 ;
5517	<	int res1 = 0 ;
5518	<	ptrdiff_t val2 ;
5519	<	int ecode2 = 0 ;
5520	<	PyObject * obj0 = 0 ;
5521	<	PyObject * obj1 = 0 ;
5522	<
5523	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5524	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5525	<	if (!SWIG_IsOK(res1)) {
5526	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5527	<	}
5528	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5529	<	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
5530	<	if (!SWIG_IsOK(ecode2)) {
5531	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5532	<	}
5533	<	arg2 = static_cast< ptrdiff_t >(val2);
5534	<	{
5535	<	try {
5536	<	try {
5537	<	result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
5538	<	}
5539	<	catch(swig::stop_iteration &_e) {
5540	<	{
5541	<	(void)_e;
5542	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5543	<	SWIG_fail;
1357	>	{
1358	>	try {
1359	>	result = std_maplstd_stringcstd_string_g___getitem_____(arg1,arg2);
1360	>
1361	>	}catch (std::out_of_range& e) {
1362	>	PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
1363	>	SWIG_fail;
1364		}
5545	–	}
5546	–
5547	–	} catch (const std::exception& e) {
5548	–	SWIG_exception(SWIG_RuntimeError, e.what());
5549	–	}
5550	–	}
5551	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5552	–	return resultobj;
5553	–	fail:
5554	–	return NULL;
5555	–	}
5556	–
5557	–
5558	–	SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5559	–	PyObject *resultobj = 0;
5560	–	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5561	–	swig::PySwigIterator *arg2 = 0 ;
5562	–	ptrdiff_t result;
5563	–	void *argp1 = 0 ;
5564	–	int res1 = 0 ;
5565	–	void *argp2 = 0 ;
5566	–	int res2 = 0 ;
5567	–	PyObject * obj0 = 0 ;
5568	–	PyObject * obj1 = 0 ;
5569	–
5570	–	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5571	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5572	–	if (!SWIG_IsOK(res1)) {
5573	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5574	–	}
5575	–	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5576	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5577	–	if (!SWIG_IsOK(res2)) {
5578	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5579	–	}
5580	–	if (!argp2) {
5581	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5582	–	}
5583	–	arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5584	–	{
5585	–	try {
5586	–	result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
5587	–	} catch (const std::exception& e) {
5588	–	SWIG_exception(SWIG_RuntimeError, e.what());
5589	–	}
5590	–	}
5591	–	resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5592	–	return resultobj;
5593	–	fail:
5594	–	return NULL;
5595	–	}
5596	–
5597	–
5598	–	SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
5599	–	int argc;
5600	–	PyObject *argv[3];
5601	–	int ii;
5602	–
5603	–	if (!PyTuple_Check(args)) SWIG_fail;
5604	–	argc = PyObject_Length(args);
5605	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5606	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
5607	–	}
5608	–	if (argc == 2) {
5609	–	int _v;
5610	–	void *vptr = 0;
5611	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5612	–	_v = SWIG_CheckState(res);
5613	–	if (_v) {
5614	–	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
5615	–	_v = SWIG_CheckState(res);
5616	–	if (_v) {
5617	–	return _wrap_PySwigIterator___sub____SWIG_1(self, args);
5618	–	}
5619	–	}
5620	–	}
5621	–	if (argc == 2) {
5622	–	int _v;
5623	–	void *vptr = 0;
5624	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5625	–	_v = SWIG_CheckState(res);
5626	–	if (_v) {
5627	–	{
5628	–	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
5629	–	_v = SWIG_CheckState(res);
5630	–	}
5631	–	if (_v) {
5632	–	return _wrap_PySwigIterator___sub____SWIG_0(self, args);
5633	–	}
5634	–	}
5635	–	}
5636	–
5637	–	fail:
5638	–	Py_INCREF(Py_NotImplemented);
5639	–	return Py_NotImplemented;
5640	–	}
5641	–
5642	–
5643	–	SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5644	–	PyObject *obj;
5645	–	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
5646	–	SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
5647	–	return SWIG_Py_Void();
5648	–	}
5649	–
5650	–	SWIGINTERN PyObject *_wrap_objectMap_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5651	–	PyObject *resultobj = 0;
5652	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5653	–	PyObject **arg2 = (PyObject **) 0 ;
5654	–	swig::PySwigIterator *result = 0 ;
5655	–	void *argp1 = 0 ;
5656	–	int res1 = 0 ;
5657	–	PyObject * obj0 = 0 ;
5658	–
5659	–	arg2 = &obj0;
5660	–	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_iterator",&obj0)) SWIG_fail;
5661	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5662	–	if (!SWIG_IsOK(res1)) {
5663	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_iterator" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
5664	–	}
5665	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5666	–	{
5667	–	try {
5668	–	result = (swig::PySwigIterator *)std_map_Sl_std_string_Sc_std_string_Sg__iterator(arg1,arg2);
5669	–	} catch (const std::exception& e) {
5670	–	SWIG_exception(SWIG_RuntimeError, e.what());
5671	–	}
5672	–	}
5673	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5674	–	return resultobj;
5675	–	fail:
5676	–	return NULL;
5677	–	}
5678	–
5679	–
5680	–	SWIGINTERN PyObject *_wrap_objectMap___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5681	–	PyObject *resultobj = 0;
5682	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5683	–	bool result;
5684	–	void *argp1 = 0 ;
5685	–	int res1 = 0 ;
5686	–	PyObject * obj0 = 0 ;
5687	–
5688	–	if (!PyArg_ParseTuple(args,(char *)"O:objectMap___nonzero__",&obj0)) SWIG_fail;
5689	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5690	–	if (!SWIG_IsOK(res1)) {
5691	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___nonzero__" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
5692	–	}
5693	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5694	–	{
5695	–	try {
5696	–	result = (bool)std_map_Sl_std_string_Sc_std_string_Sg____nonzero__((std::map<std::string,std::string > const *)arg1);
5697	–	} catch (const std::exception& e) {
5698	–	SWIG_exception(SWIG_RuntimeError, e.what());
5699	–	}
5700	–	}
5701	–	resultobj = SWIG_From_bool(static_cast< bool >(result));
5702	–	return resultobj;
5703	–	fail:
5704	–	return NULL;
5705	–	}
5706	–
5707	–
5708	–	SWIGINTERN PyObject *_wrap_objectMap___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5709	–	PyObject *resultobj = 0;
5710	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5711	–	std::map<std::string,std::string >::size_type result;
5712	–	void *argp1 = 0 ;
5713	–	int res1 = 0 ;
5714	–	PyObject * obj0 = 0 ;
5715	–
5716	–	if (!PyArg_ParseTuple(args,(char *)"O:objectMap___len__",&obj0)) SWIG_fail;
5717	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5718	–	if (!SWIG_IsOK(res1)) {
5719	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___len__" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
5720	–	}
5721	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5722	–	{
5723	–	try {
5724	–	result = std_map_Sl_std_string_Sc_std_string_Sg____len__((std::map<std::string,std::string > const *)arg1);
5725	–	} catch (const std::exception& e) {
5726	–	SWIG_exception(SWIG_RuntimeError, e.what());
5727	–	}
5728	–	}
5729	–	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
5730	–	return resultobj;
5731	–	fail:
5732	–	return NULL;
5733	–	}
5734	–
5735	–
5736	–	SWIGINTERN PyObject *_wrap_objectMap___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5737	–	PyObject *resultobj = 0;
5738	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5739	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
5740	–	std::map<std::string,std::string >::mapped_type result;
5741	–	void *argp1 = 0 ;
5742	–	int res1 = 0 ;
5743	–	int res2 = SWIG_OLDOBJ ;
5744	–	PyObject * obj0 = 0 ;
5745	–	PyObject * obj1 = 0 ;
5746	–
5747	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap___getitem__",&obj0,&obj1)) SWIG_fail;
5748	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5749	–	if (!SWIG_IsOK(res1)) {
5750	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___getitem__" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
5751	–	}
5752	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5753	–	{
5754	–	std::string *ptr = (std::string *)0;
5755	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5756	–	if (!SWIG_IsOK(res2)) {
5757	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap___getitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5758	–	}
5759	–	if (!ptr) {
5760	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap___getitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5761	–	}
5762	–	arg2 = ptr;
5763	–	}
5764	–	{
5765	–	try {
5766	–	try {
5767	–	result = std_map_Sl_std_string_Sc_std_string_Sg____getitem__((std::map<std::string,std::string > const *)arg1,(std::string const &)*arg2);
5768	–	}
5769	–	catch(std::out_of_range &_e) {
5770	–	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5771	–	}
5772	–
5773	–	} catch (const std::exception& e) {
5774	–	SWIG_exception(SWIG_RuntimeError, e.what());
5775	–	}
5776	–	}
5777	–	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
5778	–	if (SWIG_IsNewObj(res2)) delete arg2;
5779	–	return resultobj;
5780	–	fail:
5781	–	if (SWIG_IsNewObj(res2)) delete arg2;
5782	–	return NULL;
5783	–	}
5784	–
5785	–
5786	–	SWIGINTERN PyObject *_wrap_objectMap___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5787	–	PyObject *resultobj = 0;
5788	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5789	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
5790	–	std::map<std::string,std::string >::mapped_type *arg3 = 0 ;
5791	–	void *argp1 = 0 ;
5792	–	int res1 = 0 ;
5793	–	int res2 = SWIG_OLDOBJ ;
5794	–	int res3 = SWIG_OLDOBJ ;
5795	–	PyObject * obj0 = 0 ;
5796	–	PyObject * obj1 = 0 ;
5797	–	PyObject * obj2 = 0 ;
5798	–
5799	–	if (!PyArg_ParseTuple(args,(char *)"OOO:objectMap___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
5800	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5801	–	if (!SWIG_IsOK(res1)) {
5802	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___setitem__" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
5803	–	}
5804	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5805	–	{
5806	–	std::string *ptr = (std::string *)0;
5807	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5808	–	if (!SWIG_IsOK(res2)) {
5809	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap___setitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5810	–	}
5811	–	if (!ptr) {
5812	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap___setitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5813	–	}
5814	–	arg2 = ptr;
5815	–	}
5816	–	{
5817	–	std::string *ptr = (std::string *)0;
5818	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
5819	–	if (!SWIG_IsOK(res3)) {
5820	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "objectMap___setitem__" "', argument " "3"" of type '" "std::map<std::string,std::string >::mapped_type const &""'");
5821	–	}
5822	–	if (!ptr) {
5823	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap___setitem__" "', argument " "3"" of type '" "std::map<std::string,std::string >::mapped_type const &""'");
5824	–	}
5825	–	arg3 = ptr;
5826	–	}
5827	–	{
5828	–	try {
5829	–	try {
5830	–	std_map_Sl_std_string_Sc_std_string_Sg____setitem__(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5831	–	}
5832	–	catch(std::out_of_range &_e) {
5833	–	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5834	–	}
5835	–
5836	–	} catch (const std::exception& e) {
5837	–	SWIG_exception(SWIG_RuntimeError, e.what());
5838	–	}
5839	–	}
5840	–	resultobj = SWIG_Py_Void();
5841	–	if (SWIG_IsNewObj(res2)) delete arg2;
5842	–	if (SWIG_IsNewObj(res3)) delete arg3;
5843	–	return resultobj;
5844	–	fail:
5845	–	if (SWIG_IsNewObj(res2)) delete arg2;
5846	–	if (SWIG_IsNewObj(res3)) delete arg3;
5847	–	return NULL;
5848	–	}
5849	–
5850	–
5851	–	SWIGINTERN PyObject *_wrap_objectMap___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5852	–	PyObject *resultobj = 0;
5853	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5854	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
5855	–	void *argp1 = 0 ;
5856	–	int res1 = 0 ;
5857	–	int res2 = SWIG_OLDOBJ ;
5858	–	PyObject * obj0 = 0 ;
5859	–	PyObject * obj1 = 0 ;
5860	–
5861	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap___delitem__",&obj0,&obj1)) SWIG_fail;
5862	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5863	–	if (!SWIG_IsOK(res1)) {
5864	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___delitem__" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
5865	–	}
5866	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5867	–	{
5868	–	std::string *ptr = (std::string *)0;
5869	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5870	–	if (!SWIG_IsOK(res2)) {
5871	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap___delitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
1365		}
1366	<	if (!ptr) {
1367	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap___delitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5875	<	}
5876	<	arg2 = ptr;
5877	<	}
5878	<	{
5879	<	try {
5880	<	try {
5881	<	std_map_Sl_std_string_Sc_std_string_Sg____delitem__(arg1,(std::string const &)*arg2);
5882	<	}
5883	<	catch(std::out_of_range &_e) {
5884	<	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5885	<	}
5886	<
5887	<	} catch (const std::exception& e) {
5888	<	SWIG_exception(SWIG_RuntimeError, e.what());
5889	<	}
5890	<	}
5891	<	resultobj = SWIG_Py_Void();
5892	<	if (SWIG_IsNewObj(res2)) delete arg2;
5893	<	return resultobj;
5894	<	fail:
5895	<	if (SWIG_IsNewObj(res2)) delete arg2;
5896	<	return NULL;
5897	<	}
5898	<
5899	<
5900	<	SWIGINTERN PyObject *_wrap_objectMap_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5901	<	PyObject *resultobj = 0;
5902	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5903	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
5904	<	bool result;
5905	<	void *argp1 = 0 ;
5906	<	int res1 = 0 ;
5907	<	int res2 = SWIG_OLDOBJ ;
5908	<	PyObject * obj0 = 0 ;
5909	<	PyObject * obj1 = 0 ;
5910	<
5911	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_has_key",&obj0,&obj1)) SWIG_fail;
5912	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5913	<	if (!SWIG_IsOK(res1)) {
5914	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_has_key" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
5915	<	}
5916	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5917	<	{
5918	<	std::string *ptr = (std::string *)0;
5919	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5920	<	if (!SWIG_IsOK(res2)) {
5921	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_has_key" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5922	<	}
5923	<	if (!ptr) {
5924	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_has_key" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5925	<	}
5926	<	arg2 = ptr;
5927	<	}
5928	<	{
5929	<	try {
5930	<	result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__has_key((std::map<std::string,std::string > const *)arg1,(std::string const &)*arg2);
5931	<	} catch (const std::exception& e) {
5932	<	SWIG_exception(SWIG_RuntimeError, e.what());
5933	<	}
5934	<	}
5935	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
5936	<	if (SWIG_IsNewObj(res2)) delete arg2;
5937	<	return resultobj;
5938	<	fail:
5939	<	if (SWIG_IsNewObj(res2)) delete arg2;
5940	<	return NULL;
5941	<	}
5942	<
5943	<
5944	<	SWIGINTERN PyObject *_wrap_objectMap_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5945	<	PyObject *resultobj = 0;
5946	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5947	<	PyObject *result = 0 ;
5948	<	void *argp1 = 0 ;
5949	<	int res1 = 0 ;
5950	<	PyObject * obj0 = 0 ;
5951	<
5952	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_keys",&obj0)) SWIG_fail;
5953	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5954	<	if (!SWIG_IsOK(res1)) {
5955	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_keys" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
5956	<	}
5957	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5958	<	{
5959	<	try {
5960	<	result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__keys(arg1);
5961	<	} catch (const std::exception& e) {
5962	<	SWIG_exception(SWIG_RuntimeError, e.what());
5963	<	}
5964	<	}
5965	<	resultobj = result;
5966	<	return resultobj;
5967	<	fail:
5968	<	return NULL;
5969	<	}
5970	<
5971	<
5972	<	SWIGINTERN PyObject *_wrap_objectMap_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5973	<	PyObject *resultobj = 0;
5974	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5975	<	PyObject *result = 0 ;
5976	<	void *argp1 = 0 ;
5977	<	int res1 = 0 ;
5978	<	PyObject * obj0 = 0 ;
5979	<
5980	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_values",&obj0)) SWIG_fail;
5981	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5982	<	if (!SWIG_IsOK(res1)) {
5983	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_values" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
5984	<	}
5985	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5986	<	{
5987	<	try {
5988	<	result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__values(arg1);
5989	<	} catch (const std::exception& e) {
5990	<	SWIG_exception(SWIG_RuntimeError, e.what());
5991	<	}
5992	<	}
5993	<	resultobj = result;
5994	<	return resultobj;
5995	<	fail:
5996	<	return NULL;
5997	<	}
5998	<
5999	<
6000	<	SWIGINTERN PyObject *_wrap_objectMap_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6001	<	PyObject *resultobj = 0;
6002	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6003	<	PyObject *result = 0 ;
6004	<	void *argp1 = 0 ;
6005	<	int res1 = 0 ;
6006	<	PyObject * obj0 = 0 ;
6007	<
6008	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_items",&obj0)) SWIG_fail;
6009	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6010	<	if (!SWIG_IsOK(res1)) {
6011	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_items" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6012	<	}
6013	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6014	<	{
6015	<	try {
6016	<	result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__items(arg1);
6017	<	} catch (const std::exception& e) {
6018	<	SWIG_exception(SWIG_RuntimeError, e.what());
6019	<	}
6020	<	}
6021	<	resultobj = result;
6022	<	return resultobj;
6023	<	fail:
6024	<	return NULL;
6025	<	}
6026	<
6027	<
6028	<	SWIGINTERN PyObject *_wrap_objectMap___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6029	<	PyObject *resultobj = 0;
6030	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6031	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
6032	<	bool result;
6033	<	void *argp1 = 0 ;
6034	<	int res1 = 0 ;
6035	<	int res2 = SWIG_OLDOBJ ;
6036	<	PyObject * obj0 = 0 ;
6037	<	PyObject * obj1 = 0 ;
6038	<
6039	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap___contains__",&obj0,&obj1)) SWIG_fail;
6040	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6041	<	if (!SWIG_IsOK(res1)) {
6042	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___contains__" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6043	<	}
6044	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6045	<	{
6046	<	std::string *ptr = (std::string *)0;
6047	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
6048	<	if (!SWIG_IsOK(res2)) {
6049	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap___contains__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
6050	<	}
6051	<	if (!ptr) {
6052	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap___contains__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
6053	<	}
6054	<	arg2 = ptr;
6055	<	}
6056	<	{
6057	<	try {
6058	<	result = (bool)std_map_Sl_std_string_Sc_std_string_Sg____contains__(arg1,(std::string const &)*arg2);
6059	<	} catch (const std::exception& e) {
6060	<	SWIG_exception(SWIG_RuntimeError, e.what());
6061	<	}
6062	<	}
6063	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
6064	<	if (SWIG_IsNewObj(res2)) delete arg2;
6065	<	return resultobj;
6066	<	fail:
6067	<	if (SWIG_IsNewObj(res2)) delete arg2;
6068	<	return NULL;
6069	<	}
6070	<
6071	<
6072	<	SWIGINTERN PyObject *_wrap_objectMap_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6073	<	PyObject *resultobj = 0;
6074	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6075	<	PyObject **arg2 = (PyObject **) 0 ;
6076	<	swig::PySwigIterator *result = 0 ;
6077	<	void *argp1 = 0 ;
6078	<	int res1 = 0 ;
6079	<	PyObject * obj0 = 0 ;
6080	<
6081	<	arg2 = &obj0;
6082	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_key_iterator",&obj0)) SWIG_fail;
6083	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6084	<	if (!SWIG_IsOK(res1)) {
6085	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_key_iterator" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6086	<	}
6087	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6088	<	{
6089	<	try {
6090	<	result = (swig::PySwigIterator *)std_map_Sl_std_string_Sc_std_string_Sg__key_iterator(arg1,arg2);
6091	<	} catch (const std::exception& e) {
6092	<	SWIG_exception(SWIG_RuntimeError, e.what());
6093	<	}
6094	<	}
6095	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
6096	<	return resultobj;
6097	<	fail:
6098	<	return NULL;
6099	<	}
6100	<
6101	<
6102	<	SWIGINTERN PyObject *_wrap_objectMap_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6103	<	PyObject *resultobj = 0;
6104	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6105	<	PyObject **arg2 = (PyObject **) 0 ;
6106	<	swig::PySwigIterator *result = 0 ;
6107	<	void *argp1 = 0 ;
6108	<	int res1 = 0 ;
6109	<	PyObject * obj0 = 0 ;
6110	<
6111	<	arg2 = &obj0;
6112	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_value_iterator",&obj0)) SWIG_fail;
6113	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6114	<	if (!SWIG_IsOK(res1)) {
6115	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_value_iterator" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6116	<	}
6117	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6118	<	{
6119	<	try {
6120	<	result = (swig::PySwigIterator *)std_map_Sl_std_string_Sc_std_string_Sg__value_iterator(arg1,arg2);
6121	<	} catch (const std::exception& e) {
6122	<	SWIG_exception(SWIG_RuntimeError, e.what());
6123	<	}
6124	<	}
6125	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
6126	<	return resultobj;
6127	<	fail:
6128	<	return NULL;
6129	<	}
6130	<
6131	<
6132	<	SWIGINTERN PyObject *_wrap_new_objectMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6133	<	PyObject *resultobj = 0;
6134	<	std::map<std::string,std::string > *result = 0 ;
6135	<
6136	<	if (!PyArg_ParseTuple(args,(char *)":new_objectMap")) SWIG_fail;
6137	<	{
6138	<	try {
6139	<	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
6140	<	} catch (const std::exception& e) {
6141	<	SWIG_exception(SWIG_RuntimeError, e.what());
6142	<	}
6143	<	}
6144	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, SWIG_POINTER_NEW |  0 );
6145	<	return resultobj;
6146	<	fail:
6147	<	return NULL;
6148	<	}
6149	<
6150	<
6151	<	SWIGINTERN PyObject *_wrap_new_objectMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6152	<	PyObject *resultobj = 0;
6153	<	std::map<std::string,std::string > *arg1 = 0 ;
6154	<	std::map<std::string,std::string > *result = 0 ;
6155	<	int res1 = SWIG_OLDOBJ ;
6156	<	PyObject * obj0 = 0 ;
6157	<
6158	<	if (!PyArg_ParseTuple(args,(char *)"O:new_objectMap",&obj0)) SWIG_fail;
6159	<	{
6160	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > *ptr = (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > *)0;
6161	<	res1 = swig::asptr(obj0, &ptr);
6162	<	if (!SWIG_IsOK(res1)) {
6163	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_objectMap" "', argument " "1"" of type '" "std::map<std::string,std::string > const &""'");
6164	<	}
6165	<	if (!ptr) {
6166	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_objectMap" "', argument " "1"" of type '" "std::map<std::string,std::string > const &""'");
6167	<	}
6168	<	arg1 = ptr;
6169	<	}
6170	<	{
6171	<	try {
6172	<	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
6173	<	} catch (const std::exception& e) {
6174	<	SWIG_exception(SWIG_RuntimeError, e.what());
6175	<	}
6176	<	}
6177	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, SWIG_POINTER_NEW |  0 );
6178	<	if (SWIG_IsNewObj(res1)) delete arg1;
6179	<	return resultobj;
6180	<	fail:
6181	<	if (SWIG_IsNewObj(res1)) delete arg1;
6182	<	return NULL;
6183	<	}
6184	<
6185	<
6186	<	SWIGINTERN PyObject *_wrap_new_objectMap(PyObject *self, PyObject *args) {
6187	<	int argc;
6188	<	PyObject *argv[2];
6189	<	int ii;
6190	<
6191	<	if (!PyTuple_Check(args)) SWIG_fail;
6192	<	argc = PyObject_Length(args);
6193	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6194	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
6195	<	}
6196	<	if (argc == 0) {
6197	<	return _wrap_new_objectMap__SWIG_0(self, args);
6198	<	}
6199	<	if (argc == 1) {
6200	<	int _v;
6201	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
6202	<	_v = SWIG_CheckState(res);
6203	<	if (_v) {
6204	<	return _wrap_new_objectMap__SWIG_1(self, args);
6205	<	}
6206	<	}
6207	<
6208	<	fail:
6209	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_objectMap'");
6210	<	return NULL;
6211	<	}
6212	<
6213	<
6214	<	SWIGINTERN PyObject *_wrap_objectMap_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6215	<	PyObject *resultobj = 0;
6216	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6217	<	bool result;
6218	<	void *argp1 = 0 ;
6219	<	int res1 = 0 ;
6220	<	PyObject * obj0 = 0 ;
6221	<
6222	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_empty",&obj0)) SWIG_fail;
6223	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6224	<	if (!SWIG_IsOK(res1)) {
6225	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_empty" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6226	<	}
6227	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6228	<	{
6229	<	try {
6230	<	result = (bool)((std::map<std::string,std::string > const *)arg1)->empty();
6231	<	} catch (const std::exception& e) {
6232	<	SWIG_exception(SWIG_RuntimeError, e.what());
6233	<	}
6234	<	}
6235	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
6236	<	return resultobj;
6237	<	fail:
6238	<	return NULL;
6239	<	}
6240	<
6241	<
6242	<	SWIGINTERN PyObject *_wrap_objectMap_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6243	<	PyObject *resultobj = 0;
6244	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6245	<	std::map<std::string,std::string >::size_type result;
6246	<	void *argp1 = 0 ;
6247	<	int res1 = 0 ;
6248	<	PyObject * obj0 = 0 ;
6249	<
6250	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_size",&obj0)) SWIG_fail;
6251	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6252	<	if (!SWIG_IsOK(res1)) {
6253	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_size" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6254	<	}
6255	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6256	<	{
6257	<	try {
6258	<	result = ((std::map<std::string,std::string > const *)arg1)->size();
6259	<	} catch (const std::exception& e) {
6260	<	SWIG_exception(SWIG_RuntimeError, e.what());
6261	<	}
6262	<	}
6263	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6264	<	return resultobj;
6265	<	fail:
6266	<	return NULL;
6267	<	}
6268	<
6269	<
6270	<	SWIGINTERN PyObject *_wrap_objectMap_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6271	<	PyObject *resultobj = 0;
6272	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6273	<	void *argp1 = 0 ;
6274	<	int res1 = 0 ;
6275	<	PyObject * obj0 = 0 ;
6276	<
6277	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_clear",&obj0)) SWIG_fail;
6278	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6279	<	if (!SWIG_IsOK(res1)) {
6280	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_clear" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6281	<	}
6282	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6283	<	{
6284	<	try {
6285	<	(arg1)->clear();
6286	<	} catch (const std::exception& e) {
6287	<	SWIG_exception(SWIG_RuntimeError, e.what());
6288	<	}
6289	<	}
6290	<	resultobj = SWIG_Py_Void();
6291	<	return resultobj;
6292	<	fail:
6293	<	return NULL;
6294	<	}
6295	<
6296	<
6297	<	SWIGINTERN PyObject *_wrap_objectMap_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6298	<	PyObject *resultobj = 0;
6299	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6300	<	std::map<std::string,std::string > *arg2 = 0 ;
6301	<	void *argp1 = 0 ;
6302	<	int res1 = 0 ;
6303	<	void *argp2 = 0 ;
6304	<	int res2 = 0 ;
6305	<	PyObject * obj0 = 0 ;
6306	<	PyObject * obj1 = 0 ;
6307	<
6308	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_swap",&obj0,&obj1)) SWIG_fail;
6309	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6310	<	if (!SWIG_IsOK(res1)) {
6311	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_swap" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6312	<	}
6313	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6314	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t,  0 );
6315	<	if (!SWIG_IsOK(res2)) {
6316	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_swap" "', argument " "2"" of type '" "std::map<std::string,std::string > &""'");
6317	<	}
6318	<	if (!argp2) {
6319	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_swap" "', argument " "2"" of type '" "std::map<std::string,std::string > &""'");
6320	<	}
6321	<	arg2 = reinterpret_cast< std::map<std::string,std::string > * >(argp2);
6322	<	{
6323	<	try {
6324	<	(arg1)->swap(*arg2);
6325	<	} catch (const std::exception& e) {
6326	<	SWIG_exception(SWIG_RuntimeError, e.what());
6327	<	}
6328	<	}
6329	<	resultobj = SWIG_Py_Void();
6330	<	return resultobj;
6331	<	fail:
6332	<	return NULL;
6333	<	}
6334	<
6335	<
6336	<	SWIGINTERN PyObject *_wrap_objectMap_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6337	<	PyObject *resultobj = 0;
6338	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6339	<	SwigValueWrapper<std::allocator<std::pair<std::string const,std::string > > > result;
6340	<	void *argp1 = 0 ;
6341	<	int res1 = 0 ;
6342	<	PyObject * obj0 = 0 ;
6343	<
6344	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_get_allocator",&obj0)) SWIG_fail;
6345	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6346	<	if (!SWIG_IsOK(res1)) {
6347	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_get_allocator" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6348	<	}
6349	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6350	<	{
6351	<	try {
6352	<	result = ((std::map<std::string,std::string > const *)arg1)->get_allocator();
6353	<	} catch (const std::exception& e) {
6354	<	SWIG_exception(SWIG_RuntimeError, e.what());
6355	<	}
6356	<	}
6357	<	resultobj = SWIG_NewPointerObj((new std::map<std::string,std::string >::allocator_type(static_cast< const std::map<std::string,std::string >::allocator_type& >(result))), SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
6358	<	return resultobj;
6359	<	fail:
6360	<	return NULL;
6361	<	}
6362	<
6363	<
6364	<	SWIGINTERN PyObject *_wrap_objectMap_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6365	<	PyObject *resultobj = 0;
6366	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6367	<	std::map<std::string,std::string >::iterator result;
6368	<	void *argp1 = 0 ;
6369	<	int res1 = 0 ;
6370	<	PyObject * obj0 = 0 ;
6371	<
6372	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_begin",&obj0)) SWIG_fail;
6373	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6374	<	if (!SWIG_IsOK(res1)) {
6375	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_begin" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6376	<	}
6377	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6378	<	{
6379	<	try {
6380	<	result = (arg1)->begin();
6381	<	} catch (const std::exception& e) {
6382	<	SWIG_exception(SWIG_RuntimeError, e.what());
1366	>	{
1367	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1368		}
1369	<	}
1370	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
1371	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6387	<	return resultobj;
6388	<	fail:
6389	<	return NULL;
1369	>	return resultobj;
1370	>	fail:
1371	>	return NULL;
1372		}
1373
1374
1375	<	SWIGINTERN PyObject *_wrap_objectMap_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1376	<	PyObject *resultobj = 0;
1377	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1378	<	std::map<std::string,std::string >::const_iterator result;
1379	<	void *argp1 = 0 ;
1380	<	int res1 = 0 ;
1381	<	PyObject * obj0 = 0 ;
1382	<
1383	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_begin",&obj0)) SWIG_fail;
1384	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
1385	<	if (!SWIG_IsOK(res1)) {
1386	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_begin" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
1387	<	}
1388	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1389	<	{
1390	<	try {
6409	<	result = ((std::map<std::string,std::string > const *)arg1)->begin();
6410	<	} catch (const std::exception& e) {
6411	<	SWIG_exception(SWIG_RuntimeError, e.what());
1375	>	static PyObject *_wrap_objectMap___setitem__(PyObject *self, PyObject *args) {
1376	>	PyObject *resultobj;
1377	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1378	>	std::string arg2 ;
1379	>	std::string arg3 ;
1380	>	PyObject * obj0 = 0 ;
1381	>	PyObject * obj1 = 0 ;
1382	>	PyObject * obj2 = 0 ;
1383	>
1384	>	if(!PyArg_ParseTuple(args,(char *)"OOO:objectMap___setitem__",&obj0,&obj1,&obj2)) goto fail;
1385	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1386	>	{
1387	>	if (PyString_Check(obj1))
1388	>	arg2 = std::string(PyString_AsString(obj1));
1389	>	else
1390	>	SWIG_exception(SWIG_TypeError, "string expected");
1391		}
1392	<	}
1393	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
1394	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1395	<	return resultobj;
1396	<	fail:
6418	<	return NULL;
6419	<	}
6420	<
6421	<
6422	<	SWIGINTERN PyObject *_wrap_objectMap_begin(PyObject *self, PyObject *args) {
6423	<	int argc;
6424	<	PyObject *argv[2];
6425	<	int ii;
6426	<
6427	<	if (!PyTuple_Check(args)) SWIG_fail;
6428	<	argc = PyObject_Length(args);
6429	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6430	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
6431	<	}
6432	<	if (argc == 1) {
6433	<	int _v;
6434	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
6435	<	_v = SWIG_CheckState(res);
6436	<	if (_v) {
6437	<	return _wrap_objectMap_begin__SWIG_0(self, args);
1392	>	{
1393	>	if (PyString_Check(obj2))
1394	>	arg3 = std::string(PyString_AsString(obj2));
1395	>	else
1396	>	SWIG_exception(SWIG_TypeError, "string expected");
1397		}
1398	<	}
1399	<	if (argc == 1) {
1400	<	int _v;
1401	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
1402	<	_v = SWIG_CheckState(res);
1403	<	if (_v) {
1404	<	return _wrap_objectMap_begin__SWIG_1(self, args);
1398	>	{
1399	>	try {
1400	>	std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1401	>
1402	>	}catch (const BossSchedFailure & e) {
1403	>	PyErr_SetString ( SchedulerError, e.what() );
1404	>	return NULL;
1405	>	}catch (const std::exception& e) {
1406	>	PyErr_SetString ( BossError, e.what() );
1407	>	return NULL;
1408	>	}
1409		}
1410	<	}
1411	<
1412	<	fail:
1413	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_begin'");
6451	<	return NULL;
1410	>	Py_INCREF(Py_None); resultobj = Py_None;
1411	>	return resultobj;
1412	>	fail:
1413	>	return NULL;
1414		}
1415
1416
1417	<	SWIGINTERN PyObject *_wrap_objectMap_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1418	<	PyObject *resultobj = 0;
1419	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1420	<	std::map<std::string,std::string >::iterator result;
1421	<	void *argp1 = 0 ;
1422	<	int res1 = 0 ;
1423	<	PyObject * obj0 = 0 ;
1424	<
1425	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_end",&obj0)) SWIG_fail;
1426	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
1427	<	if (!SWIG_IsOK(res1)) {
1428	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_end" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1429	<	}
1430	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6469	<	{
6470	<	try {
6471	<	result = (arg1)->end();
6472	<	} catch (const std::exception& e) {
6473	<	SWIG_exception(SWIG_RuntimeError, e.what());
1417	>	static PyObject *_wrap_objectMap___delitem__(PyObject *self, PyObject *args) {
1418	>	PyObject *resultobj;
1419	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1420	>	std::string arg2 ;
1421	>	PyObject * obj0 = 0 ;
1422	>	PyObject * obj1 = 0 ;
1423	>
1424	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___delitem__",&obj0,&obj1)) goto fail;
1425	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1426	>	{
1427	>	if (PyString_Check(obj1))
1428	>	arg2 = std::string(PyString_AsString(obj1));
1429	>	else
1430	>	SWIG_exception(SWIG_TypeError, "string expected");
1431		}
1432	<	}
1433	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
1434	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1435	<	return resultobj;
1436	<	fail:
1437	<	return NULL;
1438	<	}
1439	<
6483	<
6484	<	SWIGINTERN PyObject *_wrap_objectMap_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6485	<	PyObject *resultobj = 0;
6486	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6487	<	std::map<std::string,std::string >::const_iterator result;
6488	<	void *argp1 = 0 ;
6489	<	int res1 = 0 ;
6490	<	PyObject * obj0 = 0 ;
6491	<
6492	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_end",&obj0)) SWIG_fail;
6493	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6494	<	if (!SWIG_IsOK(res1)) {
6495	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_end" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6496	<	}
6497	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6498	<	{
6499	<	try {
6500	<	result = ((std::map<std::string,std::string > const *)arg1)->end();
6501	<	} catch (const std::exception& e) {
6502	<	SWIG_exception(SWIG_RuntimeError, e.what());
1432	>	{
1433	>	try {
1434	>	std_maplstd_stringcstd_string_g___delitem_____(arg1,arg2);
1435	>
1436	>	}catch (std::out_of_range& e) {
1437	>	PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
1438	>	SWIG_fail;
1439	>	}
1440		}
1441	<	}
1442	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
1443	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1444	<	return resultobj;
6508	<	fail:
6509	<	return NULL;
1441	>	Py_INCREF(Py_None); resultobj = Py_None;
1442	>	return resultobj;
1443	>	fail:
1444	>	return NULL;
1445		}
1446
1447
1448	<	SWIGINTERN PyObject *_wrap_objectMap_end(PyObject *self, PyObject *args) {
1449	<	int argc;
1450	<	PyObject *argv[2];
1451	<	int ii;
1452	<
1453	<	if (!PyTuple_Check(args)) SWIG_fail;
1454	<	argc = PyObject_Length(args);
1455	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1456	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1457	<	}
1458	<	if (argc == 1) {
1459	<	int _v;
1460	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
1461	<	_v = SWIG_CheckState(res);
1462	<	if (_v) {
6528	<	return _wrap_objectMap_end__SWIG_0(self, args);
1448	>	static PyObject *_wrap_objectMap_has_key(PyObject *self, PyObject *args) {
1449	>	PyObject *resultobj;
1450	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1451	>	std::string arg2 ;
1452	>	bool result;
1453	>	PyObject * obj0 = 0 ;
1454	>	PyObject * obj1 = 0 ;
1455	>
1456	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap_has_key",&obj0,&obj1)) goto fail;
1457	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1458	>	{
1459	>	if (PyString_Check(obj1))
1460	>	arg2 = std::string(PyString_AsString(obj1));
1461	>	else
1462	>	SWIG_exception(SWIG_TypeError, "string expected");
1463		}
1464	<	}
1465	<	if (argc == 1) {
1466	<	int _v;
1467	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
1468	<	_v = SWIG_CheckState(res);
1469	<	if (_v) {
1470	<	return _wrap_objectMap_end__SWIG_1(self, args);
1464	>	{
1465	>	try {
1466	>	result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1467	>
1468	>	}catch (const BossSchedFailure & e) {
1469	>	PyErr_SetString ( SchedulerError, e.what() );
1470	>	return NULL;
1471	>	}catch (const std::exception& e) {
1472	>	PyErr_SetString ( BossError, e.what() );
1473	>	return NULL;
1474	>	}
1475		}
1476	<	}
1477	<
1478	<	fail:
1479	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_end'");
6542	<	return NULL;
1476	>	resultobj = PyInt_FromLong((long)result);
1477	>	return resultobj;
1478	>	fail:
1479	>	return NULL;
1480		}
1481
1482
1483	<	SWIGINTERN PyObject *_wrap_objectMap_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1484	<	PyObject *resultobj = 0;
1485	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1486	<	std::map<std::string,std::string >::reverse_iterator result;
1487	<	void *argp1 = 0 ;
1488	<	int res1 = 0 ;
1489	<	PyObject * obj0 = 0 ;
1490	<
1491	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rbegin",&obj0)) SWIG_fail;
1492	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
1493	<	if (!SWIG_IsOK(res1)) {
1494	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rbegin" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1495	<	}
1496	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1497	<	{
1498	<	try {
1499	<	result = (arg1)->rbegin();
1500	<	} catch (const std::exception& e) {
1501	<	SWIG_exception(SWIG_RuntimeError, e.what());
1483	>	static PyObject *_wrap_objectMap_keys(PyObject *self, PyObject *args) {
1484	>	PyObject *resultobj;
1485	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1486	>	PyObject *result;
1487	>	PyObject * obj0 = 0 ;
1488	>
1489	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_keys",&obj0)) goto fail;
1490	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1491	>	{
1492	>	try {
1493	>	result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1494	>
1495	>	}catch (const BossSchedFailure & e) {
1496	>	PyErr_SetString ( SchedulerError, e.what() );
1497	>	return NULL;
1498	>	}catch (const std::exception& e) {
1499	>	PyErr_SetString ( BossError, e.what() );
1500	>	return NULL;
1501	>	}
1502		}
1503	<	}
1504	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::reverse_iterator & >(result)),
1505	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1506	<	return resultobj;
6570	<	fail:
6571	<	return NULL;
1503	>	resultobj = result;
1504	>	return resultobj;
1505	>	fail:
1506	>	return NULL;
1507		}
1508
1509
1510	<	SWIGINTERN PyObject *_wrap_objectMap_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1511	<	PyObject *resultobj = 0;
1512	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1513	<	std::map<std::string,std::string >::const_reverse_iterator result;
1514	<	void *argp1 = 0 ;
1515	<	int res1 = 0 ;
1516	<	PyObject * obj0 = 0 ;
1517	<
1518	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rbegin",&obj0)) SWIG_fail;
1519	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
1520	<	if (!SWIG_IsOK(res1)) {
1521	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rbegin" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
1522	<	}
1523	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1524	<	{
1525	<	try {
1526	<	result = ((std::map<std::string,std::string > const *)arg1)->rbegin();
1527	<	} catch (const std::exception& e) {
1528	<	SWIG_exception(SWIG_RuntimeError, e.what());
1510	>	static PyObject *_wrap_objectMap_values(PyObject *self, PyObject *args) {
1511	>	PyObject *resultobj;
1512	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1513	>	PyObject *result;
1514	>	PyObject * obj0 = 0 ;
1515	>
1516	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_values",&obj0)) goto fail;
1517	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1518	>	{
1519	>	try {
1520	>	result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1521	>
1522	>	}catch (const BossSchedFailure & e) {
1523	>	PyErr_SetString ( SchedulerError, e.what() );
1524	>	return NULL;
1525	>	}catch (const std::exception& e) {
1526	>	PyErr_SetString ( BossError, e.what() );
1527	>	return NULL;
1528	>	}
1529		}
1530	<	}
1531	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_reverse_iterator & >(result)),
1532	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1533	<	return resultobj;
6599	<	fail:
6600	<	return NULL;
1530	>	resultobj = result;
1531	>	return resultobj;
1532	>	fail:
1533	>	return NULL;
1534		}
1535
1536
1537	<	SWIGINTERN PyObject *_wrap_objectMap_rbegin(PyObject *self, PyObject *args) {
1538	<	int argc;
1539	<	PyObject *argv[2];
1540	<	int ii;
1541	<
1542	<	if (!PyTuple_Check(args)) SWIG_fail;
1543	<	argc = PyObject_Length(args);
1544	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1545	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1546	<	}
1547	<	if (argc == 1) {
1548	<	int _v;
1549	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
1550	<	_v = SWIG_CheckState(res);
1551	<	if (_v) {
1552	<	return _wrap_objectMap_rbegin__SWIG_0(self, args);
1553	<	}
1554	<	}
1555	<	if (argc == 1) {
6623	<	int _v;
6624	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
6625	<	_v = SWIG_CheckState(res);
6626	<	if (_v) {
6627	<	return _wrap_objectMap_rbegin__SWIG_1(self, args);
1537	>	static PyObject *_wrap_objectMap_items(PyObject *self, PyObject *args) {
1538	>	PyObject *resultobj;
1539	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1540	>	PyObject *result;
1541	>	PyObject * obj0 = 0 ;
1542	>
1543	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_items",&obj0)) goto fail;
1544	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1545	>	{
1546	>	try {
1547	>	result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1548	>
1549	>	}catch (const BossSchedFailure & e) {
1550	>	PyErr_SetString ( SchedulerError, e.what() );
1551	>	return NULL;
1552	>	}catch (const std::exception& e) {
1553	>	PyErr_SetString ( BossError, e.what() );
1554	>	return NULL;
1555	>	}
1556		}
1557	<	}
1558	<
1559	<	fail:
1560	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_rbegin'");
6633	<	return NULL;
1557	>	resultobj = result;
1558	>	return resultobj;
1559	>	fail:
1560	>	return NULL;
1561		}
1562
1563
1564	<	SWIGINTERN PyObject *_wrap_objectMap_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1565	<	PyObject *resultobj = 0;
1566	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1567	<	std::map<std::string,std::string >::reverse_iterator result;
1568	<	void *argp1 = 0 ;
1569	<	int res1 = 0 ;
1570	<	PyObject * obj0 = 0 ;
1571	<
1572	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rend",&obj0)) SWIG_fail;
1573	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
1574	<	if (!SWIG_IsOK(res1)) {
1575	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rend" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1576	<	}
1577	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1578	<	{
6652	<	try {
6653	<	result = (arg1)->rend();
6654	<	} catch (const std::exception& e) {
6655	<	SWIG_exception(SWIG_RuntimeError, e.what());
1564	>	static PyObject *_wrap_objectMap___contains__(PyObject *self, PyObject *args) {
1565	>	PyObject *resultobj;
1566	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1567	>	std::string arg2 ;
1568	>	bool result;
1569	>	PyObject * obj0 = 0 ;
1570	>	PyObject * obj1 = 0 ;
1571	>
1572	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___contains__",&obj0,&obj1)) goto fail;
1573	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1574	>	{
1575	>	if (PyString_Check(obj1))
1576	>	arg2 = std::string(PyString_AsString(obj1));
1577	>	else
1578	>	SWIG_exception(SWIG_TypeError, "string expected");
1579		}
1580	<	}
1581	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::reverse_iterator & >(result)),
1582	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1583	<	return resultobj;
1584	<	fail:
1585	<	return NULL;
1586	<	}
1587	<
1588	<
1589	<	SWIGINTERN PyObject *_wrap_objectMap_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1590	<	PyObject *resultobj = 0;
6668	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6669	<	std::map<std::string,std::string >::const_reverse_iterator result;
6670	<	void *argp1 = 0 ;
6671	<	int res1 = 0 ;
6672	<	PyObject * obj0 = 0 ;
6673	<
6674	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rend",&obj0)) SWIG_fail;
6675	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6676	<	if (!SWIG_IsOK(res1)) {
6677	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rend" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6678	<	}
6679	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6680	<	{
6681	<	try {
6682	<	result = ((std::map<std::string,std::string > const *)arg1)->rend();
6683	<	} catch (const std::exception& e) {
6684	<	SWIG_exception(SWIG_RuntimeError, e.what());
1580	>	{
1581	>	try {
1582	>	result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1583	>
1584	>	}catch (const BossSchedFailure & e) {
1585	>	PyErr_SetString ( SchedulerError, e.what() );
1586	>	return NULL;
1587	>	}catch (const std::exception& e) {
1588	>	PyErr_SetString ( BossError, e.what() );
1589	>	return NULL;
1590	>	}
1591		}
1592	<	}
1593	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_reverse_iterator & >(result)),
1594	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1595	<	return resultobj;
6690	<	fail:
6691	<	return NULL;
1592	>	resultobj = PyInt_FromLong((long)result);
1593	>	return resultobj;
1594	>	fail:
1595	>	return NULL;
1596		}
1597
1598
1599	<	SWIGINTERN PyObject *_wrap_objectMap_rend(PyObject *self, PyObject *args) {
1600	<	int argc;
1601	<	PyObject *argv[2];
1602	<	int ii;
1603	<
1604	<	if (!PyTuple_Check(args)) SWIG_fail;
1605	<	argc = PyObject_Length(args);
1606	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1607	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1608	<	}
1609	<	if (argc == 1) {
1610	<	int _v;
1611	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
1612	<	_v = SWIG_CheckState(res);
1613	<	if (_v) {
1614	<	return _wrap_objectMap_rend__SWIG_0(self, args);
6711	<	}
6712	<	}
6713	<	if (argc == 1) {
6714	<	int _v;
6715	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
6716	<	_v = SWIG_CheckState(res);
6717	<	if (_v) {
6718	<	return _wrap_objectMap_rend__SWIG_1(self, args);
1599	>	static PyObject *_wrap_objectMap___iter__(PyObject *self, PyObject *args) {
1600	>	PyObject *resultobj;
1601	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1602	>	PyObject *result;
1603	>	PyObject * obj0 = 0 ;
1604	>
1605	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___iter__",&obj0)) goto fail;
1606	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1607	>	{
1608	>	try {
1609	>	result = (PyObject *)std_maplstd_stringcstd_string_g___iter_____(arg1);
1610	>
1611	>	}catch (std::runtime_error& e) {
1612	>	PyErr_SetString(PyExc_RuntimeError,const_cast<char*>(e.what()));
1613	>	SWIG_fail;
1614	>	}
1615		}
1616	<	}
1617	<
1618	<	fail:
1619	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_rend'");
6724	<	return NULL;
1616	>	resultobj = result;
1617	>	return resultobj;
1618	>	fail:
1619	>	return NULL;
1620		}
1621
1622
1623	<	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1624	<	PyObject *resultobj = 0;
1625	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1626	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
1627	<	std::map<std::string,std::string >::size_type result;
1628	<	void *argp1 = 0 ;
1629	<	int res1 = 0 ;
1630	<	int res2 = SWIG_OLDOBJ ;
1631	<	PyObject * obj0 = 0 ;
1632	<	PyObject * obj1 = 0 ;
1633	<
1634	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_erase",&obj0,&obj1)) SWIG_fail;
1635	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
1636	<	if (!SWIG_IsOK(res1)) {
1637	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1638	<	}
1639	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1640	<	{
6746	<	std::string *ptr = (std::string *)0;
6747	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
6748	<	if (!SWIG_IsOK(res2)) {
6749	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
6750	<	}
6751	<	if (!ptr) {
6752	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
6753	<	}
6754	<	arg2 = ptr;
6755	<	}
6756	<	{
6757	<	try {
6758	<	result = (arg1)->erase((std::map<std::string,std::string >::key_type const &)*arg2);
6759	<	} catch (const std::exception& e) {
6760	<	SWIG_exception(SWIG_RuntimeError, e.what());
1623	>	static PyObject *_wrap_delete_objectMap(PyObject *self, PyObject *args) {
1624	>	PyObject *resultobj;
1625	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1626	>	PyObject * obj0 = 0 ;
1627	>
1628	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_objectMap",&obj0)) goto fail;
1629	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1630	>	{
1631	>	try {
1632	>	delete arg1;
1633	>
1634	>	}catch (const BossSchedFailure & e) {
1635	>	PyErr_SetString ( SchedulerError, e.what() );
1636	>	return NULL;
1637	>	}catch (const std::exception& e) {
1638	>	PyErr_SetString ( BossError, e.what() );
1639	>	return NULL;
1640	>	}
1641		}
1642	<	}
1643	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
1644	<	if (SWIG_IsNewObj(res2)) delete arg2;
1645	<	return resultobj;
6766	<	fail:
6767	<	if (SWIG_IsNewObj(res2)) delete arg2;
6768	<	return NULL;
1642	>	Py_INCREF(Py_None); resultobj = Py_None;
1643	>	return resultobj;
1644	>	fail:
1645	>	return NULL;
1646		}
1647
1648
1649	<	SWIGINTERN PyObject *_wrap_objectMap_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1650	<	PyObject *resultobj = 0;
1651	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1652	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
1653	<	std::map<std::string,std::string >::size_type result;
1654	<	void *argp1 = 0 ;
1655	<	int res1 = 0 ;
1656	<	int res2 = SWIG_OLDOBJ ;
1657	<	PyObject * obj0 = 0 ;
1658	<	PyObject * obj1 = 0 ;
1659	<
1660	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_count",&obj0,&obj1)) SWIG_fail;
1661	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
1662	<	if (!SWIG_IsOK(res1)) {
1663	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_count" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
1664	<	}
1665	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6789	<	{
6790	<	std::string *ptr = (std::string *)0;
6791	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
6792	<	if (!SWIG_IsOK(res2)) {
6793	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_count" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
6794	<	}
6795	<	if (!ptr) {
6796	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_count" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
1649	>	static PyObject * objectMap_swigregister(PyObject *self, PyObject *args) {
1650	>	PyObject *obj;
1651	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
1652	>	SWIG_TypeClientData(SWIGTYPE_p_std__mapTstd__string_std__string_t, obj);
1653	>	Py_INCREF(obj);
1654	>	return Py_BuildValue((char *)"");
1655	>	}
1656	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1657	>	PyObject *resultobj;
1658	>	unsigned int arg1 = (unsigned int) 0 ;
1659	>	std::vector<std::string > *result;
1660	>	PyObject * obj0 = 0 ;
1661	>
1662	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1663	>	if (obj0) {
1664	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1665	>	if (PyErr_Occurred()) SWIG_fail;
1666		}
1667	<	arg2 = ptr;
1668	<	}
1669	<	{
1670	<	try {
1671	<	result = ((std::map<std::string,std::string > const *)arg1)->count((std::map<std::string,std::string >::key_type const &)*arg2);
1672	<	} catch (const std::exception& e) {
1673	<	SWIG_exception(SWIG_RuntimeError, e.what());
1667	>	{
1668	>	try {
1669	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1670	>
1671	>	}catch (const BossSchedFailure & e) {
1672	>	PyErr_SetString ( SchedulerError, e.what() );
1673	>	return NULL;
1674	>	}catch (const std::exception& e) {
1675	>	PyErr_SetString ( BossError, e.what() );
1676	>	return NULL;
1677	>	}
1678		}
1679	<	}
1680	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
1681	<	if (SWIG_IsNewObj(res2)) delete arg2;
1682	<	return resultobj;
6810	<	fail:
6811	<	if (SWIG_IsNewObj(res2)) delete arg2;
6812	<	return NULL;
1679	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1680	>	return resultobj;
1681	>	fail:
1682	>	return NULL;
1683		}
1684
1685
1686	<	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1687	<	PyObject *resultobj = 0;
1688	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1689	<	std::map<std::string,std::string >::iterator arg2 ;
1690	<	void *argp1 = 0 ;
1691	<	int res1 = 0 ;
1692	<	swig::PySwigIterator *iter2 = 0 ;
1693	<	int res2 ;
1694	<	PyObject * obj0 = 0 ;
1695	<	PyObject * obj1 = 0 ;
1696	<
1697	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_erase",&obj0,&obj1)) SWIG_fail;
1698	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
1699	<	if (!SWIG_IsOK(res1)) {
1700	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1701	<	}
1702	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1703	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
1704	<	if (!SWIG_IsOK(res2) || !iter2) {
6835	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::iterator""'");
6836	<	} else {
6837	<	swig::PySwigIterator_T<std::map<std::string,std::string >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map<std::string,std::string >::iterator > *>(iter2);
6838	<	if (iter_t) {
6839	<	arg2 = iter_t->get_current();
6840	<	} else {
6841	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::iterator""'");
1686	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1687	>	PyObject *resultobj;
1688	>	unsigned int arg1 ;
1689	>	std::string *arg2 = 0 ;
1690	>	std::vector<std::string > *result;
1691	>	std::string temp2 ;
1692	>	PyObject * obj0 = 0 ;
1693	>	PyObject * obj1 = 0 ;
1694	>
1695	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1696	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1697	>	if (PyErr_Occurred()) SWIG_fail;
1698	>	{
1699	>	if (PyString_Check(obj1)) {
1700	>	temp2 = std::string(PyString_AsString(obj1));
1701	>	arg2 = &temp2;
1702	>	}else {
1703	>	SWIG_exception(SWIG_TypeError, "string expected");
1704	>	}
1705		}
1706	<	}
1707	<	{
1708	<	try {
1709	<	(arg1)->erase(arg2);
1710	<	} catch (const std::exception& e) {
1711	<	SWIG_exception(SWIG_RuntimeError, e.what());
1706	>	{
1707	>	try {
1708	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1709	>
1710	>	}catch (const BossSchedFailure & e) {
1711	>	PyErr_SetString ( SchedulerError, e.what() );
1712	>	return NULL;
1713	>	}catch (const std::exception& e) {
1714	>	PyErr_SetString ( BossError, e.what() );
1715	>	return NULL;
1716	>	}
1717		}
1718	<	}
1719	<	resultobj = SWIG_Py_Void();
1720	<	return resultobj;
1721	<	fail:
6854	<	return NULL;
1718	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1719	>	return resultobj;
1720	>	fail:
1721	>	return NULL;
1722		}
1723
1724
1725	<	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1726	<	PyObject *resultobj = 0;
1727	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1728	<	std::map<std::string,std::string >::iterator arg2 ;
1729	<	std::map<std::string,std::string >::iterator arg3 ;
1730	<	void *argp1 = 0 ;
1731	<	int res1 = 0 ;
1732	<	swig::PySwigIterator *iter2 = 0 ;
1733	<	int res2 ;
1734	<	swig::PySwigIterator *iter3 = 0 ;
1735	<	int res3 ;
1736	<	PyObject * obj0 = 0 ;
1737	<	PyObject * obj1 = 0 ;
1738	<	PyObject * obj2 = 0 ;
1739	<
1740	<	if (!PyArg_ParseTuple(args,(char *)"OOO:objectMap_erase",&obj0,&obj1,&obj2)) SWIG_fail;
1741	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
1742	<	if (!SWIG_IsOK(res1)) {
1743	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1744	<	}
1745	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1746	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
1747	<	if (!SWIG_IsOK(res2) || !iter2) {
1748	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::iterator""'");
1749	<	} else {
1750	<	swig::PySwigIterator_T<std::map<std::string,std::string >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map<std::string,std::string >::iterator > *>(iter2);
1751	<	if (iter_t) {
1752	<	arg2 = iter_t->get_current();
1753	<	} else {
1754	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::iterator""'");
1755	<	}
1756	<	}
1757	<	res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
1758	<	if (!SWIG_IsOK(res3) || !iter3) {
1759	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "3"" of type '" "std::map<std::string,std::string >::iterator""'");
1760	<	} else {
6894	<	swig::PySwigIterator_T<std::map<std::string,std::string >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::map<std::string,std::string >::iterator > *>(iter3);
6895	<	if (iter_t) {
6896	<	arg3 = iter_t->get_current();
6897	<	} else {
6898	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "3"" of type '" "std::map<std::string,std::string >::iterator""'");
1725	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1726	>	PyObject *resultobj;
1727	>	std::vector<std::string > *arg1 = 0 ;
1728	>	std::vector<std::string > *result;
1729	>	std::vector<std::string > temp1 ;
1730	>	std::vector<std::string > *v1 ;
1731	>	PyObject * obj0 = 0 ;
1732	>
1733	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1734	>	{
1735	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1736	>	unsigned int size = (PyTuple_Check(obj0) ?
1737	>	PyTuple_Size(obj0) :
1738	>	PyList_Size(obj0));
1739	>	temp1 = std::vector<std::string >(size);
1740	>	arg1 = &temp1;
1741	>	for (unsigned int i=0; i<size; i++) {
1742	>	PyObject* o = PySequence_GetItem(obj0,i);
1743	>	if (PyString_Check(o)) {
1744	>	temp1[i] = (std::string)(\
1745	>	SwigString_AsString(o));
1746	>	Py_DECREF(o);
1747	>	}else {
1748	>	Py_DECREF(o);
1749	>	PyErr_SetString(PyExc_TypeError,
1750	>	"vector<""std::string""> expected");
1751	>	SWIG_fail;
1752	>	}
1753	>	}
1754	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1755	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1756	>	arg1 = v1;
1757	>	}else {
1758	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1759	>	SWIG_fail;
1760	>	}
1761		}
1762	<	}
1763	<	{
1764	<	try {
1765	<	(arg1)->erase(arg2,arg3);
1766	<	} catch (const std::exception& e) {
1767	<	SWIG_exception(SWIG_RuntimeError, e.what());
1762	>	{
1763	>	try {
1764	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1765	>
1766	>	}catch (const BossSchedFailure & e) {
1767	>	PyErr_SetString ( SchedulerError, e.what() );
1768	>	return NULL;
1769	>	}catch (const std::exception& e) {
1770	>	PyErr_SetString ( BossError, e.what() );
1771	>	return NULL;
1772	>	}
1773		}
1774	<	}
1775	<	resultobj = SWIG_Py_Void();
1776	<	return resultobj;
1777	<	fail:
6911	<	return NULL;
1774	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1775	>	return resultobj;
1776	>	fail:
1777	>	return NULL;
1778		}
1779
1780
1781	<	SWIGINTERN PyObject *_wrap_objectMap_erase(PyObject *self, PyObject *args) {
1782	<	int argc;
1783	<	PyObject *argv[4];
1784	<	int ii;
1785	<
1786	<	if (!PyTuple_Check(args)) SWIG_fail;
1787	<	argc = PyObject_Length(args);
1788	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
1789	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1790	<	}
1791	<	if (argc == 2) {
1792	<	int _v;
1793	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
1794	<	_v = SWIG_CheckState(res);
1795	<	if (_v) {
1796	<	swig::PySwigIterator *iter = 0;
1797	<	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6932	<	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map<std::string,std::string >::iterator > *>(iter) != 0));
6933	<	if (_v) {
6934	<	return _wrap_objectMap_erase__SWIG_1(self, args);
6935	<	}
6936	<	}
6937	<	}
6938	<	if (argc == 2) {
6939	<	int _v;
6940	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
6941	<	_v = SWIG_CheckState(res);
6942	<	if (_v) {
6943	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
6944	<	_v = SWIG_CheckState(res);
6945	<	if (_v) {
6946	<	return _wrap_objectMap_erase__SWIG_0(self, args);
6947	<	}
6948	<	}
6949	<	}
6950	<	if (argc == 3) {
6951	<	int _v;
6952	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
6953	<	_v = SWIG_CheckState(res);
6954	<	if (_v) {
6955	<	swig::PySwigIterator *iter = 0;
6956	<	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6957	<	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map<std::string,std::string >::iterator > *>(iter) != 0));
6958	<	if (_v) {
6959	<	swig::PySwigIterator *iter = 0;
6960	<	int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
6961	<	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::map<std::string,std::string >::iterator > *>(iter) != 0));
1781	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1782	>	int argc;
1783	>	PyObject *argv[3];
1784	>	int ii;
1785	>
1786	>	argc = PyObject_Length(args);
1787	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1788	>	argv[ii] = PyTuple_GetItem(args,ii);
1789	>	}
1790	>	if ((argc >= 0) && (argc <= 1)) {
1791	>	int _v;
1792	>	if (argc <= 0) {
1793	>	return _wrap_new_vector_string__SWIG_0(self,args);
1794	>	}
1795	>	{
1796	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1797	>	}
1798		if (_v) {
1799	<	return _wrap_objectMap_erase__SWIG_2(self, args);
1799	>	return _wrap_new_vector_string__SWIG_0(self,args);
1800		}
6965	–	}
6966	–	}
6967	–	}
6968	–
6969	–	fail:
6970	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_erase'");
6971	–	return NULL;
6972	–	}
6973	–
6974	–
6975	–	SWIGINTERN PyObject *_wrap_objectMap_find__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6976	–	PyObject *resultobj = 0;
6977	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6978	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
6979	–	std::map<std::string,std::string >::iterator result;
6980	–	void *argp1 = 0 ;
6981	–	int res1 = 0 ;
6982	–	int res2 = SWIG_OLDOBJ ;
6983	–	PyObject * obj0 = 0 ;
6984	–	PyObject * obj1 = 0 ;
6985	–
6986	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_find",&obj0,&obj1)) SWIG_fail;
6987	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6988	–	if (!SWIG_IsOK(res1)) {
6989	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_find" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6990	–	}
6991	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6992	–	{
6993	–	std::string *ptr = (std::string *)0;
6994	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
6995	–	if (!SWIG_IsOK(res2)) {
6996	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_find" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
6997	–	}
6998	–	if (!ptr) {
6999	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_find" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7000	–	}
7001	–	arg2 = ptr;
7002	–	}
7003	–	{
7004	–	try {
7005	–	result = (arg1)->find((std::map<std::string,std::string >::key_type const &)*arg2);
7006	–	} catch (const std::exception& e) {
7007	–	SWIG_exception(SWIG_RuntimeError, e.what());
7008	–	}
7009	–	}
7010	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
7011	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7012	–	if (SWIG_IsNewObj(res2)) delete arg2;
7013	–	return resultobj;
7014	–	fail:
7015	–	if (SWIG_IsNewObj(res2)) delete arg2;
7016	–	return NULL;
7017	–	}
7018	–
7019	–
7020	–	SWIGINTERN PyObject *_wrap_objectMap_find__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7021	–	PyObject *resultobj = 0;
7022	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7023	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7024	–	std::map<std::string,std::string >::const_iterator result;
7025	–	void *argp1 = 0 ;
7026	–	int res1 = 0 ;
7027	–	int res2 = SWIG_OLDOBJ ;
7028	–	PyObject * obj0 = 0 ;
7029	–	PyObject * obj1 = 0 ;
7030	–
7031	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_find",&obj0,&obj1)) SWIG_fail;
7032	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7033	–	if (!SWIG_IsOK(res1)) {
7034	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_find" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
7035	–	}
7036	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7037	–	{
7038	–	std::string *ptr = (std::string *)0;
7039	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7040	–	if (!SWIG_IsOK(res2)) {
7041	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_find" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7042	–	}
7043	–	if (!ptr) {
7044	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_find" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7045	–	}
7046	–	arg2 = ptr;
7047	–	}
7048	–	{
7049	–	try {
7050	–	result = ((std::map<std::string,std::string > const *)arg1)->find((std::map<std::string,std::string >::key_type const &)*arg2);
7051	–	} catch (const std::exception& e) {
7052	–	SWIG_exception(SWIG_RuntimeError, e.what());
7053	–	}
7054	–	}
7055	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
7056	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7057	–	if (SWIG_IsNewObj(res2)) delete arg2;
7058	–	return resultobj;
7059	–	fail:
7060	–	if (SWIG_IsNewObj(res2)) delete arg2;
7061	–	return NULL;
7062	–	}
7063	–
7064	–
7065	–	SWIGINTERN PyObject *_wrap_objectMap_find(PyObject *self, PyObject *args) {
7066	–	int argc;
7067	–	PyObject *argv[3];
7068	–	int ii;
7069	–
7070	–	if (!PyTuple_Check(args)) SWIG_fail;
7071	–	argc = PyObject_Length(args);
7072	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7073	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
7074	–	}
7075	–	if (argc == 2) {
7076	–	int _v;
7077	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7078	–	_v = SWIG_CheckState(res);
7079	–	if (_v) {
7080	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7081	–	_v = SWIG_CheckState(res);
7082	–	if (_v) {
7083	–	return _wrap_objectMap_find__SWIG_0(self, args);
7084	–	}
7085	–	}
7086	–	}
7087	–	if (argc == 2) {
7088	–	int _v;
7089	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7090	–	_v = SWIG_CheckState(res);
7091	–	if (_v) {
7092	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7093	–	_v = SWIG_CheckState(res);
7094	–	if (_v) {
7095	–	return _wrap_objectMap_find__SWIG_1(self, args);
7096	–	}
7097	–	}
7098	–	}
7099	–
7100	–	fail:
7101	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_find'");
7102	–	return NULL;
7103	–	}
7104	–
7105	–
7106	–	SWIGINTERN PyObject *_wrap_objectMap_lower_bound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7107	–	PyObject *resultobj = 0;
7108	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7109	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7110	–	std::map<std::string,std::string >::iterator result;
7111	–	void *argp1 = 0 ;
7112	–	int res1 = 0 ;
7113	–	int res2 = SWIG_OLDOBJ ;
7114	–	PyObject * obj0 = 0 ;
7115	–	PyObject * obj1 = 0 ;
7116	–
7117	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_lower_bound",&obj0,&obj1)) SWIG_fail;
7118	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7119	–	if (!SWIG_IsOK(res1)) {
7120	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_lower_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
7121	–	}
7122	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7123	–	{
7124	–	std::string *ptr = (std::string *)0;
7125	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7126	–	if (!SWIG_IsOK(res2)) {
7127	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7128	–	}
7129	–	if (!ptr) {
7130	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7131	–	}
7132	–	arg2 = ptr;
7133	–	}
7134	–	{
7135	–	try {
7136	–	result = (arg1)->lower_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7137	–	} catch (const std::exception& e) {
7138	–	SWIG_exception(SWIG_RuntimeError, e.what());
7139	–	}
7140	–	}
7141	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
7142	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7143	–	if (SWIG_IsNewObj(res2)) delete arg2;
7144	–	return resultobj;
7145	–	fail:
7146	–	if (SWIG_IsNewObj(res2)) delete arg2;
7147	–	return NULL;
7148	–	}
7149	–
7150	–
7151	–	SWIGINTERN PyObject *_wrap_objectMap_lower_bound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7152	–	PyObject *resultobj = 0;
7153	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7154	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7155	–	std::map<std::string,std::string >::const_iterator result;
7156	–	void *argp1 = 0 ;
7157	–	int res1 = 0 ;
7158	–	int res2 = SWIG_OLDOBJ ;
7159	–	PyObject * obj0 = 0 ;
7160	–	PyObject * obj1 = 0 ;
7161	–
7162	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_lower_bound",&obj0,&obj1)) SWIG_fail;
7163	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7164	–	if (!SWIG_IsOK(res1)) {
7165	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_lower_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
7166	–	}
7167	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7168	–	{
7169	–	std::string *ptr = (std::string *)0;
7170	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7171	–	if (!SWIG_IsOK(res2)) {
7172	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7173	–	}
7174	–	if (!ptr) {
7175	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7176	–	}
7177	–	arg2 = ptr;
7178	–	}
7179	–	{
7180	–	try {
7181	–	result = ((std::map<std::string,std::string > const *)arg1)->lower_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7182	–	} catch (const std::exception& e) {
7183	–	SWIG_exception(SWIG_RuntimeError, e.what());
7184	–	}
7185	–	}
7186	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
7187	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7188	–	if (SWIG_IsNewObj(res2)) delete arg2;
7189	–	return resultobj;
7190	–	fail:
7191	–	if (SWIG_IsNewObj(res2)) delete arg2;
7192	–	return NULL;
7193	–	}
7194	–
7195	–
7196	–	SWIGINTERN PyObject *_wrap_objectMap_lower_bound(PyObject *self, PyObject *args) {
7197	–	int argc;
7198	–	PyObject *argv[3];
7199	–	int ii;
7200	–
7201	–	if (!PyTuple_Check(args)) SWIG_fail;
7202	–	argc = PyObject_Length(args);
7203	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7204	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
7205	–	}
7206	–	if (argc == 2) {
7207	–	int _v;
7208	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7209	–	_v = SWIG_CheckState(res);
7210	–	if (_v) {
7211	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7212	–	_v = SWIG_CheckState(res);
7213	–	if (_v) {
7214	–	return _wrap_objectMap_lower_bound__SWIG_0(self, args);
7215	–	}
7216	–	}
7217	–	}
7218	–	if (argc == 2) {
7219	–	int _v;
7220	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7221	–	_v = SWIG_CheckState(res);
7222	–	if (_v) {
7223	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7224	–	_v = SWIG_CheckState(res);
7225	–	if (_v) {
7226	–	return _wrap_objectMap_lower_bound__SWIG_1(self, args);
7227	–	}
7228	–	}
7229	–	}
7230	–
7231	–	fail:
7232	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_lower_bound'");
7233	–	return NULL;
7234	–	}
7235	–
7236	–
7237	–	SWIGINTERN PyObject *_wrap_objectMap_upper_bound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7238	–	PyObject *resultobj = 0;
7239	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7240	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7241	–	std::map<std::string,std::string >::iterator result;
7242	–	void *argp1 = 0 ;
7243	–	int res1 = 0 ;
7244	–	int res2 = SWIG_OLDOBJ ;
7245	–	PyObject * obj0 = 0 ;
7246	–	PyObject * obj1 = 0 ;
7247	–
7248	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_upper_bound",&obj0,&obj1)) SWIG_fail;
7249	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7250	–	if (!SWIG_IsOK(res1)) {
7251	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_upper_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
7252	–	}
7253	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7254	–	{
7255	–	std::string *ptr = (std::string *)0;
7256	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7257	–	if (!SWIG_IsOK(res2)) {
7258	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_upper_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7259	–	}
7260	–	if (!ptr) {
7261	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_upper_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7262	–	}
7263	–	arg2 = ptr;
7264	–	}
7265	–	{
7266	–	try {
7267	–	result = (arg1)->upper_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7268	–	} catch (const std::exception& e) {
7269	–	SWIG_exception(SWIG_RuntimeError, e.what());
7270	–	}
7271	–	}
7272	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
7273	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7274	–	if (SWIG_IsNewObj(res2)) delete arg2;
7275	–	return resultobj;
7276	–	fail:
7277	–	if (SWIG_IsNewObj(res2)) delete arg2;
7278	–	return NULL;
7279	–	}
7280	–
7281	–
7282	–	SWIGINTERN PyObject *_wrap_objectMap_upper_bound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7283	–	PyObject *resultobj = 0;
7284	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7285	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7286	–	std::map<std::string,std::string >::const_iterator result;
7287	–	void *argp1 = 0 ;
7288	–	int res1 = 0 ;
7289	–	int res2 = SWIG_OLDOBJ ;
7290	–	PyObject * obj0 = 0 ;
7291	–	PyObject * obj1 = 0 ;
7292	–
7293	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_upper_bound",&obj0,&obj1)) SWIG_fail;
7294	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7295	–	if (!SWIG_IsOK(res1)) {
7296	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_upper_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
7297	–	}
7298	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7299	–	{
7300	–	std::string *ptr = (std::string *)0;
7301	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7302	–	if (!SWIG_IsOK(res2)) {
7303	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_upper_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7304	–	}
7305	–	if (!ptr) {
7306	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_upper_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7307	–	}
7308	–	arg2 = ptr;
7309	–	}
7310	–	{
7311	–	try {
7312	–	result = ((std::map<std::string,std::string > const *)arg1)->upper_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7313	–	} catch (const std::exception& e) {
7314	–	SWIG_exception(SWIG_RuntimeError, e.what());
7315	–	}
7316	–	}
7317	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
7318	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7319	–	if (SWIG_IsNewObj(res2)) delete arg2;
7320	–	return resultobj;
7321	–	fail:
7322	–	if (SWIG_IsNewObj(res2)) delete arg2;
7323	–	return NULL;
7324	–	}
7325	–
7326	–
7327	–	SWIGINTERN PyObject *_wrap_objectMap_upper_bound(PyObject *self, PyObject *args) {
7328	–	int argc;
7329	–	PyObject *argv[3];
7330	–	int ii;
7331	–
7332	–	if (!PyTuple_Check(args)) SWIG_fail;
7333	–	argc = PyObject_Length(args);
7334	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7335	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
7336	–	}
7337	–	if (argc == 2) {
7338	–	int _v;
7339	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7340	–	_v = SWIG_CheckState(res);
7341	–	if (_v) {
7342	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7343	–	_v = SWIG_CheckState(res);
7344	–	if (_v) {
7345	–	return _wrap_objectMap_upper_bound__SWIG_0(self, args);
7346	–	}
7347	–	}
7348	–	}
7349	–	if (argc == 2) {
7350	–	int _v;
7351	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7352	–	_v = SWIG_CheckState(res);
7353	–	if (_v) {
7354	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7355	–	_v = SWIG_CheckState(res);
7356	–	if (_v) {
7357	–	return _wrap_objectMap_upper_bound__SWIG_1(self, args);
7358	–	}
7359	–	}
7360	–	}
7361	–
7362	–	fail:
7363	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_upper_bound'");
7364	–	return NULL;
7365	–	}
7366	–
7367	–
7368	–	SWIGINTERN PyObject *_wrap_delete_objectMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7369	–	PyObject *resultobj = 0;
7370	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7371	–	void *argp1 = 0 ;
7372	–	int res1 = 0 ;
7373	–	PyObject * obj0 = 0 ;
7374	–
7375	–	if (!PyArg_ParseTuple(args,(char *)"O:delete_objectMap",&obj0)) SWIG_fail;
7376	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, SWIG_POINTER_DISOWN |  0 );
7377	–	if (!SWIG_IsOK(res1)) {
7378	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_objectMap" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
7379	–	}
7380	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7381	–	{
7382	–	try {
7383	–	delete arg1;
7384	–
7385	–	} catch (const std::exception& e) {
7386	–	SWIG_exception(SWIG_RuntimeError, e.what());
7387	–	}
7388	–	}
7389	–	resultobj = SWIG_Py_Void();
7390	–	return resultobj;
7391	–	fail:
7392	–	return NULL;
7393	–	}
7394	–
7395	–
7396	–	SWIGINTERN PyObject *objectMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7397	–	PyObject *obj;
7398	–	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
7399	–	SWIG_TypeNewClientData(SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, SWIG_NewClientData(obj));
7400	–	return SWIG_Py_Void();
7401	–	}
7402	–
7403	–	SWIGINTERN PyObject *_wrap_vector_string_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7404	–	PyObject *resultobj = 0;
7405	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7406	–	PyObject **arg2 = (PyObject **) 0 ;
7407	–	swig::PySwigIterator *result = 0 ;
7408	–	void *argp1 = 0 ;
7409	–	int res1 = 0 ;
7410	–	PyObject * obj0 = 0 ;
7411	–
7412	–	arg2 = &obj0;
7413	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_iterator",&obj0)) SWIG_fail;
7414	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7415	–	if (!SWIG_IsOK(res1)) {
7416	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_iterator" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7417	–	}
7418	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7419	–	{
7420	–	try {
7421	–	result = (swig::PySwigIterator *)std_vector_Sl_std_string_Sg__iterator(arg1,arg2);
7422	–	} catch (const std::exception& e) {
7423	–	SWIG_exception(SWIG_RuntimeError, e.what());
7424	–	}
7425	–	}
7426	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
7427	–	return resultobj;
7428	–	fail:
7429	–	return NULL;
7430	–	}
7431	–
7432	–
7433	–	SWIGINTERN PyObject *_wrap_vector_string___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7434	–	PyObject *resultobj = 0;
7435	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7436	–	bool result;
7437	–	void *argp1 = 0 ;
7438	–	int res1 = 0 ;
7439	–	PyObject * obj0 = 0 ;
7440	–
7441	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) SWIG_fail;
7442	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7443	–	if (!SWIG_IsOK(res1)) {
7444	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___nonzero__" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
7445	–	}
7446	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7447	–	{
7448	–	try {
7449	–	result = (bool)std_vector_Sl_std_string_Sg____nonzero__((std::vector<std::string > const *)arg1);
7450	–	} catch (const std::exception& e) {
7451	–	SWIG_exception(SWIG_RuntimeError, e.what());
7452	–	}
7453	–	}
7454	–	resultobj = SWIG_From_bool(static_cast< bool >(result));
7455	–	return resultobj;
7456	–	fail:
7457	–	return NULL;
7458	–	}
7459	–
7460	–
7461	–	SWIGINTERN PyObject *_wrap_vector_string___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7462	–	PyObject *resultobj = 0;
7463	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7464	–	std::vector<std::string >::size_type result;
7465	–	void *argp1 = 0 ;
7466	–	int res1 = 0 ;
7467	–	PyObject * obj0 = 0 ;
7468	–
7469	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) SWIG_fail;
7470	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7471	–	if (!SWIG_IsOK(res1)) {
7472	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___len__" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
7473	–	}
7474	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7475	–	{
7476	–	try {
7477	–	result = std_vector_Sl_std_string_Sg____len__((std::vector<std::string > const *)arg1);
7478	–	} catch (const std::exception& e) {
7479	–	SWIG_exception(SWIG_RuntimeError, e.what());
7480	–	}
7481	–	}
7482	–	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7483	–	return resultobj;
7484	–	fail:
7485	–	return NULL;
7486	–	}
7487	–
7488	–
7489	–	SWIGINTERN PyObject *_wrap_vector_string_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7490	–	PyObject *resultobj = 0;
7491	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7492	–	std::vector<std::string >::value_type result;
7493	–	void *argp1 = 0 ;
7494	–	int res1 = 0 ;
7495	–	PyObject * obj0 = 0 ;
7496	–
7497	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) SWIG_fail;
7498	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7499	–	if (!SWIG_IsOK(res1)) {
7500	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_pop" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7501	–	}
7502	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7503	–	{
7504	–	try {
7505	–	try {
7506	–	result = std_vector_Sl_std_string_Sg__pop(arg1);
7507	–	}
7508	–	catch(std::out_of_range &_e) {
7509	–	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7510	–	}
7511	–
7512	–	} catch (const std::exception& e) {
7513	–	SWIG_exception(SWIG_RuntimeError, e.what());
7514	–	}
7515	–	}
7516	–	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
7517	–	return resultobj;
7518	–	fail:
7519	–	return NULL;
7520	–	}
7521	–
7522	–
7523	–	SWIGINTERN PyObject *_wrap_vector_string___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7524	–	PyObject *resultobj = 0;
7525	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7526	–	std::vector<std::string >::difference_type arg2 ;
7527	–	std::vector<std::string >::difference_type arg3 ;
7528	–	std::vector<std::string,std::allocator<std::string > > *result = 0 ;
7529	–	void *argp1 = 0 ;
7530	–	int res1 = 0 ;
7531	–	ptrdiff_t val2 ;
7532	–	int ecode2 = 0 ;
7533	–	ptrdiff_t val3 ;
7534	–	int ecode3 = 0 ;
7535	–	PyObject * obj0 = 0 ;
7536	–	PyObject * obj1 = 0 ;
7537	–	PyObject * obj2 = 0 ;
7538	–
7539	–	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7540	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7541	–	if (!SWIG_IsOK(res1)) {
7542	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___getslice__" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7543	–	}
7544	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7545	–	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7546	–	if (!SWIG_IsOK(ecode2)) {
7547	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string___getslice__" "', argument " "2"" of type '" "std::vector<std::string >::difference_type""'");
7548	–	}
7549	–	arg2 = static_cast< std::vector<std::string >::difference_type >(val2);
7550	–	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7551	–	if (!SWIG_IsOK(ecode3)) {
7552	–	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string___getslice__" "', argument " "3"" of type '" "std::vector<std::string >::difference_type""'");
7553	–	}
7554	–	arg3 = static_cast< std::vector<std::string >::difference_type >(val3);
7555	–	{
7556	–	try {
7557	–	try {
7558	–	result = (std::vector<std::string,std::allocator<std::string > > *)std_vector_Sl_std_string_Sg____getslice__(arg1,arg2,arg3);
7559	–	}
7560	–	catch(std::out_of_range &_e) {
7561	–	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7562	–	}
7563	–
7564	–	} catch (const std::exception& e) {
7565	–	SWIG_exception(SWIG_RuntimeError, e.what());
7566	–	}
7567	–	}
7568	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_OWN |  0 );
7569	–	return resultobj;
7570	–	fail:
7571	–	return NULL;
7572	–	}
7573	–
7574	–
7575	–	SWIGINTERN PyObject *_wrap_vector_string___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7576	–	PyObject *resultobj = 0;
7577	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7578	–	std::vector<std::string >::difference_type arg2 ;
7579	–	std::vector<std::string >::difference_type arg3 ;
7580	–	std::vector<std::string,std::allocator<std::string > > *arg4 = 0 ;
7581	–	void *argp1 = 0 ;
7582	–	int res1 = 0 ;
7583	–	ptrdiff_t val2 ;
7584	–	int ecode2 = 0 ;
7585	–	ptrdiff_t val3 ;
7586	–	int ecode3 = 0 ;
7587	–	int res4 = SWIG_OLDOBJ ;
7588	–	PyObject * obj0 = 0 ;
7589	–	PyObject * obj1 = 0 ;
7590	–	PyObject * obj2 = 0 ;
7591	–	PyObject * obj3 = 0 ;
7592	–
7593	–	if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7594	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7595	–	if (!SWIG_IsOK(res1)) {
7596	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___setslice__" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7597	–	}
7598	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7599	–	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7600	–	if (!SWIG_IsOK(ecode2)) {
7601	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string___setslice__" "', argument " "2"" of type '" "std::vector<std::string >::difference_type""'");
7602	–	}
7603	–	arg2 = static_cast< std::vector<std::string >::difference_type >(val2);
7604	–	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7605	–	if (!SWIG_IsOK(ecode3)) {
7606	–	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string___setslice__" "', argument " "3"" of type '" "std::vector<std::string >::difference_type""'");
7607	–	}
7608	–	arg3 = static_cast< std::vector<std::string >::difference_type >(val3);
7609	–	{
7610	–	std::vector<std::string,std::allocator<std::string > > *ptr = (std::vector<std::string,std::allocator<std::string > > *)0;
7611	–	res4 = swig::asptr(obj3, &ptr);
7612	–	if (!SWIG_IsOK(res4)) {
7613	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_string___setslice__" "', argument " "4"" of type '" "std::vector<std::string,std::allocator<std::string > > const &""'");
7614	–	}
7615	–	if (!ptr) {
7616	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string___setslice__" "', argument " "4"" of type '" "std::vector<std::string,std::allocator<std::string > > const &""'");
1801		}
1802	<	arg4 = ptr;
1803	<	}
7620	<	{
7621	<	try {
7622	<	try {
7623	<	std_vector_Sl_std_string_Sg____setslice__(arg1,arg2,arg3,(std::vector<std::string,std::allocator<std::string > > const &)*arg4);
7624	<	}
7625	<	catch(std::out_of_range &_e) {
7626	<	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7627	<	}
7628	<	catch(std::invalid_argument &_e) {
7629	<	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7630	<	}
7631	<
7632	<	} catch (const std::exception& e) {
7633	<	SWIG_exception(SWIG_RuntimeError, e.what());
7634	<	}
7635	<	}
7636	<	resultobj = SWIG_Py_Void();
7637	<	if (SWIG_IsNewObj(res4)) delete arg4;
7638	<	return resultobj;
7639	<	fail:
7640	<	if (SWIG_IsNewObj(res4)) delete arg4;
7641	<	return NULL;
7642	<	}
7643	<
7644	<
7645	<	SWIGINTERN PyObject *_wrap_vector_string___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7646	<	PyObject *resultobj = 0;
7647	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7648	<	std::vector<std::string >::difference_type arg2 ;
7649	<	std::vector<std::string >::difference_type arg3 ;
7650	<	void *argp1 = 0 ;
7651	<	int res1 = 0 ;
7652	<	ptrdiff_t val2 ;
7653	<	int ecode2 = 0 ;
7654	<	ptrdiff_t val3 ;
7655	<	int ecode3 = 0 ;
7656	<	PyObject * obj0 = 0 ;
7657	<	PyObject * obj1 = 0 ;
7658	<	PyObject * obj2 = 0 ;
7659	<
7660	<	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7661	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7662	<	if (!SWIG_IsOK(res1)) {
7663	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___delslice__" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7664	<	}
7665	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7666	<	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7667	<	if (!SWIG_IsOK(ecode2)) {
7668	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string___delslice__" "', argument " "2"" of type '" "std::vector<std::string >::difference_type""'");
7669	<	}
7670	<	arg2 = static_cast< std::vector<std::string >::difference_type >(val2);
7671	<	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7672	<	if (!SWIG_IsOK(ecode3)) {
7673	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string___delslice__" "', argument " "3"" of type '" "std::vector<std::string >::difference_type""'");
7674	<	}
7675	<	arg3 = static_cast< std::vector<std::string >::difference_type >(val3);
7676	<	{
7677	<	try {
7678	<	try {
7679	<	std_vector_Sl_std_string_Sg____delslice__(arg1,arg2,arg3);
7680	<	}
7681	<	catch(std::out_of_range &_e) {
7682	<	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7683	<	}
7684	<
7685	<	} catch (const std::exception& e) {
7686	<	SWIG_exception(SWIG_RuntimeError, e.what());
7687	<	}
7688	<	}
7689	<	resultobj = SWIG_Py_Void();
7690	<	return resultobj;
7691	<	fail:
7692	<	return NULL;
7693	<	}
7694	<
7695	<
7696	<	SWIGINTERN PyObject *_wrap_vector_string___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7697	<	PyObject *resultobj = 0;
7698	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7699	<	std::vector<std::string >::difference_type arg2 ;
7700	<	void *argp1 = 0 ;
7701	<	int res1 = 0 ;
7702	<	ptrdiff_t val2 ;
7703	<	int ecode2 = 0 ;
7704	<	PyObject * obj0 = 0 ;
7705	<	PyObject * obj1 = 0 ;
7706	<
7707	<	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string___delitem__",&obj0,&obj1)) SWIG_fail;
7708	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7709	<	if (!SWIG_IsOK(res1)) {
7710	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___delitem__" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7711	<	}
7712	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7713	<	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7714	<	if (!SWIG_IsOK(ecode2)) {
7715	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string___delitem__" "', argument " "2"" of type '" "std::vector<std::string >::difference_type""'");
7716	<	}
7717	<	arg2 = static_cast< std::vector<std::string >::difference_type >(val2);
7718	<	{
7719	<	try {
7720	<	try {
7721	<	std_vector_Sl_std_string_Sg____delitem__(arg1,arg2);
7722	<	}
7723	<	catch(std::out_of_range &_e) {
7724	<	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7725	<	}
7726	<
7727	<	} catch (const std::exception& e) {
7728	<	SWIG_exception(SWIG_RuntimeError, e.what());
7729	<	}
7730	<	}
7731	<	resultobj = SWIG_Py_Void();
7732	<	return resultobj;
7733	<	fail:
7734	<	return NULL;
7735	<	}
7736	<
7737	<
7738	<	SWIGINTERN PyObject *_wrap_vector_string___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7739	<	PyObject *resultobj = 0;
7740	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7741	<	std::vector<std::string >::difference_type arg2 ;
7742	<	std::vector<std::string >::value_type *result = 0 ;
7743	<	void *argp1 = 0 ;
7744	<	int res1 = 0 ;
7745	<	ptrdiff_t val2 ;
7746	<	int ecode2 = 0 ;
7747	<	PyObject * obj0 = 0 ;
7748	<	PyObject * obj1 = 0 ;
7749	<
7750	<	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string___getitem__",&obj0,&obj1)) SWIG_fail;
7751	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7752	<	if (!SWIG_IsOK(res1)) {
7753	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___getitem__" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
7754	<	}
7755	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7756	<	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7757	<	if (!SWIG_IsOK(ecode2)) {
7758	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string___getitem__" "', argument " "2"" of type '" "std::vector<std::string >::difference_type""'");
7759	<	}
7760	<	arg2 = static_cast< std::vector<std::string >::difference_type >(val2);
7761	<	{
7762	<	try {
7763	<	try {
1802	>	if (argc == 1) {
1803	>	int _v;
1804		{
1805	<	std::vector<std::string >::value_type const &_result_ref = std_vector_Sl_std_string_Sg____getitem__((std::vector<std::string > const *)arg1,arg2);
1806	<	result = (std::vector<std::string >::value_type *) &_result_ref;
1805	>	/* native sequence? */
1806	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1807	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1808	>	PyTuple_Size(argv[0]) :
1809	>	PyList_Size(argv[0]));
1810	>	if (size == 0) {
1811	>	/* an empty sequence can be of any type */
1812	>	_v = 1;
1813	>	}else {
1814	>	/* check the first element only */
1815	>	PyObject* o = PySequence_GetItem(argv[0],0);
1816	>	if (PyString_Check(o))
1817	>	_v = 1;
1818	>	else
1819	>	_v = 0;
1820	>	Py_DECREF(o);
1821	>	}
1822	>	}else {
1823	>	/* wrapped vector? */
1824	>	std::vector<std::string >* v;
1825	>	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1826	>	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1827	>	_v = 1;
1828	>	else
1829	>	_v = 0;
1830	>	}
1831	>	}
1832	>	if (_v) {
1833	>	return _wrap_new_vector_string__SWIG_2(self,args);
1834		}
7768	–	}
7769	–	catch(std::out_of_range &_e) {
7770	–	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7771	–	}
7772	–
7773	–	} catch (const std::exception& e) {
7774	–	SWIG_exception(SWIG_RuntimeError, e.what());
7775	–	}
7776	–	}
7777	–	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
7778	–	return resultobj;
7779	–	fail:
7780	–	return NULL;
7781	–	}
7782	–
7783	–
7784	–	SWIGINTERN PyObject *_wrap_vector_string___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7785	–	PyObject *resultobj = 0;
7786	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7787	–	std::vector<std::string >::difference_type arg2 ;
7788	–	std::vector<std::string >::value_type *arg3 = 0 ;
7789	–	void *argp1 = 0 ;
7790	–	int res1 = 0 ;
7791	–	ptrdiff_t val2 ;
7792	–	int ecode2 = 0 ;
7793	–	int res3 = SWIG_OLDOBJ ;
7794	–	PyObject * obj0 = 0 ;
7795	–	PyObject * obj1 = 0 ;
7796	–	PyObject * obj2 = 0 ;
7797	–
7798	–	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
7799	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7800	–	if (!SWIG_IsOK(res1)) {
7801	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___setitem__" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7802	–	}
7803	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7804	–	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7805	–	if (!SWIG_IsOK(ecode2)) {
7806	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string___setitem__" "', argument " "2"" of type '" "std::vector<std::string >::difference_type""'");
7807	–	}
7808	–	arg2 = static_cast< std::vector<std::string >::difference_type >(val2);
7809	–	{
7810	–	std::string *ptr = (std::string *)0;
7811	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
7812	–	if (!SWIG_IsOK(res3)) {
7813	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_string___setitem__" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
7814	–	}
7815	–	if (!ptr) {
7816	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string___setitem__" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
7817	–	}
7818	–	arg3 = ptr;
7819	–	}
7820	–	{
7821	–	try {
7822	–	try {
7823	–	std_vector_Sl_std_string_Sg____setitem__(arg1,arg2,(std::string const &)*arg3);
7824	–	}
7825	–	catch(std::out_of_range &_e) {
7826	–	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7827	–	}
7828	–
7829	–	} catch (const std::exception& e) {
7830	–	SWIG_exception(SWIG_RuntimeError, e.what());
7831	–	}
7832	–	}
7833	–	resultobj = SWIG_Py_Void();
7834	–	if (SWIG_IsNewObj(res3)) delete arg3;
7835	–	return resultobj;
7836	–	fail:
7837	–	if (SWIG_IsNewObj(res3)) delete arg3;
7838	–	return NULL;
7839	–	}
7840	–
7841	–
7842	–	SWIGINTERN PyObject *_wrap_vector_string_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7843	–	PyObject *resultobj = 0;
7844	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7845	–	std::vector<std::string >::value_type *arg2 = 0 ;
7846	–	void *argp1 = 0 ;
7847	–	int res1 = 0 ;
7848	–	int res2 = SWIG_OLDOBJ ;
7849	–	PyObject * obj0 = 0 ;
7850	–	PyObject * obj1 = 0 ;
7851	–
7852	–	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) SWIG_fail;
7853	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7854	–	if (!SWIG_IsOK(res1)) {
7855	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_append" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7856	–	}
7857	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7858	–	{
7859	–	std::string *ptr = (std::string *)0;
7860	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7861	–	if (!SWIG_IsOK(res2)) {
7862	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vector_string_append" "', argument " "2"" of type '" "std::vector<std::string >::value_type const &""'");
7863	–	}
7864	–	if (!ptr) {
7865	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_append" "', argument " "2"" of type '" "std::vector<std::string >::value_type const &""'");
7866	–	}
7867	–	arg2 = ptr;
7868	–	}
7869	–	{
7870	–	try {
7871	–	std_vector_Sl_std_string_Sg__append(arg1,(std::string const &)*arg2);
7872	–	} catch (const std::exception& e) {
7873	–	SWIG_exception(SWIG_RuntimeError, e.what());
7874	–	}
7875	–	}
7876	–	resultobj = SWIG_Py_Void();
7877	–	if (SWIG_IsNewObj(res2)) delete arg2;
7878	–	return resultobj;
7879	–	fail:
7880	–	if (SWIG_IsNewObj(res2)) delete arg2;
7881	–	return NULL;
7882	–	}
7883	–
7884	–
7885	–	SWIGINTERN PyObject *_wrap_new_vector_string__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7886	–	PyObject *resultobj = 0;
7887	–	std::vector<std::string > *result = 0 ;
7888	–
7889	–	if (!PyArg_ParseTuple(args,(char *)":new_vector_string")) SWIG_fail;
7890	–	{
7891	–	try {
7892	–	result = (std::vector<std::string > *)new std::vector<std::string >();
7893	–	} catch (const std::exception& e) {
7894	–	SWIG_exception(SWIG_RuntimeError, e.what());
7895	–	}
7896	–	}
7897	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
7898	–	return resultobj;
7899	–	fail:
7900	–	return NULL;
7901	–	}
7902	–
7903	–
7904	–	SWIGINTERN PyObject *_wrap_new_vector_string__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7905	–	PyObject *resultobj = 0;
7906	–	std::vector<std::string > *arg1 = 0 ;
7907	–	std::vector<std::string > *result = 0 ;
7908	–	int res1 = SWIG_OLDOBJ ;
7909	–	PyObject * obj0 = 0 ;
7910	–
7911	–	if (!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) SWIG_fail;
7912	–	{
7913	–	std::vector<std::string,std::allocator<std::string > > *ptr = (std::vector<std::string,std::allocator<std::string > > *)0;
7914	–	res1 = swig::asptr(obj0, &ptr);
7915	–	if (!SWIG_IsOK(res1)) {
7916	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_string" "', argument " "1"" of type '" "std::vector<std::string > const &""'");
7917	–	}
7918	–	if (!ptr) {
7919	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vector_string" "', argument " "1"" of type '" "std::vector<std::string > const &""'");
7920	–	}
7921	–	arg1 = ptr;
7922	–	}
7923	–	{
7924	–	try {
7925	–	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
7926	–	} catch (const std::exception& e) {
7927	–	SWIG_exception(SWIG_RuntimeError, e.what());
7928	–	}
7929	–	}
7930	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
7931	–	if (SWIG_IsNewObj(res1)) delete arg1;
7932	–	return resultobj;
7933	–	fail:
7934	–	if (SWIG_IsNewObj(res1)) delete arg1;
7935	–	return NULL;
7936	–	}
7937	–
7938	–
7939	–	SWIGINTERN PyObject *_wrap_vector_string_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7940	–	PyObject *resultobj = 0;
7941	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7942	–	bool result;
7943	–	void *argp1 = 0 ;
7944	–	int res1 = 0 ;
7945	–	PyObject * obj0 = 0 ;
7946	–
7947	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_empty",&obj0)) SWIG_fail;
7948	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7949	–	if (!SWIG_IsOK(res1)) {
7950	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_empty" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
7951	–	}
7952	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7953	–	{
7954	–	try {
7955	–	result = (bool)((std::vector<std::string > const *)arg1)->empty();
7956	–	} catch (const std::exception& e) {
7957	–	SWIG_exception(SWIG_RuntimeError, e.what());
7958	–	}
7959	–	}
7960	–	resultobj = SWIG_From_bool(static_cast< bool >(result));
7961	–	return resultobj;
7962	–	fail:
7963	–	return NULL;
7964	–	}
7965	–
7966	–
7967	–	SWIGINTERN PyObject *_wrap_vector_string_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7968	–	PyObject *resultobj = 0;
7969	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7970	–	std::vector<std::string >::size_type result;
7971	–	void *argp1 = 0 ;
7972	–	int res1 = 0 ;
7973	–	PyObject * obj0 = 0 ;
7974	–
7975	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_size",&obj0)) SWIG_fail;
7976	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7977	–	if (!SWIG_IsOK(res1)) {
7978	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_size" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
7979	–	}
7980	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7981	–	{
7982	–	try {
7983	–	result = ((std::vector<std::string > const *)arg1)->size();
7984	–	} catch (const std::exception& e) {
7985	–	SWIG_exception(SWIG_RuntimeError, e.what());
7986	–	}
7987	–	}
7988	–	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7989	–	return resultobj;
7990	–	fail:
7991	–	return NULL;
7992	–	}
7993	–
7994	–
7995	–	SWIGINTERN PyObject *_wrap_vector_string_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7996	–	PyObject *resultobj = 0;
7997	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7998	–	void *argp1 = 0 ;
7999	–	int res1 = 0 ;
8000	–	PyObject * obj0 = 0 ;
8001	–
8002	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) SWIG_fail;
8003	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8004	–	if (!SWIG_IsOK(res1)) {
8005	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_clear" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8006	–	}
8007	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8008	–	{
8009	–	try {
8010	–	(arg1)->clear();
8011	–	} catch (const std::exception& e) {
8012	–	SWIG_exception(SWIG_RuntimeError, e.what());
8013	–	}
8014	–	}
8015	–	resultobj = SWIG_Py_Void();
8016	–	return resultobj;
8017	–	fail:
8018	–	return NULL;
8019	–	}
8020	–
8021	–
8022	–	SWIGINTERN PyObject *_wrap_vector_string_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023	–	PyObject *resultobj = 0;
8024	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8025	–	std::vector<std::string > *arg2 = 0 ;
8026	–	void *argp1 = 0 ;
8027	–	int res1 = 0 ;
8028	–	void *argp2 = 0 ;
8029	–	int res2 = 0 ;
8030	–	PyObject * obj0 = 0 ;
8031	–	PyObject * obj1 = 0 ;
8032	–
8033	–	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_swap",&obj0,&obj1)) SWIG_fail;
8034	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8035	–	if (!SWIG_IsOK(res1)) {
8036	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_swap" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8037	–	}
8038	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8039	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t,  0 );
8040	–	if (!SWIG_IsOK(res2)) {
8041	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vector_string_swap" "', argument " "2"" of type '" "std::vector<std::string > &""'");
8042	–	}
8043	–	if (!argp2) {
8044	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_swap" "', argument " "2"" of type '" "std::vector<std::string > &""'");
8045	–	}
8046	–	arg2 = reinterpret_cast< std::vector<std::string > * >(argp2);
8047	–	{
8048	–	try {
8049	–	(arg1)->swap(*arg2);
8050	–	} catch (const std::exception& e) {
8051	–	SWIG_exception(SWIG_RuntimeError, e.what());
8052	–	}
8053	–	}
8054	–	resultobj = SWIG_Py_Void();
8055	–	return resultobj;
8056	–	fail:
8057	–	return NULL;
8058	–	}
8059	–
8060	–
8061	–	SWIGINTERN PyObject *_wrap_vector_string_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8062	–	PyObject *resultobj = 0;
8063	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8064	–	SwigValueWrapper<std::allocator<std::string > > result;
8065	–	void *argp1 = 0 ;
8066	–	int res1 = 0 ;
8067	–	PyObject * obj0 = 0 ;
8068	–
8069	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_get_allocator",&obj0)) SWIG_fail;
8070	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8071	–	if (!SWIG_IsOK(res1)) {
8072	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_get_allocator" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
8073	–	}
8074	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8075	–	{
8076	–	try {
8077	–	result = ((std::vector<std::string > const *)arg1)->get_allocator();
8078	–	} catch (const std::exception& e) {
8079	–	SWIG_exception(SWIG_RuntimeError, e.what());
8080	–	}
8081	–	}
8082	–	resultobj = SWIG_NewPointerObj((new std::vector<std::string >::allocator_type(static_cast< const std::vector<std::string >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
8083	–	return resultobj;
8084	–	fail:
8085	–	return NULL;
8086	–	}
8087	–
8088	–
8089	–	SWIGINTERN PyObject *_wrap_vector_string_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8090	–	PyObject *resultobj = 0;
8091	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8092	–	std::vector<std::string >::iterator result;
8093	–	void *argp1 = 0 ;
8094	–	int res1 = 0 ;
8095	–	PyObject * obj0 = 0 ;
8096	–
8097	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_begin",&obj0)) SWIG_fail;
8098	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8099	–	if (!SWIG_IsOK(res1)) {
8100	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_begin" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8101	–	}
8102	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8103	–	{
8104	–	try {
8105	–	result = (arg1)->begin();
8106	–	} catch (const std::exception& e) {
8107	–	SWIG_exception(SWIG_RuntimeError, e.what());
8108	–	}
8109	–	}
8110	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
8111	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8112	–	return resultobj;
8113	–	fail:
8114	–	return NULL;
8115	–	}
8116	–
8117	–
8118	–	SWIGINTERN PyObject *_wrap_vector_string_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8119	–	PyObject *resultobj = 0;
8120	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8121	–	std::vector<std::string >::const_iterator result;
8122	–	void *argp1 = 0 ;
8123	–	int res1 = 0 ;
8124	–	PyObject * obj0 = 0 ;
8125	–
8126	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_begin",&obj0)) SWIG_fail;
8127	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8128	–	if (!SWIG_IsOK(res1)) {
8129	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_begin" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
8130	–	}
8131	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8132	–	{
8133	–	try {
8134	–	result = ((std::vector<std::string > const *)arg1)->begin();
8135	–	} catch (const std::exception& e) {
8136	–	SWIG_exception(SWIG_RuntimeError, e.what());
8137	–	}
8138	–	}
8139	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::const_iterator & >(result)),
8140	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8141	–	return resultobj;
8142	–	fail:
8143	–	return NULL;
8144	–	}
8145	–
8146	–
8147	–	SWIGINTERN PyObject *_wrap_vector_string_begin(PyObject *self, PyObject *args) {
8148	–	int argc;
8149	–	PyObject *argv[2];
8150	–	int ii;
8151	–
8152	–	if (!PyTuple_Check(args)) SWIG_fail;
8153	–	argc = PyObject_Length(args);
8154	–	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
8155	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
8156	–	}
8157	–	if (argc == 1) {
8158	–	int _v;
8159	–	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8160	–	_v = SWIG_CheckState(res);
8161	–	if (_v) {
8162	–	return _wrap_vector_string_begin__SWIG_0(self, args);
8163	–	}
8164	–	}
8165	–	if (argc == 1) {
8166	–	int _v;
8167	–	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8168	–	_v = SWIG_CheckState(res);
8169	–	if (_v) {
8170	–	return _wrap_vector_string_begin__SWIG_1(self, args);
8171	–	}
8172	–	}
8173	–
8174	–	fail:
8175	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_begin'");
8176	–	return NULL;
8177	–	}
8178	–
8179	–
8180	–	SWIGINTERN PyObject *_wrap_vector_string_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8181	–	PyObject *resultobj = 0;
8182	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8183	–	std::vector<std::string >::iterator result;
8184	–	void *argp1 = 0 ;
8185	–	int res1 = 0 ;
8186	–	PyObject * obj0 = 0 ;
8187	–
8188	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_end",&obj0)) SWIG_fail;
8189	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8190	–	if (!SWIG_IsOK(res1)) {
8191	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_end" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8192	–	}
8193	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8194	–	{
8195	–	try {
8196	–	result = (arg1)->end();
8197	–	} catch (const std::exception& e) {
8198	–	SWIG_exception(SWIG_RuntimeError, e.what());
8199	–	}
8200	–	}
8201	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
8202	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8203	–	return resultobj;
8204	–	fail:
8205	–	return NULL;
8206	–	}
8207	–
8208	–
8209	–	SWIGINTERN PyObject *_wrap_vector_string_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8210	–	PyObject *resultobj = 0;
8211	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8212	–	std::vector<std::string >::const_iterator result;
8213	–	void *argp1 = 0 ;
8214	–	int res1 = 0 ;
8215	–	PyObject * obj0 = 0 ;
8216	–
8217	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_end",&obj0)) SWIG_fail;
8218	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8219	–	if (!SWIG_IsOK(res1)) {
8220	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_end" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
8221	–	}
8222	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8223	–	{
8224	–	try {
8225	–	result = ((std::vector<std::string > const *)arg1)->end();
8226	–	} catch (const std::exception& e) {
8227	–	SWIG_exception(SWIG_RuntimeError, e.what());
8228	–	}
8229	–	}
8230	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::const_iterator & >(result)),
8231	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8232	–	return resultobj;
8233	–	fail:
8234	–	return NULL;
8235	–	}
8236	–
8237	–
8238	–	SWIGINTERN PyObject *_wrap_vector_string_end(PyObject *self, PyObject *args) {
8239	–	int argc;
8240	–	PyObject *argv[2];
8241	–	int ii;
8242	–
8243	–	if (!PyTuple_Check(args)) SWIG_fail;
8244	–	argc = PyObject_Length(args);
8245	–	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
8246	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
8247	–	}
8248	–	if (argc == 1) {
8249	–	int _v;
8250	–	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8251	–	_v = SWIG_CheckState(res);
8252	–	if (_v) {
8253	–	return _wrap_vector_string_end__SWIG_0(self, args);
8254	–	}
8255	–	}
8256	–	if (argc == 1) {
8257	–	int _v;
8258	–	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8259	–	_v = SWIG_CheckState(res);
8260	–	if (_v) {
8261	–	return _wrap_vector_string_end__SWIG_1(self, args);
8262	–	}
8263	–	}
8264	–
8265	–	fail:
8266	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_end'");
8267	–	return NULL;
8268	–	}
8269	–
8270	–
8271	–	SWIGINTERN PyObject *_wrap_vector_string_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8272	–	PyObject *resultobj = 0;
8273	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8274	–	std::vector<std::string >::reverse_iterator result;
8275	–	void *argp1 = 0 ;
8276	–	int res1 = 0 ;
8277	–	PyObject * obj0 = 0 ;
8278	–
8279	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_rbegin",&obj0)) SWIG_fail;
8280	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8281	–	if (!SWIG_IsOK(res1)) {
8282	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_rbegin" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8283	–	}
8284	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8285	–	{
8286	–	try {
8287	–	result = (arg1)->rbegin();
8288	–	} catch (const std::exception& e) {
8289	–	SWIG_exception(SWIG_RuntimeError, e.what());
8290	–	}
8291	–	}
8292	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::reverse_iterator & >(result)),
8293	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8294	–	return resultobj;
8295	–	fail:
8296	–	return NULL;
8297	–	}
8298	–
8299	–
8300	–	SWIGINTERN PyObject *_wrap_vector_string_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8301	–	PyObject *resultobj = 0;
8302	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8303	–	std::vector<std::string >::const_reverse_iterator result;
8304	–	void *argp1 = 0 ;
8305	–	int res1 = 0 ;
8306	–	PyObject * obj0 = 0 ;
8307	–
8308	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_rbegin",&obj0)) SWIG_fail;
8309	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8310	–	if (!SWIG_IsOK(res1)) {
8311	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_rbegin" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
8312	–	}
8313	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8314	–	{
8315	–	try {
8316	–	result = ((std::vector<std::string > const *)arg1)->rbegin();
8317	–	} catch (const std::exception& e) {
8318	–	SWIG_exception(SWIG_RuntimeError, e.what());
8319	–	}
8320	–	}
8321	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::const_reverse_iterator & >(result)),
8322	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8323	–	return resultobj;
8324	–	fail:
8325	–	return NULL;
8326	–	}
8327	–
8328	–
8329	–	SWIGINTERN PyObject *_wrap_vector_string_rbegin(PyObject *self, PyObject *args) {
8330	–	int argc;
8331	–	PyObject *argv[2];
8332	–	int ii;
8333	–
8334	–	if (!PyTuple_Check(args)) SWIG_fail;
8335	–	argc = PyObject_Length(args);
8336	–	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
8337	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
8338	–	}
8339	–	if (argc == 1) {
8340	–	int _v;
8341	–	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8342	–	_v = SWIG_CheckState(res);
8343	–	if (_v) {
8344	–	return _wrap_vector_string_rbegin__SWIG_0(self, args);
8345	–	}
8346	–	}
8347	–	if (argc == 1) {
8348	–	int _v;
8349	–	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8350	–	_v = SWIG_CheckState(res);
8351	–	if (_v) {
8352	–	return _wrap_vector_string_rbegin__SWIG_1(self, args);
8353	–	}
8354	–	}
8355	–
8356	–	fail:
8357	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_rbegin'");
8358	–	return NULL;
8359	–	}
8360	–
8361	–
8362	–	SWIGINTERN PyObject *_wrap_vector_string_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8363	–	PyObject *resultobj = 0;
8364	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8365	–	std::vector<std::string >::reverse_iterator result;
8366	–	void *argp1 = 0 ;
8367	–	int res1 = 0 ;
8368	–	PyObject * obj0 = 0 ;
8369	–
8370	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_rend",&obj0)) SWIG_fail;
8371	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8372	–	if (!SWIG_IsOK(res1)) {
8373	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_rend" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8374	–	}
8375	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8376	–	{
8377	–	try {
8378	–	result = (arg1)->rend();
8379	–	} catch (const std::exception& e) {
8380	–	SWIG_exception(SWIG_RuntimeError, e.what());
8381	–	}
8382	–	}
8383	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::reverse_iterator & >(result)),
8384	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8385	–	return resultobj;
8386	–	fail:
8387	–	return NULL;
8388	–	}
8389	–
8390	–
8391	–	SWIGINTERN PyObject *_wrap_vector_string_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8392	–	PyObject *resultobj = 0;
8393	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8394	–	std::vector<std::string >::const_reverse_iterator result;
8395	–	void *argp1 = 0 ;
8396	–	int res1 = 0 ;
8397	–	PyObject * obj0 = 0 ;
8398	–
8399	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_rend",&obj0)) SWIG_fail;
8400	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8401	–	if (!SWIG_IsOK(res1)) {
8402	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_rend" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
8403	–	}
8404	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8405	–	{
8406	–	try {
8407	–	result = ((std::vector<std::string > const *)arg1)->rend();
8408	–	} catch (const std::exception& e) {
8409	–	SWIG_exception(SWIG_RuntimeError, e.what());
8410	–	}
8411	–	}
8412	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::const_reverse_iterator & >(result)),
8413	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8414	–	return resultobj;
8415	–	fail:
8416	–	return NULL;
8417	–	}
8418	–
8419	–
8420	–	SWIGINTERN PyObject *_wrap_vector_string_rend(PyObject *self, PyObject *args) {
8421	–	int argc;
8422	–	PyObject *argv[2];
8423	–	int ii;
8424	–
8425	–	if (!PyTuple_Check(args)) SWIG_fail;
8426	–	argc = PyObject_Length(args);
8427	–	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
8428	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
8429	–	}
8430	–	if (argc == 1) {
8431	–	int _v;
8432	–	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8433	–	_v = SWIG_CheckState(res);
8434	–	if (_v) {
8435	–	return _wrap_vector_string_rend__SWIG_0(self, args);
8436	–	}
8437	–	}
8438	–	if (argc == 1) {
8439	–	int _v;
8440	–	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8441	–	_v = SWIG_CheckState(res);
8442	–	if (_v) {
8443	–	return _wrap_vector_string_rend__SWIG_1(self, args);
1835		}
1836	<	}
1837	<
1838	<	fail:
1839	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_rend'");
1840	<	return NULL;
1841	<	}
1842	<
1843	<
1844	<	SWIGINTERN PyObject *_wrap_new_vector_string__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1845	<	PyObject *resultobj = 0;
1846	<	std::vector<std::string >::size_type arg1 ;
1847	<	std::vector<std::string > *result = 0 ;
1848	<	size_t val1 ;
8458	<	int ecode1 = 0 ;
8459	<	PyObject * obj0 = 0 ;
8460	<
8461	<	if (!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) SWIG_fail;
8462	<	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
8463	<	if (!SWIG_IsOK(ecode1)) {
8464	<	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vector_string" "', argument " "1"" of type '" "std::vector<std::string >::size_type""'");
8465	<	}
8466	<	arg1 = static_cast< std::vector<std::string >::size_type >(val1);
8467	<	{
8468	<	try {
8469	<	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
8470	<	} catch (const std::exception& e) {
8471	<	SWIG_exception(SWIG_RuntimeError, e.what());
1836	>	if (argc == 2) {
1837	>	int _v;
1838	>	{
1839	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1840	>	}
1841	>	if (_v) {
1842	>	{
1843	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1844	>	}
1845	>	if (_v) {
1846	>	return _wrap_new_vector_string__SWIG_1(self,args);
1847	>	}
1848	>	}
1849		}
1850	<	}
1851	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
1852	<	return resultobj;
8476	<	fail:
8477	<	return NULL;
1850	>
1851	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1852	>	return NULL;
1853		}
1854
1855
1856	<	SWIGINTERN PyObject *_wrap_vector_string_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1857	<	PyObject *resultobj = 0;
1858	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1859	<	void *argp1 = 0 ;
1860	<	int res1 = 0 ;
1861	<	PyObject * obj0 = 0 ;
1862	<
1863	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_pop_back",&obj0)) SWIG_fail;
1864	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
1865	<	if (!SWIG_IsOK(res1)) {
1866	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_pop_back" "', argument " "1"" of type '" "std::vector<std::string > *""'");
1867	<	}
1868	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
1869	<	{
1870	<	try {
1871	<	(arg1)->pop_back();
1872	<	} catch (const std::exception& e) {
1873	<	SWIG_exception(SWIG_RuntimeError, e.what());
1856	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1857	>	PyObject *resultobj;
1858	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1859	>	unsigned int result;
1860	>	std::vector<std::string > temp1 ;
1861	>	std::vector<std::string > *v1 ;
1862	>	PyObject * obj0 = 0 ;
1863	>
1864	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1865	>	{
1866	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1867	>	unsigned int size = (PyTuple_Check(obj0) ?
1868	>	PyTuple_Size(obj0) :
1869	>	PyList_Size(obj0));
1870	>	temp1 = std::vector<std::string >(size);
1871	>	arg1 = &temp1;
1872	>	for (unsigned int i=0; i<size; i++) {
1873	>	PyObject* o = PySequence_GetItem(obj0,i);
1874	>	if (PyString_Check(o)) {
1875	>	temp1[i] = (std::string)(\
1876	>	SwigString_AsString(o));
1877	>	Py_DECREF(o);
1878	>	}else {
1879	>	Py_DECREF(o);
1880	>	PyErr_SetString(PyExc_TypeError,
1881	>	"vector<""std::string""> expected");
1882	>	SWIG_fail;
1883	>	}
1884	>	}
1885	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1886	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1887	>	arg1 = v1;
1888	>	}else {
1889	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1890	>	SWIG_fail;
1891	>	}
1892		}
1893	<	}
1894	<	resultobj = SWIG_Py_Void();
1895	<	return resultobj;
1896	<	fail:
1897	<	return NULL;
1898	<	}
1899	<
1900	<
1901	<	SWIGINTERN PyObject *_wrap_vector_string_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1902	<	PyObject *resultobj = 0;
1903	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8511	<	std::vector<std::string >::size_type arg2 ;
8512	<	void *argp1 = 0 ;
8513	<	int res1 = 0 ;
8514	<	size_t val2 ;
8515	<	int ecode2 = 0 ;
8516	<	PyObject * obj0 = 0 ;
8517	<	PyObject * obj1 = 0 ;
8518	<
8519	<	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_resize",&obj0,&obj1)) SWIG_fail;
8520	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8521	<	if (!SWIG_IsOK(res1)) {
8522	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_resize" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8523	<	}
8524	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8525	<	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8526	<	if (!SWIG_IsOK(ecode2)) {
8527	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string_resize" "', argument " "2"" of type '" "std::vector<std::string >::size_type""'");
8528	<	}
8529	<	arg2 = static_cast< std::vector<std::string >::size_type >(val2);
8530	<	{
8531	<	try {
8532	<	(arg1)->resize(arg2);
8533	<	} catch (const std::exception& e) {
8534	<	SWIG_exception(SWIG_RuntimeError, e.what());
1893	>	{
1894	>	try {
1895	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1896	>
1897	>	}catch (const BossSchedFailure & e) {
1898	>	PyErr_SetString ( SchedulerError, e.what() );
1899	>	return NULL;
1900	>	}catch (const std::exception& e) {
1901	>	PyErr_SetString ( BossError, e.what() );
1902	>	return NULL;
1903	>	}
1904		}
1905	<	}
1906	<	resultobj = SWIG_Py_Void();
1907	<	return resultobj;
1908	<	fail:
8540	<	return NULL;
1905	>	resultobj = PyInt_FromLong((long)result);
1906	>	return resultobj;
1907	>	fail:
1908	>	return NULL;
1909		}
1910
1911
1912	<	SWIGINTERN PyObject *_wrap_vector_string_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1913	<	PyObject *resultobj = 0;
1914	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1915	<	std::vector<std::string >::iterator arg2 ;
1916	<	std::vector<std::string >::iterator result;
1917	<	void *argp1 = 0 ;
1918	<	int res1 = 0 ;
1919	<	swig::PySwigIterator *iter2 = 0 ;
1920	<	int res2 ;
1921	<	PyObject * obj0 = 0 ;
1922	<	PyObject * obj1 = 0 ;
1923	<
1924	<	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_erase",&obj0,&obj1)) SWIG_fail;
1925	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
1926	<	if (!SWIG_IsOK(res1)) {
1927	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_erase" "', argument " "1"" of type '" "std::vector<std::string > *""'");
1928	<	}
1929	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
1930	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
1931	<	if (!SWIG_IsOK(res2) || !iter2) {
1932	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_erase" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
1933	<	} else {
1934	<	swig::PySwigIterator_T<std::vector<std::string >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter2);
1935	<	if (iter_t) {
1936	<	arg2 = iter_t->get_current();
1937	<	} else {
1938	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_erase" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
1912	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1913	>	PyObject *resultobj;
1914	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1915	>	bool result;
1916	>	std::vector<std::string > temp1 ;
1917	>	std::vector<std::string > *v1 ;
1918	>	PyObject * obj0 = 0 ;
1919	>
1920	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1921	>	{
1922	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1923	>	unsigned int size = (PyTuple_Check(obj0) ?
1924	>	PyTuple_Size(obj0) :
1925	>	PyList_Size(obj0));
1926	>	temp1 = std::vector<std::string >(size);
1927	>	arg1 = &temp1;
1928	>	for (unsigned int i=0; i<size; i++) {
1929	>	PyObject* o = PySequence_GetItem(obj0,i);
1930	>	if (PyString_Check(o)) {
1931	>	temp1[i] = (std::string)(\
1932	>	SwigString_AsString(o));
1933	>	Py_DECREF(o);
1934	>	}else {
1935	>	Py_DECREF(o);
1936	>	PyErr_SetString(PyExc_TypeError,
1937	>	"vector<""std::string""> expected");
1938	>	SWIG_fail;
1939	>	}
1940	>	}
1941	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1942	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1943	>	arg1 = v1;
1944	>	}else {
1945	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1946	>	SWIG_fail;
1947	>	}
1948		}
1949	<	}
1950	<	{
1951	<	try {
1952	<	result = (arg1)->erase(arg2);
1953	<	} catch (const std::exception& e) {
1954	<	SWIG_exception(SWIG_RuntimeError, e.what());
1949	>	{
1950	>	try {
1951	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1952	>
1953	>	}catch (const BossSchedFailure & e) {
1954	>	PyErr_SetString ( SchedulerError, e.what() );
1955	>	return NULL;
1956	>	}catch (const std::exception& e) {
1957	>	PyErr_SetString ( BossError, e.what() );
1958	>	return NULL;
1959	>	}
1960		}
1961	<	}
1962	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
1963	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1964	<	return resultobj;
8583	<	fail:
8584	<	return NULL;
1961	>	resultobj = PyInt_FromLong((long)result);
1962	>	return resultobj;
1963	>	fail:
1964	>	return NULL;
1965		}
1966
1967
1968	<	SWIGINTERN PyObject *_wrap_vector_string_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1969	<	PyObject *resultobj = 0;
1970	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1971	<	std::vector<std::string >::iterator arg2 ;
1972	<	std::vector<std::string >::iterator arg3 ;
1973	<	std::vector<std::string >::iterator result;
1974	<	void *argp1 = 0 ;
1975	<	int res1 = 0 ;
1976	<	swig::PySwigIterator *iter2 = 0 ;
1977	<	int res2 ;
1978	<	swig::PySwigIterator *iter3 = 0 ;
1979	<	int res3 ;
1980	<	PyObject * obj0 = 0 ;
1981	<	PyObject * obj1 = 0 ;
1982	<	PyObject * obj2 = 0 ;
1983	<
1984	<	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_erase",&obj0,&obj1,&obj2)) SWIG_fail;
1985	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8606	<	if (!SWIG_IsOK(res1)) {
8607	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_erase" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8608	<	}
8609	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8610	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
8611	<	if (!SWIG_IsOK(res2) || !iter2) {
8612	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_erase" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
8613	<	} else {
8614	<	swig::PySwigIterator_T<std::vector<std::string >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter2);
8615	<	if (iter_t) {
8616	<	arg2 = iter_t->get_current();
8617	<	} else {
8618	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_erase" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
8619	<	}
8620	<	}
8621	<	res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
8622	<	if (!SWIG_IsOK(res3) || !iter3) {
8623	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_erase" "', argument " "3"" of type '" "std::vector<std::string >::iterator""'");
8624	<	} else {
8625	<	swig::PySwigIterator_T<std::vector<std::string >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter3);
8626	<	if (iter_t) {
8627	<	arg3 = iter_t->get_current();
8628	<	} else {
8629	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_erase" "', argument " "3"" of type '" "std::vector<std::string >::iterator""'");
8630	<	}
8631	<	}
8632	<	{
8633	<	try {
8634	<	result = (arg1)->erase(arg2,arg3);
8635	<	} catch (const std::exception& e) {
8636	<	SWIG_exception(SWIG_RuntimeError, e.what());
1968	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1969	>	PyObject *resultobj;
1970	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1971	>	PyObject * obj0 = 0 ;
1972	>
1973	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1974	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1975	>	{
1976	>	try {
1977	>	(arg1)->clear();
1978	>
1979	>	}catch (const BossSchedFailure & e) {
1980	>	PyErr_SetString ( SchedulerError, e.what() );
1981	>	return NULL;
1982	>	}catch (const std::exception& e) {
1983	>	PyErr_SetString ( BossError, e.what() );
1984	>	return NULL;
1985	>	}
1986		}
1987	<	}
1988	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
1989	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1990	<	return resultobj;
8642	<	fail:
8643	<	return NULL;
1987	>	Py_INCREF(Py_None); resultobj = Py_None;
1988	>	return resultobj;
1989	>	fail:
1990	>	return NULL;
1991		}
1992
1993
1994	<	SWIGINTERN PyObject *_wrap_vector_string_erase(PyObject *self, PyObject *args) {
1995	<	int argc;
1996	<	PyObject *argv[4];
1997	<	int ii;
1998	<
1999	<	if (!PyTuple_Check(args)) SWIG_fail;
2000	<	argc = PyObject_Length(args);
2001	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
2002	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2003	<	}
2004	<	if (argc == 2) {
2005	<	int _v;
2006	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2007	<	_v = SWIG_CheckState(res);
8661	<	if (_v) {
8662	<	swig::PySwigIterator *iter = 0;
8663	<	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8664	<	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter) != 0));
8665	<	if (_v) {
8666	<	return _wrap_vector_string_erase__SWIG_0(self, args);
8667	<	}
1994	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1995	>	PyObject *resultobj;
1996	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1997	>	std::string arg2 ;
1998	>	PyObject * obj0 = 0 ;
1999	>	PyObject * obj1 = 0 ;
2000	>
2001	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
2002	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2003	>	{
2004	>	if (PyString_Check(obj1))
2005	>	arg2 = std::string(PyString_AsString(obj1));
2006	>	else
2007	>	SWIG_exception(SWIG_TypeError, "string expected");
2008		}
2009	<	}
2010	<	if (argc == 3) {
2011	<	int _v;
2012	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2013	<	_v = SWIG_CheckState(res);
2014	<	if (_v) {
2015	<	swig::PySwigIterator *iter = 0;
2016	<	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
2017	<	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter) != 0));
2018	<	if (_v) {
8679	<	swig::PySwigIterator *iter = 0;
8680	<	int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8681	<	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter) != 0));
8682	<	if (_v) {
8683	<	return _wrap_vector_string_erase__SWIG_1(self, args);
2009	>	{
2010	>	try {
2011	>	(arg1)->push_back(arg2);
2012	>
2013	>	}catch (const BossSchedFailure & e) {
2014	>	PyErr_SetString ( SchedulerError, e.what() );
2015	>	return NULL;
2016	>	}catch (const std::exception& e) {
2017	>	PyErr_SetString ( BossError, e.what() );
2018	>	return NULL;
2019		}
8685	–	}
2020		}
2021	<	}
2022	<
2023	<	fail:
2024	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_erase'");
8691	<	return NULL;
2021	>	Py_INCREF(Py_None); resultobj = Py_None;
2022	>	return resultobj;
2023	>	fail:
2024	>	return NULL;
2025		}
2026
2027
2028	<	SWIGINTERN PyObject *_wrap_new_vector_string__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2029	<	PyObject *resultobj = 0;
2030	<	std::vector<std::string >::size_type arg1 ;
2031	<	std::vector<std::string >::value_type *arg2 = 0 ;
2032	<	std::vector<std::string > *result = 0 ;
2033	<	size_t val1 ;
2034	<	int ecode1 = 0 ;
2035	<	int res2 = SWIG_OLDOBJ ;
2036	<	PyObject * obj0 = 0 ;
2037	<	PyObject * obj1 = 0 ;
2038	<
2039	<	if (!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) SWIG_fail;
2040	<	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
2041	<	if (!SWIG_IsOK(ecode1)) {
2042	<	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vector_string" "', argument " "1"" of type '" "std::vector<std::string >::size_type""'");
8710	<	}
8711	<	arg1 = static_cast< std::vector<std::string >::size_type >(val1);
8712	<	{
8713	<	std::string *ptr = (std::string *)0;
8714	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
8715	<	if (!SWIG_IsOK(res2)) {
8716	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vector_string" "', argument " "2"" of type '" "std::vector<std::string >::value_type const &""'");
8717	<	}
8718	<	if (!ptr) {
8719	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vector_string" "', argument " "2"" of type '" "std::vector<std::string >::value_type const &""'");
2028	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
2029	>	PyObject *resultobj;
2030	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2031	>	std::string result;
2032	>	PyObject * obj0 = 0 ;
2033	>
2034	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
2035	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2036	>	{
2037	>	try {
2038	>	result = std_vectorlstd_string_g_pop___(arg1);
2039	>
2040	>	}catch (std::out_of_range& e) {
2041	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2042	>	}
2043		}
2044	<	arg2 = ptr;
2045	<	}
8723	<	{
8724	<	try {
8725	<	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::vector<std::string >::value_type const &)*arg2);
8726	<	} catch (const std::exception& e) {
8727	<	SWIG_exception(SWIG_RuntimeError, e.what());
2044	>	{
2045	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2046		}
2047	<	}
2048	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
2049	<	if (SWIG_IsNewObj(res2)) delete arg2;
8732	<	return resultobj;
8733	<	fail:
8734	<	if (SWIG_IsNewObj(res2)) delete arg2;
8735	<	return NULL;
2047	>	return resultobj;
2048	>	fail:
2049	>	return NULL;
2050		}
2051
2052
2053	<	SWIGINTERN PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
2054	<	int argc;
2055	<	PyObject *argv[3];
2056	<	int ii;
2057	<
2058	<	if (!PyTuple_Check(args)) SWIG_fail;
2059	<	argc = PyObject_Length(args);
2060	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
2061	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
8748	<	}
8749	<	if (argc == 0) {
8750	<	return _wrap_new_vector_string__SWIG_0(self, args);
8751	<	}
8752	<	if (argc == 1) {
8753	<	int _v;
2053	>	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
2054	>	PyObject *resultobj;
2055	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2056	>	int arg2 ;
2057	>	std::string result;
2058	>	PyObject * obj0 = 0 ;
2059	>
2060	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2061	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2062		{
2063	<	int res = SWIG_AsVal_size_t(argv[0], NULL);
2064	<	_v = SWIG_CheckState(res);
2065	<	}
2066	<	if (_v) {
2067	<	return _wrap_new_vector_string__SWIG_2(self, args);
2068	<	}
8761	<	}
8762	<	if (argc == 1) {
8763	<	int _v;
8764	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8765	<	_v = SWIG_CheckState(res);
8766	<	if (_v) {
8767	<	return _wrap_new_vector_string__SWIG_1(self, args);
2063	>	try {
2064	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2065	>
2066	>	}catch (std::out_of_range& e) {
2067	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2068	>	}
2069		}
8769	–	}
8770	–	if (argc == 2) {
8771	–	int _v;
2070		{
2071	<	int res = SWIG_AsVal_size_t(argv[0], NULL);
8774	<	_v = SWIG_CheckState(res);
8775	<	}
8776	<	if (_v) {
8777	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
8778	<	_v = SWIG_CheckState(res);
8779	<	if (_v) {
8780	<	return _wrap_new_vector_string__SWIG_3(self, args);
8781	<	}
2071	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2072		}
2073	<	}
2074	<
2075	<	fail:
8786	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_vector_string'");
8787	<	return NULL;
2073	>	return resultobj;
2074	>	fail:
2075	>	return NULL;
2076		}
2077
2078
2079	<	SWIGINTERN PyObject *_wrap_vector_string_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2080	<	PyObject *resultobj = 0;
2081	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2082	<	std::vector<std::string >::value_type *arg2 = 0 ;
2083	<	void *argp1 = 0 ;
2084	<	int res1 = 0 ;
2085	<	int res2 = SWIG_OLDOBJ ;
2086	<	PyObject * obj0 = 0 ;
2087	<	PyObject * obj1 = 0 ;
2088	<
2089	<	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_push_back",&obj0,&obj1)) SWIG_fail;
2090	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2091	<	if (!SWIG_IsOK(res1)) {
2092	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_push_back" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2093	<	}
2094	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2095	<	{
2096	<	std::string *ptr = (std::string *)0;
2097	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
2098	<	if (!SWIG_IsOK(res2)) {
2099	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vector_string_push_back" "', argument " "2"" of type '" "std::vector<std::string >::value_type const &""'");
8812	<	}
8813	<	if (!ptr) {
8814	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_push_back" "', argument " "2"" of type '" "std::vector<std::string >::value_type const &""'");
2079	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2080	>	PyObject *resultobj;
2081	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2082	>	int arg2 ;
2083	>	int arg3 ;
2084	>	std::vector<std::string > result;
2085	>	PyObject * obj0 = 0 ;
2086	>
2087	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2088	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2089	>	{
2090	>	try {
2091	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2092	>
2093	>	}catch (const BossSchedFailure & e) {
2094	>	PyErr_SetString ( SchedulerError, e.what() );
2095	>	return NULL;
2096	>	}catch (const std::exception& e) {
2097	>	PyErr_SetString ( BossError, e.what() );
2098	>	return NULL;
2099	>	}
2100		}
2101	<	arg2 = ptr;
2102	<	}
2103	<	{
2104	<	try {
2105	<	(arg1)->push_back((std::vector<std::string >::value_type const &)*arg2);
8821	<	} catch (const std::exception& e) {
8822	<	SWIG_exception(SWIG_RuntimeError, e.what());
2101	>	{
2102	>	resultobj = PyTuple_New((&result)->size());
2103	>	for (unsigned int i=0; i<(&result)->size(); i++)
2104	>	PyTuple_SetItem(resultobj,i,
2105	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2106		}
2107	<	}
2108	<	resultobj = SWIG_Py_Void();
2109	<	if (SWIG_IsNewObj(res2)) delete arg2;
8827	<	return resultobj;
8828	<	fail:
8829	<	if (SWIG_IsNewObj(res2)) delete arg2;
8830	<	return NULL;
2107	>	return resultobj;
2108	>	fail:
2109	>	return NULL;
2110		}
2111
2112
2113	<	SWIGINTERN PyObject *_wrap_vector_string_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2114	<	PyObject *resultobj = 0;
2115	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2116	<	std::vector<std::string >::value_type *result = 0 ;
2117	<	void *argp1 = 0 ;
2118	<	int res1 = 0 ;
2119	<	PyObject * obj0 = 0 ;
2120	<
2121	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_front",&obj0)) SWIG_fail;
2122	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2123	<	if (!SWIG_IsOK(res1)) {
2124	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_front" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
2125	<	}
2126	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2127	<	{
8849	<	try {
8850	<	{
8851	<	std::vector<std::string >::value_type const &_result_ref = ((std::vector<std::string > const *)arg1)->front();
8852	<	result = (std::vector<std::string >::value_type *) &_result_ref;
8853	<	}
8854	<	} catch (const std::exception& e) {
8855	<	SWIG_exception(SWIG_RuntimeError, e.what());
2113	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2114	>	PyObject *resultobj;
2115	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2116	>	int arg2 ;
2117	>	std::string arg3 ;
2118	>	PyObject * obj0 = 0 ;
2119	>	PyObject * obj2 = 0 ;
2120	>
2121	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2122	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2123	>	{
2124	>	if (PyString_Check(obj2))
2125	>	arg3 = std::string(PyString_AsString(obj2));
2126	>	else
2127	>	SWIG_exception(SWIG_TypeError, "string expected");
2128		}
2129	<	}
2130	<	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
2131	<	return resultobj;
2132	<	fail:
2133	<	return NULL;
2134	<	}
2135	<
8864	<
8865	<	SWIGINTERN PyObject *_wrap_vector_string_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8866	<	PyObject *resultobj = 0;
8867	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8868	<	std::vector<std::string >::value_type *result = 0 ;
8869	<	void *argp1 = 0 ;
8870	<	int res1 = 0 ;
8871	<	PyObject * obj0 = 0 ;
8872	<
8873	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_back",&obj0)) SWIG_fail;
8874	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8875	<	if (!SWIG_IsOK(res1)) {
8876	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_back" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
8877	<	}
8878	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8879	<	{
8880	<	try {
8881	<	{
8882	<	std::vector<std::string >::value_type const &_result_ref = ((std::vector<std::string > const *)arg1)->back();
8883	<	result = (std::vector<std::string >::value_type *) &_result_ref;
8884	<	}
8885	<	} catch (const std::exception& e) {
8886	<	SWIG_exception(SWIG_RuntimeError, e.what());
2129	>	{
2130	>	try {
2131	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2132	>
2133	>	}catch (std::out_of_range& e) {
2134	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2135	>	}
2136		}
2137	<	}
2138	<	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
2139	<	return resultobj;
2140	<	fail:
8892	<	return NULL;
2137	>	Py_INCREF(Py_None); resultobj = Py_None;
2138	>	return resultobj;
2139	>	fail:
2140	>	return NULL;
2141		}
2142
2143
2144	<	SWIGINTERN PyObject *_wrap_vector_string_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2145	<	PyObject *resultobj = 0;
2146	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2147	<	std::vector<std::string >::size_type arg2 ;
2148	<	std::vector<std::string >::value_type *arg3 = 0 ;
2149	<	void *argp1 = 0 ;
2150	<	int res1 = 0 ;
2151	<	size_t val2 ;
2152	<	int ecode2 = 0 ;
2153	<	int res3 = SWIG_OLDOBJ ;
2154	<	PyObject * obj0 = 0 ;
2155	<	PyObject * obj1 = 0 ;
2156	<	PyObject * obj2 = 0 ;
2157	<
2158	<	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_assign",&obj0,&obj1,&obj2)) SWIG_fail;
2159	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2160	<	if (!SWIG_IsOK(res1)) {
2161	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_assign" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2162	<	}
2163	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2164	<	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
2165	<	if (!SWIG_IsOK(ecode2)) {
2166	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string_assign" "', argument " "2"" of type '" "std::vector<std::string >::size_type""'");
2167	<	}
2168	<	arg2 = static_cast< std::vector<std::string >::size_type >(val2);
2169	<	{
2170	<	std::string *ptr = (std::string *)0;
2171	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
2172	<	if (!SWIG_IsOK(res3)) {
2173	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_string_assign" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
2174	<	}
2175	<	if (!ptr) {
2176	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_assign" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
2144	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2145	>	PyObject *resultobj;
2146	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2147	>	int arg2 ;
2148	>	int arg3 ;
2149	>	std::vector<std::string > *arg4 = 0 ;
2150	>	std::vector<std::string > temp4 ;
2151	>	std::vector<std::string > *v4 ;
2152	>	PyObject * obj0 = 0 ;
2153	>	PyObject * obj3 = 0 ;
2154	>
2155	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2156	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2157	>	{
2158	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2159	>	unsigned int size = (PyTuple_Check(obj3) ?
2160	>	PyTuple_Size(obj3) :
2161	>	PyList_Size(obj3));
2162	>	temp4 = std::vector<std::string >(size);
2163	>	arg4 = &temp4;
2164	>	for (unsigned int i=0; i<size; i++) {
2165	>	PyObject* o = PySequence_GetItem(obj3,i);
2166	>	if (PyString_Check(o)) {
2167	>	temp4[i] = (std::string)(\
2168	>	SwigString_AsString(o));
2169	>	Py_DECREF(o);
2170	>	}else {
2171	>	Py_DECREF(o);
2172	>	PyErr_SetString(PyExc_TypeError,
2173	>	"vector<""std::string""> expected");
2174	>	SWIG_fail;
2175	>	}
2176	>	}
2177	>	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2178	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2179	>	arg4 = v4;
2180	>	}else {
2181	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2182	>	SWIG_fail;
2183	>	}
2184		}
2185	<	arg3 = ptr;
2186	<	}
2187	<	{
2188	<	try {
2189	<	(arg1)->assign(arg2,(std::vector<std::string >::value_type const &)*arg3);
2190	<	} catch (const std::exception& e) {
2191	<	SWIG_exception(SWIG_RuntimeError, e.what());
2185	>	{
2186	>	try {
2187	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2188	>
2189	>	}catch (const BossSchedFailure & e) {
2190	>	PyErr_SetString ( SchedulerError, e.what() );
2191	>	return NULL;
2192	>	}catch (const std::exception& e) {
2193	>	PyErr_SetString ( BossError, e.what() );
2194	>	return NULL;
2195	>	}
2196		}
2197	<	}
2198	<	resultobj = SWIG_Py_Void();
2199	<	if (SWIG_IsNewObj(res3)) delete arg3;
2200	<	return resultobj;
8942	<	fail:
8943	<	if (SWIG_IsNewObj(res3)) delete arg3;
8944	<	return NULL;
2197	>	Py_INCREF(Py_None); resultobj = Py_None;
2198	>	return resultobj;
2199	>	fail:
2200	>	return NULL;
2201		}
2202
2203
2204	<	SWIGINTERN PyObject *_wrap_vector_string_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2205	<	PyObject *resultobj = 0;
2206	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2207	<	std::vector<std::string >::size_type arg2 ;
2208	<	std::vector<std::string >::value_type *arg3 = 0 ;
2209	<	void *argp1 = 0 ;
2210	<	int res1 = 0 ;
2211	<	size_t val2 ;
2212	<	int ecode2 = 0 ;
2213	<	int res3 = SWIG_OLDOBJ ;
2214	<	PyObject * obj0 = 0 ;
2215	<	PyObject * obj1 = 0 ;
2216	<	PyObject * obj2 = 0 ;
2217	<
2218	<	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_resize",&obj0,&obj1,&obj2)) SWIG_fail;
8963	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8964	<	if (!SWIG_IsOK(res1)) {
8965	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_resize" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8966	<	}
8967	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8968	<	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8969	<	if (!SWIG_IsOK(ecode2)) {
8970	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string_resize" "', argument " "2"" of type '" "std::vector<std::string >::size_type""'");
8971	<	}
8972	<	arg2 = static_cast< std::vector<std::string >::size_type >(val2);
8973	<	{
8974	<	std::string *ptr = (std::string *)0;
8975	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
8976	<	if (!SWIG_IsOK(res3)) {
8977	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_string_resize" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
8978	<	}
8979	<	if (!ptr) {
8980	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_resize" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
8981	<	}
8982	<	arg3 = ptr;
8983	<	}
8984	<	{
8985	<	try {
8986	<	(arg1)->resize(arg2,(std::vector<std::string >::value_type const &)*arg3);
8987	<	} catch (const std::exception& e) {
8988	<	SWIG_exception(SWIG_RuntimeError, e.what());
2204	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2205	>	PyObject *resultobj;
2206	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2207	>	int arg2 ;
2208	>	PyObject * obj0 = 0 ;
2209	>
2210	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2211	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2212	>	{
2213	>	try {
2214	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2215	>
2216	>	}catch (std::out_of_range& e) {
2217	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2218	>	}
2219		}
2220	<	}
2221	<	resultobj = SWIG_Py_Void();
2222	<	if (SWIG_IsNewObj(res3)) delete arg3;
2223	<	return resultobj;
8994	<	fail:
8995	<	if (SWIG_IsNewObj(res3)) delete arg3;
8996	<	return NULL;
2220	>	Py_INCREF(Py_None); resultobj = Py_None;
2221	>	return resultobj;
2222	>	fail:
2223	>	return NULL;
2224		}
2225
2226
2227	<	SWIGINTERN PyObject *_wrap_vector_string_resize(PyObject *self, PyObject *args) {
2228	<	int argc;
2229	<	PyObject *argv[4];
2230	<	int ii;
2231	<
2232	<	if (!PyTuple_Check(args)) SWIG_fail;
2233	<	argc = PyObject_Length(args);
2234	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
2235	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2236	<	}
2237	<	if (argc == 2) {
2238	<	int _v;
2239	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2240	<	_v = SWIG_CheckState(res);
2241	<	if (_v) {
2242	<	{
2243	<	int res = SWIG_AsVal_size_t(argv[1], NULL);
2244	<	_v = SWIG_CheckState(res);
2245	<	}
9019	<	if (_v) {
9020	<	return _wrap_vector_string_resize__SWIG_0(self, args);
9021	<	}
9022	<	}
9023	<	}
9024	<	if (argc == 3) {
9025	<	int _v;
9026	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
9027	<	_v = SWIG_CheckState(res);
9028	<	if (_v) {
9029	<	{
9030	<	int res = SWIG_AsVal_size_t(argv[1], NULL);
9031	<	_v = SWIG_CheckState(res);
9032	<	}
9033	<	if (_v) {
9034	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
9035	<	_v = SWIG_CheckState(res);
9036	<	if (_v) {
9037	<	return _wrap_vector_string_resize__SWIG_1(self, args);
2227	>	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2228	>	PyObject *resultobj;
2229	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2230	>	int arg2 ;
2231	>	int arg3 ;
2232	>	PyObject * obj0 = 0 ;
2233	>
2234	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2235	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2236	>	{
2237	>	try {
2238	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2239	>
2240	>	}catch (const BossSchedFailure & e) {
2241	>	PyErr_SetString ( SchedulerError, e.what() );
2242	>	return NULL;
2243	>	}catch (const std::exception& e) {
2244	>	PyErr_SetString ( BossError, e.what() );
2245	>	return NULL;
2246		}
9039	–	}
2247		}
2248	<	}
2249	<
2250	<	fail:
2251	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_resize'");
9045	<	return NULL;
2248	>	Py_INCREF(Py_None); resultobj = Py_None;
2249	>	return resultobj;
2250	>	fail:
2251	>	return NULL;
2252		}
2253
2254
2255	<	SWIGINTERN PyObject *_wrap_vector_string_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2256	<	PyObject *resultobj = 0;
2257	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2258	<	std::vector<std::string >::iterator arg2 ;
2259	<	std::vector<std::string >::value_type *arg3 = 0 ;
2260	<	std::vector<std::string >::iterator result;
2261	<	void *argp1 = 0 ;
2262	<	int res1 = 0 ;
2263	<	swig::PySwigIterator *iter2 = 0 ;
2264	<	int res2 ;
2265	<	int res3 = SWIG_OLDOBJ ;
2266	<	PyObject * obj0 = 0 ;
2267	<	PyObject * obj1 = 0 ;
2268	<	PyObject * obj2 = 0 ;
2269	<
2270	<	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_insert",&obj0,&obj1,&obj2)) SWIG_fail;
2271	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2272	<	if (!SWIG_IsOK(res1)) {
9067	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_insert" "', argument " "1"" of type '" "std::vector<std::string > *""'");
9068	<	}
9069	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
9070	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
9071	<	if (!SWIG_IsOK(res2) || !iter2) {
9072	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_insert" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
9073	<	} else {
9074	<	swig::PySwigIterator_T<std::vector<std::string >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter2);
9075	<	if (iter_t) {
9076	<	arg2 = iter_t->get_current();
9077	<	} else {
9078	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_insert" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
9079	<	}
9080	<	}
9081	<	{
9082	<	std::string *ptr = (std::string *)0;
9083	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
9084	<	if (!SWIG_IsOK(res3)) {
9085	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_string_insert" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
9086	<	}
9087	<	if (!ptr) {
9088	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_insert" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
9089	<	}
9090	<	arg3 = ptr;
9091	<	}
9092	<	{
9093	<	try {
9094	<	result = (arg1)->insert(arg2,(std::vector<std::string >::value_type const &)*arg3);
9095	<	} catch (const std::exception& e) {
9096	<	SWIG_exception(SWIG_RuntimeError, e.what());
2255	>	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2256	>	PyObject *resultobj;
2257	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2258	>	PyObject * obj0 = 0 ;
2259	>
2260	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2261	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2262	>	{
2263	>	try {
2264	>	delete arg1;
2265	>
2266	>	}catch (const BossSchedFailure & e) {
2267	>	PyErr_SetString ( SchedulerError, e.what() );
2268	>	return NULL;
2269	>	}catch (const std::exception& e) {
2270	>	PyErr_SetString ( BossError, e.what() );
2271	>	return NULL;
2272	>	}
2273		}
2274	<	}
2275	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
2276	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
2277	<	if (SWIG_IsNewObj(res3)) delete arg3;
9102	<	return resultobj;
9103	<	fail:
9104	<	if (SWIG_IsNewObj(res3)) delete arg3;
9105	<	return NULL;
2274	>	Py_INCREF(Py_None); resultobj = Py_None;
2275	>	return resultobj;
2276	>	fail:
2277	>	return NULL;
2278		}
2279
2280
2281	<	SWIGINTERN PyObject *_wrap_vector_string_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2282	<	PyObject *resultobj = 0;
2283	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2284	<	std::vector<std::string >::iterator arg2 ;
2285	<	std::vector<std::string >::size_type arg3 ;
2286	<	std::vector<std::string >::value_type *arg4 = 0 ;
2287	<	void *argp1 = 0 ;
2288	<	int res1 = 0 ;
2289	<	swig::PySwigIterator *iter2 = 0 ;
2290	<	int res2 ;
2291	<	size_t val3 ;
2292	<	int ecode3 = 0 ;
2293	<	int res4 = SWIG_OLDOBJ ;
2294	<	PyObject * obj0 = 0 ;
2295	<	PyObject * obj1 = 0 ;
2296	<	PyObject * obj2 = 0 ;
2297	<	PyObject * obj3 = 0 ;
2298	<
2299	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
2300	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2301	<	if (!SWIG_IsOK(res1)) {
2302	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_insert" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2303	<	}
2304	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2305	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
2306	<	if (!SWIG_IsOK(res2) || !iter2) {
2307	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_insert" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
9136	<	} else {
9137	<	swig::PySwigIterator_T<std::vector<std::string >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter2);
9138	<	if (iter_t) {
9139	<	arg2 = iter_t->get_current();
9140	<	} else {
9141	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_insert" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
9142	<	}
9143	<	}
9144	<	ecode3 = SWIG_AsVal_size_t(obj2, &val3);
9145	<	if (!SWIG_IsOK(ecode3)) {
9146	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string_insert" "', argument " "3"" of type '" "std::vector<std::string >::size_type""'");
9147	<	}
9148	<	arg3 = static_cast< std::vector<std::string >::size_type >(val3);
9149	<	{
9150	<	std::string *ptr = (std::string *)0;
9151	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
9152	<	if (!SWIG_IsOK(res4)) {
9153	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_string_insert" "', argument " "4"" of type '" "std::vector<std::string >::value_type const &""'");
9154	<	}
9155	<	if (!ptr) {
9156	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_insert" "', argument " "4"" of type '" "std::vector<std::string >::value_type const &""'");
2281	>	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2282	>	PyObject *obj;
2283	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2284	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2285	>	Py_INCREF(obj);
2286	>	return Py_BuildValue((char *)"");
2287	>	}
2288	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2289	>	PyObject *resultobj;
2290	>	std::string arg1 = (std::string) "" ;
2291	>	std::string arg2 = (std::string) "2" ;
2292	>	std::string arg3 = (std::string) "" ;
2293	>	std::string arg4 = (std::string) "" ;
2294	>	BossSession *result;
2295	>	PyObject * obj0 = 0 ;
2296	>	PyObject * obj1 = 0 ;
2297	>	PyObject * obj2 = 0 ;
2298	>	PyObject * obj3 = 0 ;
2299	>
2300	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2301	>	if (obj0) {
2302	>	{
2303	>	if (PyString_Check(obj0))
2304	>	arg1 = std::string(PyString_AsString(obj0));
2305	>	else
2306	>	SWIG_exception(SWIG_TypeError, "string expected");
2307	>	}
2308		}
2309	<	arg4 = ptr;
2310	<	}
2311	<	{
2312	<	try {
2313	<	(arg1)->insert(arg2,arg3,(std::vector<std::string >::value_type const &)*arg4);
2314	<	} catch (const std::exception& e) {
2315	<	SWIG_exception(SWIG_RuntimeError, e.what());
2309	>	if (obj1) {
2310	>	{
2311	>	if (PyString_Check(obj1))
2312	>	arg2 = std::string(PyString_AsString(obj1));
2313	>	else
2314	>	SWIG_exception(SWIG_TypeError, "string expected");
2315	>	}
2316		}
2317	<	}
2318	<	resultobj = SWIG_Py_Void();
2319	<	if (SWIG_IsNewObj(res4)) delete arg4;
2320	<	return resultobj;
2321	<	fail:
2322	<	if (SWIG_IsNewObj(res4)) delete arg4;
9172	<	return NULL;
9173	<	}
9174	<
9175	<
9176	<	SWIGINTERN PyObject *_wrap_vector_string_insert(PyObject *self, PyObject *args) {
9177	<	int argc;
9178	<	PyObject *argv[5];
9179	<	int ii;
9180	<
9181	<	if (!PyTuple_Check(args)) SWIG_fail;
9182	<	argc = PyObject_Length(args);
9183	<	for (ii = 0; (ii < argc) && (ii < 4); ii++) {
9184	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
9185	<	}
9186	<	if (argc == 3) {
9187	<	int _v;
9188	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
9189	<	_v = SWIG_CheckState(res);
9190	<	if (_v) {
9191	<	swig::PySwigIterator *iter = 0;
9192	<	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9193	<	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter) != 0));
9194	<	if (_v) {
9195	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
9196	<	_v = SWIG_CheckState(res);
9197	<	if (_v) {
9198	<	return _wrap_vector_string_insert__SWIG_0(self, args);
2317	>	if (obj2) {
2318	>	{
2319	>	if (PyString_Check(obj2))
2320	>	arg3 = std::string(PyString_AsString(obj2));
2321	>	else
2322	>	SWIG_exception(SWIG_TypeError, "string expected");
2323		}
9200	–	}
2324		}
2325	<	}
9203	<	if (argc == 4) {
9204	<	int _v;
9205	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
9206	<	_v = SWIG_CheckState(res);
9207	<	if (_v) {
9208	<	swig::PySwigIterator *iter = 0;
9209	<	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
9210	<	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter) != 0));
9211	<	if (_v) {
2325	>	if (obj3) {
2326		{
2327	<	int res = SWIG_AsVal_size_t(argv[2], NULL);
2328	<	_v = SWIG_CheckState(res);
2327	>	if (PyString_Check(obj3))
2328	>	arg4 = std::string(PyString_AsString(obj3));
2329	>	else
2330	>	SWIG_exception(SWIG_TypeError, "string expected");
2331		}
2332	<	if (_v) {
2333	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
2334	<	_v = SWIG_CheckState(res);
2335	<	if (_v) {
2336	<	return _wrap_vector_string_insert__SWIG_1(self, args);
2337	<	}
2332	>	}
2333	>	{
2334	>	try {
2335	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2336	>
2337	>	}catch (const BossSchedFailure & e) {
2338	>	PyErr_SetString ( SchedulerError, e.what() );
2339	>	return NULL;
2340	>	}catch (const std::exception& e) {
2341	>	PyErr_SetString ( BossError, e.what() );
2342	>	return NULL;
2343		}
9223	–	}
2344		}
2345	<	}
2346	<
2347	<	fail:
2348	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_insert'");
9229	<	return NULL;
2345	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2346	>	return resultobj;
2347	>	fail:
2348	>	return NULL;
2349		}
2350
2351
2352	<	SWIGINTERN PyObject *_wrap_vector_string_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2353	<	PyObject *resultobj = 0;
2354	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2355	<	std::vector<std::string >::size_type arg2 ;
2356	<	void *argp1 = 0 ;
2357	<	int res1 = 0 ;
2358	<	size_t val2 ;
2359	<	int ecode2 = 0 ;
2360	<	PyObject * obj0 = 0 ;
2361	<	PyObject * obj1 = 0 ;
2362	<
2363	<	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_reserve",&obj0,&obj1)) SWIG_fail;
2364	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2365	<	if (!SWIG_IsOK(res1)) {
2366	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_reserve" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2367	<	}
2368	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2369	<	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9251	<	if (!SWIG_IsOK(ecode2)) {
9252	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string_reserve" "', argument " "2"" of type '" "std::vector<std::string >::size_type""'");
9253	<	}
9254	<	arg2 = static_cast< std::vector<std::string >::size_type >(val2);
9255	<	{
9256	<	try {
9257	<	(arg1)->reserve(arg2);
9258	<	} catch (const std::exception& e) {
9259	<	SWIG_exception(SWIG_RuntimeError, e.what());
2352	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2353	>	PyObject *resultobj;
2354	>	BossSession *arg1 = (BossSession *) 0 ;
2355	>	PyObject * obj0 = 0 ;
2356	>
2357	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2358	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2359	>	{
2360	>	try {
2361	>	delete arg1;
2362	>
2363	>	}catch (const BossSchedFailure & e) {
2364	>	PyErr_SetString ( SchedulerError, e.what() );
2365	>	return NULL;
2366	>	}catch (const std::exception& e) {
2367	>	PyErr_SetString ( BossError, e.what() );
2368	>	return NULL;
2369	>	}
2370		}
2371	<	}
2372	<	resultobj = SWIG_Py_Void();
2373	<	return resultobj;
2374	<	fail:
9265	<	return NULL;
2371	>	Py_INCREF(Py_None); resultobj = Py_None;
2372	>	return resultobj;
2373	>	fail:
2374	>	return NULL;
2375		}
2376
2377
2378	<	SWIGINTERN PyObject *_wrap_vector_string_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2379	<	PyObject *resultobj = 0;
2380	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2381	<	std::vector<std::string >::size_type result;
2382	<	void *argp1 = 0 ;
2383	<	int res1 = 0 ;
2384	<	PyObject * obj0 = 0 ;
2385	<
2386	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_capacity",&obj0)) SWIG_fail;
2387	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2388	<	if (!SWIG_IsOK(res1)) {
2389	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_capacity" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
2390	<	}
2391	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2392	<	{
2393	<	try {
2394	<	result = ((std::vector<std::string > const *)arg1)->capacity();
2395	<	} catch (const std::exception& e) {
9287	<	SWIG_exception(SWIG_RuntimeError, e.what());
2378	>	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2379	>	PyObject *resultobj;
2380	>	BossSession *arg1 = (BossSession *) 0 ;
2381	>	PyObject * obj0 = 0 ;
2382	>
2383	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2384	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2385	>	{
2386	>	try {
2387	>	(arg1)->resetDB();
2388	>
2389	>	}catch (const BossSchedFailure & e) {
2390	>	PyErr_SetString ( SchedulerError, e.what() );
2391	>	return NULL;
2392	>	}catch (const std::exception& e) {
2393	>	PyErr_SetString ( BossError, e.what() );
2394	>	return NULL;
2395	>	}
2396		}
2397	<	}
2398	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
2399	<	return resultobj;
2400	<	fail:
9293	<	return NULL;
2397	>	Py_INCREF(Py_None); resultobj = Py_None;
2398	>	return resultobj;
2399	>	fail:
2400	>	return NULL;
2401		}
2402
2403
2404	<	SWIGINTERN PyObject *_wrap_delete_vector_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2405	<	PyObject *resultobj = 0;
2406	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2407	<	void *argp1 = 0 ;
2408	<	int res1 = 0 ;
2409	<	PyObject * obj0 = 0 ;
2410	<
2411	<	if (!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) SWIG_fail;
2412	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_DISOWN |  0 );
2413	<	if (!SWIG_IsOK(res1)) {
2414	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vector_string" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2415	<	}
2416	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2417	<	{
2418	<	try {
2419	<	delete arg1;
2420	<
2421	<	} catch (const std::exception& e) {
9315	<	SWIG_exception(SWIG_RuntimeError, e.what());
2404	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2405	>	PyObject *resultobj;
2406	>	BossSession *arg1 = (BossSession *) 0 ;
2407	>	PyObject * obj0 = 0 ;
2408	>
2409	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2410	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2411	>	{
2412	>	try {
2413	>	(arg1)->clear();
2414	>
2415	>	}catch (const BossSchedFailure & e) {
2416	>	PyErr_SetString ( SchedulerError, e.what() );
2417	>	return NULL;
2418	>	}catch (const std::exception& e) {
2419	>	PyErr_SetString ( BossError, e.what() );
2420	>	return NULL;
2421	>	}
2422		}
2423	<	}
2424	<	resultobj = SWIG_Py_Void();
2425	<	return resultobj;
2426	<	fail:
9321	<	return NULL;
2423	>	Py_INCREF(Py_None); resultobj = Py_None;
2424	>	return resultobj;
2425	>	fail:
2426	>	return NULL;
2427		}
2428
2429
2430	<	SWIGINTERN PyObject *vector_string_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2431	<	PyObject *obj;
2432	<	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
2433	<	SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_NewClientData(obj));
2434	<	return SWIG_Py_Void();
2435	<	}
2436	<
2437	<	SWIGINTERN PyObject *_wrap_new_BossSession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2438	<	PyObject *resultobj = 0;
2439	<	std::string arg1 ;
2440	<	BossSession *result = 0 ;
2441	<	PyObject * obj0 = 0 ;
2442	<
2443	<	if (!PyArg_ParseTuple(args,(char *)"O:new_BossSession",&obj0)) SWIG_fail;
2444	<	{
2445	<	std::string *ptr = (std::string *)0;
2446	<	int res = SWIG_AsPtr_std_string(obj0, &ptr);
2447	<	if (!SWIG_IsOK(res) || !ptr) {
2448	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BossSession" "', argument " "1"" of type '" "std::string""'");
2449	<	}
2450	<	arg1 = *ptr;
9346	<	if (SWIG_IsNewObj(res)) delete ptr;
9347	<	}
9348	<	{
9349	<	try {
9350	<	result = (BossSession *)new BossSession(arg1);
9351	<	} catch (const std::exception& e) {
9352	<	SWIG_exception(SWIG_RuntimeError, e.what());
2430	>	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2431	>	PyObject *resultobj;
2432	>	BossSession *arg1 = (BossSession *) 0 ;
2433	>	std::string const &arg2_defvalue = "" ;
2434	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
2435	>	BossTask *result;
2436	>	std::string temp2 ;
2437	>	PyObject * obj0 = 0 ;
2438	>	PyObject * obj1 = 0 ;
2439	>
2440	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2441	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2442	>	if (obj1) {
2443	>	{
2444	>	if (PyString_Check(obj1)) {
2445	>	temp2 = std::string(PyString_AsString(obj1));
2446	>	arg2 = &temp2;
2447	>	}else {
2448	>	SWIG_exception(SWIG_TypeError, "string expected");
2449	>	}
2450	>	}
2451		}
2452	<	}
2453	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossSession, SWIG_POINTER_NEW |  0 );
2454	<	return resultobj;
2455	<	fail:
2456	<	return NULL;
2457	<	}
2458	<
2459	<
2460	<	SWIGINTERN PyObject *_wrap_new_BossSession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2461	<	PyObject *resultobj = 0;
2462	<	BossSession *result = 0 ;
9365	<
9366	<	if (!PyArg_ParseTuple(args,(char *)":new_BossSession")) SWIG_fail;
9367	<	{
9368	<	try {
9369	<	result = (BossSession *)new BossSession();
9370	<	} catch (const std::exception& e) {
9371	<	SWIG_exception(SWIG_RuntimeError, e.what());
2452	>	{
2453	>	try {
2454	>	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2455	>
2456	>	}catch (const BossSchedFailure & e) {
2457	>	PyErr_SetString ( SchedulerError, e.what() );
2458	>	return NULL;
2459	>	}catch (const std::exception& e) {
2460	>	PyErr_SetString ( BossError, e.what() );
2461	>	return NULL;
2462	>	}
2463		}
2464	<	}
2465	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossSession, SWIG_POINTER_NEW |  0 );
2466	<	return resultobj;
2467	<	fail:
9377	<	return NULL;
2464	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2465	>	return resultobj;
2466	>	fail:
2467	>	return NULL;
2468		}
2469
2470
2471	<	SWIGINTERN PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2472	<	int argc;
2473	<	PyObject *argv[2];
2474	<	int ii;
2475	<
2476	<	if (!PyTuple_Check(args)) SWIG_fail;
2477	<	argc = PyObject_Length(args);
2478	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2479	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2480	<	}
2481	<	if (argc == 0) {
2482	<	return _wrap_new_BossSession__SWIG_1(self, args);
2483	<	}
2484	<	if (argc == 1) {
2485	<	int _v;
2486	<	int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
2487	<	_v = SWIG_CheckState(res);
2488	<	if (_v) {
2489	<	return _wrap_new_BossSession__SWIG_0(self, args);
2471	>	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2472	>	PyObject *resultobj;
2473	>	BossSession *arg1 = (BossSession *) 0 ;
2474	>	BossTask *arg2 = (BossTask *) 0 ;
2475	>	PyObject * obj0 = 0 ;
2476	>	PyObject * obj1 = 0 ;
2477	>
2478	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2479	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2480	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2481	>	{
2482	>	try {
2483	>	(arg1)->destroyBossTask(arg2);
2484	>
2485	>	}catch (const BossSchedFailure & e) {
2486	>	PyErr_SetString ( SchedulerError, e.what() );
2487	>	return NULL;
2488	>	}catch (const std::exception& e) {
2489	>	PyErr_SetString ( BossError, e.what() );
2490	>	return NULL;
2491	>	}
2492		}
2493	<	}
2494	<
2495	<	fail:
2496	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BossSession'");
9405	<	return NULL;
2493	>	Py_INCREF(Py_None); resultobj = Py_None;
2494	>	return resultobj;
2495	>	fail:
2496	>	return NULL;
2497		}
2498
2499
2500	<	SWIGINTERN PyObject *_wrap_delete_BossSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2501	<	PyObject *resultobj = 0;
2502	<	BossSession *arg1 = (BossSession *) 0 ;
2503	<	void *argp1 = 0 ;
2504	<	int res1 = 0 ;
2505	<	PyObject * obj0 = 0 ;
2506	<
2507	<	if (!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) SWIG_fail;
2508	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, SWIG_POINTER_DISOWN |  0 );
2509	<	if (!SWIG_IsOK(res1)) {
2510	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BossSession" "', argument " "1"" of type '" "BossSession *""'");
2511	<	}
2512	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2513	<	{
2514	<	try {
2515	<	delete arg1;
2516	<
2517	<	} catch (const std::exception& e) {
2518	<	SWIG_exception(SWIG_RuntimeError, e.what());
2500	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2501	>	PyObject *resultobj;
2502	>	BossSession *arg1 = (BossSession *) 0 ;
2503	>	std::vector<std::string > result;
2504	>	PyObject * obj0 = 0 ;
2505	>
2506	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2507	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2508	>	{
2509	>	try {
2510	>	result = (arg1)->showCHTools();
2511	>
2512	>	}catch (const BossSchedFailure & e) {
2513	>	PyErr_SetString ( SchedulerError, e.what() );
2514	>	return NULL;
2515	>	}catch (const std::exception& e) {
2516	>	PyErr_SetString ( BossError, e.what() );
2517	>	return NULL;
2518	>	}
2519		}
2520	<	}
2521	<	resultobj = SWIG_Py_Void();
2522	<	return resultobj;
2523	<	fail:
2524	<	return NULL;
9434	<	}
9435	<
9436	<
9437	<	SWIGINTERN PyObject *_wrap_BossSession_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9438	<	PyObject *resultobj = 0;
9439	<	BossSession *arg1 = (BossSession *) 0 ;
9440	<	void *argp1 = 0 ;
9441	<	int res1 = 0 ;
9442	<	PyObject * obj0 = 0 ;
9443	<
9444	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) SWIG_fail;
9445	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9446	<	if (!SWIG_IsOK(res1)) {
9447	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_clear" "', argument " "1"" of type '" "BossSession *""'");
9448	<	}
9449	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9450	<	{
9451	<	try {
9452	<	(arg1)->clear();
9453	<	} catch (const std::exception& e) {
9454	<	SWIG_exception(SWIG_RuntimeError, e.what());
2520	>	{
2521	>	resultobj = PyTuple_New((&result)->size());
2522	>	for (unsigned int i=0; i<(&result)->size(); i++)
2523	>	PyTuple_SetItem(resultobj,i,
2524	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2525		}
2526	<	}
2527	<	resultobj = SWIG_Py_Void();
2528	<	return resultobj;
9459	<	fail:
9460	<	return NULL;
2526	>	return resultobj;
2527	>	fail:
2528	>	return NULL;
2529		}
2530
2531
2532	<	SWIGINTERN PyObject *_wrap_BossSession_makeBossTask__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2533	<	PyObject *resultobj = 0;
2534	<	BossSession *arg1 = (BossSession *) 0 ;
2535	<	std::string *arg2 = 0 ;
2536	<	BossTask *result = 0 ;
2537	<	void *argp1 = 0 ;
2538	<	int res1 = 0 ;
2539	<	int res2 = SWIG_OLDOBJ ;
2540	<	PyObject * obj0 = 0 ;
2541	<	PyObject * obj1 = 0 ;
2542	<
2543	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_makeBossTask",&obj0,&obj1)) SWIG_fail;
2544	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2545	<	if (!SWIG_IsOK(res1)) {
2546	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_makeBossTask" "', argument " "1"" of type '" "BossSession *""'");
2547	<	}
2548	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2549	<	{
2550	<	std::string *ptr = (std::string *)0;
9483	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
9484	<	if (!SWIG_IsOK(res2)) {
9485	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_makeBossTask" "', argument " "2"" of type '" "std::string const &""'");
9486	<	}
9487	<	if (!ptr) {
9488	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_makeBossTask" "', argument " "2"" of type '" "std::string const &""'");
9489	<	}
9490	<	arg2 = ptr;
9491	<	}
9492	<	{
9493	<	try {
9494	<	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
9495	<	} catch (const std::exception& e) {
9496	<	SWIG_exception(SWIG_RuntimeError, e.what());
2532	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2533	>	PyObject *resultobj;
2534	>	BossSession *arg1 = (BossSession *) 0 ;
2535	>	std::vector<std::string > result;
2536	>	PyObject * obj0 = 0 ;
2537	>
2538	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2539	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2540	>	{
2541	>	try {
2542	>	result = (arg1)->showProgramTypes();
2543	>
2544	>	}catch (const BossSchedFailure & e) {
2545	>	PyErr_SetString ( SchedulerError, e.what() );
2546	>	return NULL;
2547	>	}catch (const std::exception& e) {
2548	>	PyErr_SetString ( BossError, e.what() );
2549	>	return NULL;
2550	>	}
2551		}
2552	<	}
2553	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, 0 |  0 );
2554	<	if (SWIG_IsNewObj(res2)) delete arg2;
2555	<	return resultobj;
2556	<	fail:
9503	<	if (SWIG_IsNewObj(res2)) delete arg2;
9504	<	return NULL;
9505	<	}
9506	<
9507	<
9508	<	SWIGINTERN PyObject *_wrap_BossSession_makeBossTask__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9509	<	PyObject *resultobj = 0;
9510	<	BossSession *arg1 = (BossSession *) 0 ;
9511	<	BossTask *result = 0 ;
9512	<	void *argp1 = 0 ;
9513	<	int res1 = 0 ;
9514	<	PyObject * obj0 = 0 ;
9515	<
9516	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_makeBossTask",&obj0)) SWIG_fail;
9517	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9518	<	if (!SWIG_IsOK(res1)) {
9519	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_makeBossTask" "', argument " "1"" of type '" "BossSession *""'");
9520	<	}
9521	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9522	<	{
9523	<	try {
9524	<	result = (BossTask *)(arg1)->makeBossTask();
9525	<	} catch (const std::exception& e) {
9526	<	SWIG_exception(SWIG_RuntimeError, e.what());
2552	>	{
2553	>	resultobj = PyTuple_New((&result)->size());
2554	>	for (unsigned int i=0; i<(&result)->size(); i++)
2555	>	PyTuple_SetItem(resultobj,i,
2556	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2557		}
2558	<	}
2559	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, 0 |  0 );
2560	<	return resultobj;
9531	<	fail:
9532	<	return NULL;
2558	>	return resultobj;
2559	>	fail:
2560	>	return NULL;
2561		}
2562
2563
2564	<	SWIGINTERN PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2565	<	int argc;
2566	<	PyObject *argv[3];
2567	<	int ii;
2568	<
2569	<	if (!PyTuple_Check(args)) SWIG_fail;
2570	<	argc = PyObject_Length(args);
2571	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
2572	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2573	<	}
2574	<	if (argc == 1) {
2575	<	int _v;
2576	<	void *vptr = 0;
2577	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2578	<	_v = SWIG_CheckState(res);
2579	<	if (_v) {
2580	<	return _wrap_BossSession_makeBossTask__SWIG_1(self, args);
2581	<	}
2582	<	}
9555	<	if (argc == 2) {
9556	<	int _v;
9557	<	void *vptr = 0;
9558	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
9559	<	_v = SWIG_CheckState(res);
9560	<	if (_v) {
9561	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
9562	<	_v = SWIG_CheckState(res);
9563	<	if (_v) {
9564	<	return _wrap_BossSession_makeBossTask__SWIG_0(self, args);
9565	<	}
2564	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2565	>	PyObject *resultobj;
2566	>	BossSession *arg1 = (BossSession *) 0 ;
2567	>	std::vector<std::string > result;
2568	>	PyObject * obj0 = 0 ;
2569	>
2570	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2571	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2572	>	{
2573	>	try {
2574	>	result = (arg1)->showRTMon();
2575	>
2576	>	}catch (const BossSchedFailure & e) {
2577	>	PyErr_SetString ( SchedulerError, e.what() );
2578	>	return NULL;
2579	>	}catch (const std::exception& e) {
2580	>	PyErr_SetString ( BossError, e.what() );
2581	>	return NULL;
2582	>	}
2583		}
2584	<	}
2585	<
2586	<	fail:
2587	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_makeBossTask'");
2588	<	return NULL;
9572	<	}
9573	<
9574	<
9575	<	SWIGINTERN PyObject *_wrap_BossSession_destroyBossTask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9576	<	PyObject *resultobj = 0;
9577	<	BossSession *arg1 = (BossSession *) 0 ;
9578	<	BossTask *arg2 = (BossTask *) 0 ;
9579	<	void *argp1 = 0 ;
9580	<	int res1 = 0 ;
9581	<	void *argp2 = 0 ;
9582	<	int res2 = 0 ;
9583	<	PyObject * obj0 = 0 ;
9584	<	PyObject * obj1 = 0 ;
9585	<
9586	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) SWIG_fail;
9587	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9588	<	if (!SWIG_IsOK(res1)) {
9589	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_destroyBossTask" "', argument " "1"" of type '" "BossSession *""'");
9590	<	}
9591	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9592	<	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_BossTask, 0 |  0 );
9593	<	if (!SWIG_IsOK(res2)) {
9594	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_destroyBossTask" "', argument " "2"" of type '" "BossTask *""'");
9595	<	}
9596	<	arg2 = reinterpret_cast< BossTask * >(argp2);
9597	<	{
9598	<	try {
9599	<	(arg1)->destroyBossTask(arg2);
9600	<	} catch (const std::exception& e) {
9601	<	SWIG_exception(SWIG_RuntimeError, e.what());
2584	>	{
2585	>	resultobj = PyTuple_New((&result)->size());
2586	>	for (unsigned int i=0; i<(&result)->size(); i++)
2587	>	PyTuple_SetItem(resultobj,i,
2588	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2589		}
2590	<	}
2591	<	resultobj = SWIG_Py_Void();
2592	<	return resultobj;
9606	<	fail:
9607	<	return NULL;
2590	>	return resultobj;
2591	>	fail:
2592	>	return NULL;
2593		}
2594
2595
2596	<	SWIGINTERN PyObject *_wrap_BossSession_defaultCHTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2597	<	PyObject *resultobj = 0;
2598	<	BossSession *arg1 = (BossSession *) 0 ;
2599	<	std::string result;
2600	<	void *argp1 = 0 ;
2601	<	int res1 = 0 ;
2602	<	PyObject * obj0 = 0 ;
2603	<
2604	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) SWIG_fail;
2605	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2606	<	if (!SWIG_IsOK(res1)) {
2607	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultCHTool" "', argument " "1"" of type '" "BossSession *""'");
2608	<	}
2609	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2610	<	{
2611	<	try {
2612	<	result = (arg1)->defaultCHTool();
2613	<	} catch (const std::exception& e) {
2614	<	SWIG_exception(SWIG_RuntimeError, e.what());
2596	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2597	>	PyObject *resultobj;
2598	>	BossSession *arg1 = (BossSession *) 0 ;
2599	>	std::vector<std::string > result;
2600	>	PyObject * obj0 = 0 ;
2601	>
2602	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2603	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2604	>	{
2605	>	try {
2606	>	result = (arg1)->showSchedulers();
2607	>
2608	>	}catch (const BossSchedFailure & e) {
2609	>	PyErr_SetString ( SchedulerError, e.what() );
2610	>	return NULL;
2611	>	}catch (const std::exception& e) {
2612	>	PyErr_SetString ( BossError, e.what() );
2613	>	return NULL;
2614	>	}
2615		}
2616	<	}
2617	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2618	<	return resultobj;
2619	<	fail:
2620	<	return NULL;
9636	<	}
9637	<
9638	<
9639	<	SWIGINTERN PyObject *_wrap_BossSession_defaultProgramType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9640	<	PyObject *resultobj = 0;
9641	<	BossSession *arg1 = (BossSession *) 0 ;
9642	<	std::string result;
9643	<	void *argp1 = 0 ;
9644	<	int res1 = 0 ;
9645	<	PyObject * obj0 = 0 ;
9646	<
9647	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) SWIG_fail;
9648	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9649	<	if (!SWIG_IsOK(res1)) {
9650	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultProgramType" "', argument " "1"" of type '" "BossSession *""'");
9651	<	}
9652	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9653	<	{
9654	<	try {
9655	<	result = (arg1)->defaultProgramType();
9656	<	} catch (const std::exception& e) {
9657	<	SWIG_exception(SWIG_RuntimeError, e.what());
2616	>	{
2617	>	resultobj = PyTuple_New((&result)->size());
2618	>	for (unsigned int i=0; i<(&result)->size(); i++)
2619	>	PyTuple_SetItem(resultobj,i,
2620	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2621		}
2622	<	}
2623	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2624	<	return resultobj;
9662	<	fail:
9663	<	return NULL;
2622	>	return resultobj;
2623	>	fail:
2624	>	return NULL;
2625		}
2626
2627
2628	<	SWIGINTERN PyObject *_wrap_BossSession_defaultRTMon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2629	<	PyObject *resultobj = 0;
2630	<	BossSession *arg1 = (BossSession *) 0 ;
2631	<	std::string result;
2632	<	void *argp1 = 0 ;
2633	<	int res1 = 0 ;
2634	<	PyObject * obj0 = 0 ;
2635	<
2636	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) SWIG_fail;
2637	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2638	<	if (!SWIG_IsOK(res1)) {
2639	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultRTMon" "', argument " "1"" of type '" "BossSession *""'");
2640	<	}
2641	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2642	<	{
2643	<	try {
2644	<	result = (arg1)->defaultRTMon();
2645	<	} catch (const std::exception& e) {
2646	<	SWIG_exception(SWIG_RuntimeError, e.what());
2628	>	static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
2629	>	PyObject *resultobj;
2630	>	BossSession *arg1 = (BossSession *) 0 ;
2631	>	std::string result;
2632	>	PyObject * obj0 = 0 ;
2633	>
2634	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) goto fail;
2635	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2636	>	{
2637	>	try {
2638	>	result = (arg1)->defaultCHTool();
2639	>
2640	>	}catch (const BossSchedFailure & e) {
2641	>	PyErr_SetString ( SchedulerError, e.what() );
2642	>	return NULL;
2643	>	}catch (const std::exception& e) {
2644	>	PyErr_SetString ( BossError, e.what() );
2645	>	return NULL;
2646	>	}
2647		}
2648	<	}
2649	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9689	<	return resultobj;
9690	<	fail:
9691	<	return NULL;
9692	<	}
9693	<
9694	<
9695	<	SWIGINTERN PyObject *_wrap_BossSession_defaultScheduler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9696	<	PyObject *resultobj = 0;
9697	<	BossSession *arg1 = (BossSession *) 0 ;
9698	<	std::string result;
9699	<	void *argp1 = 0 ;
9700	<	int res1 = 0 ;
9701	<	PyObject * obj0 = 0 ;
9702	<
9703	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) SWIG_fail;
9704	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9705	<	if (!SWIG_IsOK(res1)) {
9706	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultScheduler" "', argument " "1"" of type '" "BossSession *""'");
9707	<	}
9708	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9709	<	{
9710	<	try {
9711	<	result = (arg1)->defaultScheduler();
9712	<	} catch (const std::exception& e) {
9713	<	SWIG_exception(SWIG_RuntimeError, e.what());
2648	>	{
2649	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2650		}
2651	<	}
2652	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2653	<	return resultobj;
9718	<	fail:
9719	<	return NULL;
2651	>	return resultobj;
2652	>	fail:
2653	>	return NULL;
2654		}
2655
2656
2657	<	SWIGINTERN PyObject *_wrap_BossSession_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2658	<	PyObject *resultobj = 0;
2659	<	BossSession *arg1 = (BossSession *) 0 ;
2660	<	std::string result;
2661	<	void *argp1 = 0 ;
2662	<	int res1 = 0 ;
2663	<	PyObject * obj0 = 0 ;
2664	<
2665	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) SWIG_fail;
2666	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2667	<	if (!SWIG_IsOK(res1)) {
2668	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_version" "', argument " "1"" of type '" "BossSession *""'");
2669	<	}
2670	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2671	<	{
2672	<	try {
2673	<	result = (arg1)->version();
2674	<	} catch (const std::exception& e) {
2675	<	SWIG_exception(SWIG_RuntimeError, e.what());
2657	>	static PyObject *_wrap_BossSession_defaultProgramType(PyObject *self, PyObject *args) {
2658	>	PyObject *resultobj;
2659	>	BossSession *arg1 = (BossSession *) 0 ;
2660	>	std::string result;
2661	>	PyObject * obj0 = 0 ;
2662	>
2663	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) goto fail;
2664	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2665	>	{
2666	>	try {
2667	>	result = (arg1)->defaultProgramType();
2668	>
2669	>	}catch (const BossSchedFailure & e) {
2670	>	PyErr_SetString ( SchedulerError, e.what() );
2671	>	return NULL;
2672	>	}catch (const std::exception& e) {
2673	>	PyErr_SetString ( BossError, e.what() );
2674	>	return NULL;
2675	>	}
2676		}
2677	<	}
2678	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9745	<	return resultobj;
9746	<	fail:
9747	<	return NULL;
9748	<	}
9749	<
9750	<
9751	<	SWIGINTERN PyObject *_wrap_BossSession_clientID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9752	<	PyObject *resultobj = 0;
9753	<	BossSession *arg1 = (BossSession *) 0 ;
9754	<	std::string result;
9755	<	void *argp1 = 0 ;
9756	<	int res1 = 0 ;
9757	<	PyObject * obj0 = 0 ;
9758	<
9759	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) SWIG_fail;
9760	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9761	<	if (!SWIG_IsOK(res1)) {
9762	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_clientID" "', argument " "1"" of type '" "BossSession *""'");
9763	<	}
9764	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9765	<	{
9766	<	try {
9767	<	result = (arg1)->clientID();
9768	<	} catch (const std::exception& e) {
9769	<	SWIG_exception(SWIG_RuntimeError, e.what());
2677	>	{
2678	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2679		}
2680	<	}
2681	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2682	<	return resultobj;
9774	<	fail:
9775	<	return NULL;
2680	>	return resultobj;
2681	>	fail:
2682	>	return NULL;
2683		}
2684
2685
2686	<	SWIGINTERN PyObject *_wrap_BossSession_showConfigs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2687	<	PyObject *resultobj = 0;
2688	<	BossSession *arg1 = (BossSession *) 0 ;
2689	<	bool arg2 ;
2690	<	int result;
2691	<	void *argp1 = 0 ;
2692	<	int res1 = 0 ;
2693	<	bool val2 ;
2694	<	int ecode2 = 0 ;
2695	<	PyObject * obj0 = 0 ;
2696	<	PyObject * obj1 = 0 ;
2697	<
2698	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_showConfigs",&obj0,&obj1)) SWIG_fail;
2699	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2700	<	if (!SWIG_IsOK(res1)) {
2701	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_showConfigs" "', argument " "1"" of type '" "BossSession *""'");
2702	<	}
2703	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2704	<	ecode2 = SWIG_AsVal_bool(obj1, &val2);
9798	<	if (!SWIG_IsOK(ecode2)) {
9799	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_showConfigs" "', argument " "2"" of type '" "bool""'");
9800	<	}
9801	<	arg2 = static_cast< bool >(val2);
9802	<	{
9803	<	try {
9804	<	result = (int)(arg1)->showConfigs(arg2);
9805	<	} catch (const std::exception& e) {
9806	<	SWIG_exception(SWIG_RuntimeError, e.what());
2686	>	static PyObject *_wrap_BossSession_defaultRTMon(PyObject *self, PyObject *args) {
2687	>	PyObject *resultobj;
2688	>	BossSession *arg1 = (BossSession *) 0 ;
2689	>	std::string result;
2690	>	PyObject * obj0 = 0 ;
2691	>
2692	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) goto fail;
2693	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2694	>	{
2695	>	try {
2696	>	result = (arg1)->defaultRTMon();
2697	>
2698	>	}catch (const BossSchedFailure & e) {
2699	>	PyErr_SetString ( SchedulerError, e.what() );
2700	>	return NULL;
2701	>	}catch (const std::exception& e) {
2702	>	PyErr_SetString ( BossError, e.what() );
2703	>	return NULL;
2704	>	}
2705		}
2706	<	}
2707	<	resultobj = SWIG_From_int(static_cast< int >(result));
9810	<	return resultobj;
9811	<	fail:
9812	<	return NULL;
9813	<	}
9814	<
9815	<
9816	<	SWIGINTERN PyObject *_wrap_BossSession_showConfigs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9817	<	PyObject *resultobj = 0;
9818	<	BossSession *arg1 = (BossSession *) 0 ;
9819	<	int result;
9820	<	void *argp1 = 0 ;
9821	<	int res1 = 0 ;
9822	<	PyObject * obj0 = 0 ;
9823	<
9824	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_showConfigs",&obj0)) SWIG_fail;
9825	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9826	<	if (!SWIG_IsOK(res1)) {
9827	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_showConfigs" "', argument " "1"" of type '" "BossSession *""'");
9828	<	}
9829	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9830	<	{
9831	<	try {
9832	<	result = (int)(arg1)->showConfigs();
9833	<	} catch (const std::exception& e) {
9834	<	SWIG_exception(SWIG_RuntimeError, e.what());
2706	>	{
2707	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2708		}
2709	<	}
2710	<	resultobj = SWIG_From_int(static_cast< int >(result));
2711	<	return resultobj;
9839	<	fail:
9840	<	return NULL;
2709	>	return resultobj;
2710	>	fail:
2711	>	return NULL;
2712		}
2713
2714
2715	<	SWIGINTERN PyObject *_wrap_BossSession_showConfigs(PyObject *self, PyObject *args) {
2716	<	int argc;
2717	<	PyObject *argv[3];
2718	<	int ii;
2719	<
2720	<	if (!PyTuple_Check(args)) SWIG_fail;
2721	<	argc = PyObject_Length(args);
2722	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
2723	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2724	<	}
2725	<	if (argc == 1) {
2726	<	int _v;
2727	<	void *vptr = 0;
2728	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2729	<	_v = SWIG_CheckState(res);
2730	<	if (_v) {
2731	<	return _wrap_BossSession_showConfigs__SWIG_1(self, args);
2715	>	static PyObject *_wrap_BossSession_defaultScheduler(PyObject *self, PyObject *args) {
2716	>	PyObject *resultobj;
2717	>	BossSession *arg1 = (BossSession *) 0 ;
2718	>	std::string result;
2719	>	PyObject * obj0 = 0 ;
2720	>
2721	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) goto fail;
2722	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2723	>	{
2724	>	try {
2725	>	result = (arg1)->defaultScheduler();
2726	>
2727	>	}catch (const BossSchedFailure & e) {
2728	>	PyErr_SetString ( SchedulerError, e.what() );
2729	>	return NULL;
2730	>	}catch (const std::exception& e) {
2731	>	PyErr_SetString ( BossError, e.what() );
2732	>	return NULL;
2733	>	}
2734		}
2735	<	}
2736	<	if (argc == 2) {
9864	<	int _v;
9865	<	void *vptr = 0;
9866	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
9867	<	_v = SWIG_CheckState(res);
9868	<	if (_v) {
9869	<	{
9870	<	int res = SWIG_AsVal_bool(argv[1], NULL);
9871	<	_v = SWIG_CheckState(res);
9872	<	}
9873	<	if (_v) {
9874	<	return _wrap_BossSession_showConfigs__SWIG_0(self, args);
9875	<	}
2735	>	{
2736	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2737		}
2738	<	}
2739	<
2740	<	fail:
9880	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_showConfigs'");
9881	<	return NULL;
2738	>	return resultobj;
2739	>	fail:
2740	>	return NULL;
2741		}
2742
2743
2744	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2745	<	PyObject *resultobj = 0;
2746	<	BossSession *arg1 = (BossSession *) 0 ;
2747	<	std::string arg2 ;
2748	<	std::string arg3 ;
2749	<	std::string arg4 ;
2750	<	int result;
2751	<	void *argp1 = 0 ;
2752	<	int res1 = 0 ;
2753	<	PyObject * obj0 = 0 ;
2754	<	PyObject * obj1 = 0 ;
2755	<	PyObject * obj2 = 0 ;
2756	<	PyObject * obj3 = 0 ;
2757	<
2758	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
2759	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2760	<	if (!SWIG_IsOK(res1)) {
2761	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTupdate" "', argument " "1"" of type '" "BossSession *""'");
2762	<	}
9904	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9905	<	{
9906	<	std::string *ptr = (std::string *)0;
9907	<	int res = SWIG_AsPtr_std_string(obj1, &ptr);
9908	<	if (!SWIG_IsOK(res) || !ptr) {
9909	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_RTupdate" "', argument " "2"" of type '" "std::string""'");
9910	<	}
9911	<	arg2 = *ptr;
9912	<	if (SWIG_IsNewObj(res)) delete ptr;
9913	<	}
9914	<	{
9915	<	std::string *ptr = (std::string *)0;
9916	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
9917	<	if (!SWIG_IsOK(res) || !ptr) {
9918	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_RTupdate" "', argument " "3"" of type '" "std::string""'");
9919	<	}
9920	<	arg3 = *ptr;
9921	<	if (SWIG_IsNewObj(res)) delete ptr;
9922	<	}
9923	<	{
9924	<	std::string *ptr = (std::string *)0;
9925	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
9926	<	if (!SWIG_IsOK(res) || !ptr) {
9927	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_RTupdate" "', argument " "4"" of type '" "std::string""'");
2744	>	static PyObject *_wrap_BossSession_version(PyObject *self, PyObject *args) {
2745	>	PyObject *resultobj;
2746	>	BossSession *arg1 = (BossSession *) 0 ;
2747	>	std::string result;
2748	>	PyObject * obj0 = 0 ;
2749	>
2750	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) goto fail;
2751	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2752	>	{
2753	>	try {
2754	>	result = (arg1)->version();
2755	>
2756	>	}catch (const BossSchedFailure & e) {
2757	>	PyErr_SetString ( SchedulerError, e.what() );
2758	>	return NULL;
2759	>	}catch (const std::exception& e) {
2760	>	PyErr_SetString ( BossError, e.what() );
2761	>	return NULL;
2762	>	}
2763		}
2764	<	arg4 = *ptr;
2765	<	if (SWIG_IsNewObj(res)) delete ptr;
9931	<	}
9932	<	{
9933	<	try {
9934	<	result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
9935	<	} catch (const std::exception& e) {
9936	<	SWIG_exception(SWIG_RuntimeError, e.what());
2764	>	{
2765	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2766		}
2767	<	}
2768	<	resultobj = SWIG_From_int(static_cast< int >(result));
2769	<	return resultobj;
9941	<	fail:
9942	<	return NULL;
2767	>	return resultobj;
2768	>	fail:
2769	>	return NULL;
2770		}
2771
2772
2773	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2774	<	PyObject *resultobj = 0;
2775	<	BossSession *arg1 = (BossSession *) 0 ;
2776	<	std::string arg2 ;
2777	<	std::string arg3 ;
2778	<	int result;
2779	<	void *argp1 = 0 ;
2780	<	int res1 = 0 ;
2781	<	PyObject * obj0 = 0 ;
2782	<	PyObject * obj1 = 0 ;
2783	<	PyObject * obj2 = 0 ;
2784	<
2785	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_RTupdate",&obj0,&obj1,&obj2)) SWIG_fail;
2786	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2787	<	if (!SWIG_IsOK(res1)) {
2788	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTupdate" "', argument " "1"" of type '" "BossSession *""'");
2789	<	}
2790	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2791	<	{
9965	<	std::string *ptr = (std::string *)0;
9966	<	int res = SWIG_AsPtr_std_string(obj1, &ptr);
9967	<	if (!SWIG_IsOK(res) || !ptr) {
9968	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_RTupdate" "', argument " "2"" of type '" "std::string""'");
9969	<	}
9970	<	arg2 = *ptr;
9971	<	if (SWIG_IsNewObj(res)) delete ptr;
9972	<	}
9973	<	{
9974	<	std::string *ptr = (std::string *)0;
9975	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
9976	<	if (!SWIG_IsOK(res) || !ptr) {
9977	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_RTupdate" "', argument " "3"" of type '" "std::string""'");
2773	>	static PyObject *_wrap_BossSession_clientID(PyObject *self, PyObject *args) {
2774	>	PyObject *resultobj;
2775	>	BossSession *arg1 = (BossSession *) 0 ;
2776	>	std::string result;
2777	>	PyObject * obj0 = 0 ;
2778	>
2779	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) goto fail;
2780	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2781	>	{
2782	>	try {
2783	>	result = (arg1)->clientID();
2784	>
2785	>	}catch (const BossSchedFailure & e) {
2786	>	PyErr_SetString ( SchedulerError, e.what() );
2787	>	return NULL;
2788	>	}catch (const std::exception& e) {
2789	>	PyErr_SetString ( BossError, e.what() );
2790	>	return NULL;
2791	>	}
2792		}
2793	<	arg3 = *ptr;
2794	<	if (SWIG_IsNewObj(res)) delete ptr;
9981	<	}
9982	<	{
9983	<	try {
9984	<	result = (int)(arg1)->RTupdate(arg2,arg3);
9985	<	} catch (const std::exception& e) {
9986	<	SWIG_exception(SWIG_RuntimeError, e.what());
2793	>	{
2794	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2795		}
2796	<	}
2797	<	resultobj = SWIG_From_int(static_cast< int >(result));
2798	<	return resultobj;
9991	<	fail:
9992	<	return NULL;
2796	>	return resultobj;
2797	>	fail:
2798	>	return NULL;
2799		}
2800
2801
2802	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2803	<	PyObject *resultobj = 0;
2804	<	BossSession *arg1 = (BossSession *) 0 ;
2805	<	std::string arg2 ;
2806	<	int result;
2807	<	void *argp1 = 0 ;
2808	<	int res1 = 0 ;
2809	<	PyObject * obj0 = 0 ;
2810	<	PyObject * obj1 = 0 ;
2811	<
2812	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_RTupdate",&obj0,&obj1)) SWIG_fail;
2813	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2814	<	if (!SWIG_IsOK(res1)) {
10009	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTupdate" "', argument " "1"" of type '" "BossSession *""'");
10010	<	}
10011	<	arg1 = reinterpret_cast< BossSession * >(argp1);
10012	<	{
10013	<	std::string *ptr = (std::string *)0;
10014	<	int res = SWIG_AsPtr_std_string(obj1, &ptr);
10015	<	if (!SWIG_IsOK(res) || !ptr) {
10016	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_RTupdate" "', argument " "2"" of type '" "std::string""'");
10017	<	}
10018	<	arg2 = *ptr;
10019	<	if (SWIG_IsNewObj(res)) delete ptr;
10020	<	}
10021	<	{
10022	<	try {
10023	<	result = (int)(arg1)->RTupdate(arg2);
10024	<	} catch (const std::exception& e) {
10025	<	SWIG_exception(SWIG_RuntimeError, e.what());
2802	>	static PyObject *_wrap_BossSession_showConfigs(PyObject *self, PyObject *args) {
2803	>	PyObject *resultobj;
2804	>	BossSession *arg1 = (BossSession *) 0 ;
2805	>	bool arg2 = (bool) false ;
2806	>	int result;
2807	>	PyObject * obj0 = 0 ;
2808	>	PyObject * obj1 = 0 ;
2809	>
2810	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_showConfigs",&obj0,&obj1)) goto fail;
2811	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2812	>	if (obj1) {
2813	>	arg2 = PyInt_AsLong(obj1) ? true : false;
2814	>	if (PyErr_Occurred()) SWIG_fail;
2815		}
2816	<	}
2817	<	resultobj = SWIG_From_int(static_cast< int >(result));
2818	<	return resultobj;
2819	<	fail:
2820	<	return NULL;
2821	<	}
2822	<
2823	<
2824	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2825	<	PyObject *resultobj = 0;
2826	<	BossSession *arg1 = (BossSession *) 0 ;
10038	<	int result;
10039	<	void *argp1 = 0 ;
10040	<	int res1 = 0 ;
10041	<	PyObject * obj0 = 0 ;
10042	<
10043	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_RTupdate",&obj0)) SWIG_fail;
10044	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10045	<	if (!SWIG_IsOK(res1)) {
10046	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTupdate" "', argument " "1"" of type '" "BossSession *""'");
10047	<	}
10048	<	arg1 = reinterpret_cast< BossSession * >(argp1);
10049	<	{
10050	<	try {
10051	<	result = (int)(arg1)->RTupdate();
10052	<	} catch (const std::exception& e) {
10053	<	SWIG_exception(SWIG_RuntimeError, e.what());
2816	>	{
2817	>	try {
2818	>	result = (int)(arg1)->showConfigs(arg2);
2819	>
2820	>	}catch (const BossSchedFailure & e) {
2821	>	PyErr_SetString ( SchedulerError, e.what() );
2822	>	return NULL;
2823	>	}catch (const std::exception& e) {
2824	>	PyErr_SetString ( BossError, e.what() );
2825	>	return NULL;
2826	>	}
2827		}
2828	<	}
2829	<	resultobj = SWIG_From_int(static_cast< int >(result));
2830	<	return resultobj;
2831	<	fail:
10059	<	return NULL;
2828	>	resultobj = PyInt_FromLong((long)result);
2829	>	return resultobj;
2830	>	fail:
2831	>	return NULL;
2832		}
2833
2834
2835	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2836	<	int argc;
2837	<	PyObject *argv[5];
2838	<	int ii;
2839	<
2840	<	if (!PyTuple_Check(args)) SWIG_fail;
2841	<	argc = PyObject_Length(args);
2842	<	for (ii = 0; (ii < argc) && (ii < 4); ii++) {
2843	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2844	<	}
2845	<	if (argc == 1) {
2846	<	int _v;
2847	<	void *vptr = 0;
2848	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2849	<	_v = SWIG_CheckState(res);
2850	<	if (_v) {
2851	<	return _wrap_BossSession_RTupdate__SWIG_3(self, args);
2852	<	}
2853	<	}
2854	<	if (argc == 2) {
10083	<	int _v;
10084	<	void *vptr = 0;
10085	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
10086	<	_v = SWIG_CheckState(res);
10087	<	if (_v) {
10088	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
10089	<	_v = SWIG_CheckState(res);
10090	<	if (_v) {
10091	<	return _wrap_BossSession_RTupdate__SWIG_2(self, args);
10092	<	}
10093	<	}
10094	<	}
10095	<	if (argc == 3) {
10096	<	int _v;
10097	<	void *vptr = 0;
10098	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
10099	<	_v = SWIG_CheckState(res);
10100	<	if (_v) {
10101	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
10102	<	_v = SWIG_CheckState(res);
10103	<	if (_v) {
10104	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
10105	<	_v = SWIG_CheckState(res);
10106	<	if (_v) {
10107	<	return _wrap_BossSession_RTupdate__SWIG_1(self, args);
2835	>	static PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2836	>	PyObject *resultobj;
2837	>	BossSession *arg1 = (BossSession *) 0 ;
2838	>	std::string arg2 = (std::string) "all" ;
2839	>	std::string arg3 = (std::string) "all" ;
2840	>	std::string arg4 = (std::string) "" ;
2841	>	int result;
2842	>	PyObject * obj0 = 0 ;
2843	>	PyObject * obj1 = 0 ;
2844	>	PyObject * obj2 = 0 ;
2845	>	PyObject * obj3 = 0 ;
2846	>
2847	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
2848	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2849	>	if (obj1) {
2850	>	{
2851	>	if (PyString_Check(obj1))
2852	>	arg2 = std::string(PyString_AsString(obj1));
2853	>	else
2854	>	SWIG_exception(SWIG_TypeError, "string expected");
2855		}
10109	–	}
2856		}
2857	<	}
2858	<	if (argc == 4) {
2859	<	int _v;
2860	<	void *vptr = 0;
2861	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2862	<	_v = SWIG_CheckState(res);
10117	<	if (_v) {
10118	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
10119	<	_v = SWIG_CheckState(res);
10120	<	if (_v) {
10121	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
10122	<	_v = SWIG_CheckState(res);
10123	<	if (_v) {
10124	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
10125	<	_v = SWIG_CheckState(res);
10126	<	if (_v) {
10127	<	return _wrap_BossSession_RTupdate__SWIG_0(self, args);
10128	<	}
2857	>	if (obj2) {
2858	>	{
2859	>	if (PyString_Check(obj2))
2860	>	arg3 = std::string(PyString_AsString(obj2));
2861	>	else
2862	>	SWIG_exception(SWIG_TypeError, "string expected");
2863		}
10130	–	}
10131	–	}
10132	–	}
10133	–
10134	–	fail:
10135	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_RTupdate'");
10136	–	return NULL;
10137	–	}
10138	–
10139	–
10140	–	SWIGINTERN PyObject *_wrap_BossSession_listMatch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10141	–	PyObject *resultobj = 0;
10142	–	BossSession *arg1 = (BossSession *) 0 ;
10143	–	std::string *arg2 = 0 ;
10144	–	std::string *arg3 = 0 ;
10145	–	bool arg4 ;
10146	–	std::string *arg5 = 0 ;
10147	–	std::string *arg6 = 0 ;
10148	–	std::vector<std::string,std::allocator<std::string > > result;
10149	–	void *argp1 = 0 ;
10150	–	int res1 = 0 ;
10151	–	int res2 = SWIG_OLDOBJ ;
10152	–	int res3 = SWIG_OLDOBJ ;
10153	–	bool val4 ;
10154	–	int ecode4 = 0 ;
10155	–	int res5 = SWIG_OLDOBJ ;
10156	–	int res6 = SWIG_OLDOBJ ;
10157	–	PyObject * obj0 = 0 ;
10158	–	PyObject * obj1 = 0 ;
10159	–	PyObject * obj2 = 0 ;
10160	–	PyObject * obj3 = 0 ;
10161	–	PyObject * obj4 = 0 ;
10162	–	PyObject * obj5 = 0 ;
10163	–
10164	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10165	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10166	–	if (!SWIG_IsOK(res1)) {
10167	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_listMatch" "', argument " "1"" of type '" "BossSession *""'");
10168	–	}
10169	–	arg1 = reinterpret_cast< BossSession * >(argp1);
10170	–	{
10171	–	std::string *ptr = (std::string *)0;
10172	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
10173	–	if (!SWIG_IsOK(res2)) {
10174	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10175	–	}
10176	–	if (!ptr) {
10177	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10178	–	}
10179	–	arg2 = ptr;
10180	–	}
10181	–	{
10182	–	std::string *ptr = (std::string *)0;
10183	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10184	–	if (!SWIG_IsOK(res3)) {
10185	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10186	–	}
10187	–	if (!ptr) {
10188	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10189	–	}
10190	–	arg3 = ptr;
10191	–	}
10192	–	ecode4 = SWIG_AsVal_bool(obj3, &val4);
10193	–	if (!SWIG_IsOK(ecode4)) {
10194	–	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossSession_listMatch" "', argument " "4"" of type '" "bool""'");
10195	–	}
10196	–	arg4 = static_cast< bool >(val4);
10197	–	{
10198	–	std::string *ptr = (std::string *)0;
10199	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10200	–	if (!SWIG_IsOK(res5)) {
10201	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_listMatch" "', argument " "5"" of type '" "std::string const &""'");
10202	–	}
10203	–	if (!ptr) {
10204	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "5"" of type '" "std::string const &""'");
10205	–	}
10206	–	arg5 = ptr;
10207	–	}
10208	–	{
10209	–	std::string *ptr = (std::string *)0;
10210	–	res6 = SWIG_AsPtr_std_string(obj5, &ptr);
10211	–	if (!SWIG_IsOK(res6)) {
10212	–	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BossSession_listMatch" "', argument " "6"" of type '" "std::string const &""'");
10213	–	}
10214	–	if (!ptr) {
10215	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "6"" of type '" "std::string const &""'");
10216	–	}
10217	–	arg6 = ptr;
10218	–	}
10219	–	{
10220	–	try {
10221	–	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
10222	–	} catch (const std::exception& e) {
10223	–	SWIG_exception(SWIG_RuntimeError, e.what());
10224	–	}
10225	–	}
10226	–	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
10227	–	if (SWIG_IsNewObj(res2)) delete arg2;
10228	–	if (SWIG_IsNewObj(res3)) delete arg3;
10229	–	if (SWIG_IsNewObj(res5)) delete arg5;
10230	–	if (SWIG_IsNewObj(res6)) delete arg6;
10231	–	return resultobj;
10232	–	fail:
10233	–	if (SWIG_IsNewObj(res2)) delete arg2;
10234	–	if (SWIG_IsNewObj(res3)) delete arg3;
10235	–	if (SWIG_IsNewObj(res5)) delete arg5;
10236	–	if (SWIG_IsNewObj(res6)) delete arg6;
10237	–	return NULL;
10238	–	}
10239	–
10240	–
10241	–	SWIGINTERN PyObject *_wrap_BossSession_listMatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10242	–	PyObject *resultobj = 0;
10243	–	BossSession *arg1 = (BossSession *) 0 ;
10244	–	std::string *arg2 = 0 ;
10245	–	std::string *arg3 = 0 ;
10246	–	bool arg4 ;
10247	–	std::string *arg5 = 0 ;
10248	–	std::vector<std::string,std::allocator<std::string > > result;
10249	–	void *argp1 = 0 ;
10250	–	int res1 = 0 ;
10251	–	int res2 = SWIG_OLDOBJ ;
10252	–	int res3 = SWIG_OLDOBJ ;
10253	–	bool val4 ;
10254	–	int ecode4 = 0 ;
10255	–	int res5 = SWIG_OLDOBJ ;
10256	–	PyObject * obj0 = 0 ;
10257	–	PyObject * obj1 = 0 ;
10258	–	PyObject * obj2 = 0 ;
10259	–	PyObject * obj3 = 0 ;
10260	–	PyObject * obj4 = 0 ;
10261	–
10262	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10263	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10264	–	if (!SWIG_IsOK(res1)) {
10265	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_listMatch" "', argument " "1"" of type '" "BossSession *""'");
10266	–	}
10267	–	arg1 = reinterpret_cast< BossSession * >(argp1);
10268	–	{
10269	–	std::string *ptr = (std::string *)0;
10270	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
10271	–	if (!SWIG_IsOK(res2)) {
10272	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10273	–	}
10274	–	if (!ptr) {
10275	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10276	–	}
10277	–	arg2 = ptr;
10278	–	}
10279	–	{
10280	–	std::string *ptr = (std::string *)0;
10281	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10282	–	if (!SWIG_IsOK(res3)) {
10283	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10284	–	}
10285	–	if (!ptr) {
10286	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10287	–	}
10288	–	arg3 = ptr;
10289	–	}
10290	–	ecode4 = SWIG_AsVal_bool(obj3, &val4);
10291	–	if (!SWIG_IsOK(ecode4)) {
10292	–	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossSession_listMatch" "', argument " "4"" of type '" "bool""'");
10293	–	}
10294	–	arg4 = static_cast< bool >(val4);
10295	–	{
10296	–	std::string *ptr = (std::string *)0;
10297	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10298	–	if (!SWIG_IsOK(res5)) {
10299	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_listMatch" "', argument " "5"" of type '" "std::string const &""'");
10300	–	}
10301	–	if (!ptr) {
10302	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "5"" of type '" "std::string const &""'");
10303	–	}
10304	–	arg5 = ptr;
10305	–	}
10306	–	{
10307	–	try {
10308	–	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5);
10309	–	} catch (const std::exception& e) {
10310	–	SWIG_exception(SWIG_RuntimeError, e.what());
10311	–	}
10312	–	}
10313	–	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
10314	–	if (SWIG_IsNewObj(res2)) delete arg2;
10315	–	if (SWIG_IsNewObj(res3)) delete arg3;
10316	–	if (SWIG_IsNewObj(res5)) delete arg5;
10317	–	return resultobj;
10318	–	fail:
10319	–	if (SWIG_IsNewObj(res2)) delete arg2;
10320	–	if (SWIG_IsNewObj(res3)) delete arg3;
10321	–	if (SWIG_IsNewObj(res5)) delete arg5;
10322	–	return NULL;
10323	–	}
10324	–
10325	–
10326	–	SWIGINTERN PyObject *_wrap_BossSession_listMatch__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10327	–	PyObject *resultobj = 0;
10328	–	BossSession *arg1 = (BossSession *) 0 ;
10329	–	std::string *arg2 = 0 ;
10330	–	std::string *arg3 = 0 ;
10331	–	bool arg4 ;
10332	–	std::vector<std::string,std::allocator<std::string > > result;
10333	–	void *argp1 = 0 ;
10334	–	int res1 = 0 ;
10335	–	int res2 = SWIG_OLDOBJ ;
10336	–	int res3 = SWIG_OLDOBJ ;
10337	–	bool val4 ;
10338	–	int ecode4 = 0 ;
10339	–	PyObject * obj0 = 0 ;
10340	–	PyObject * obj1 = 0 ;
10341	–	PyObject * obj2 = 0 ;
10342	–	PyObject * obj3 = 0 ;
10343	–
10344	–	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10345	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10346	–	if (!SWIG_IsOK(res1)) {
10347	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_listMatch" "', argument " "1"" of type '" "BossSession *""'");
10348	–	}
10349	–	arg1 = reinterpret_cast< BossSession * >(argp1);
10350	–	{
10351	–	std::string *ptr = (std::string *)0;
10352	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
10353	–	if (!SWIG_IsOK(res2)) {
10354	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10355	–	}
10356	–	if (!ptr) {
10357	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
2864		}
2865	<	arg2 = ptr;
2866	<	}
2867	<	{
2868	<	std::string *ptr = (std::string *)0;
2869	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
2870	<	if (!SWIG_IsOK(res3)) {
2871	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10366	<	}
10367	<	if (!ptr) {
10368	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10369	<	}
10370	<	arg3 = ptr;
10371	<	}
10372	<	ecode4 = SWIG_AsVal_bool(obj3, &val4);
10373	<	if (!SWIG_IsOK(ecode4)) {
10374	<	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossSession_listMatch" "', argument " "4"" of type '" "bool""'");
10375	<	}
10376	<	arg4 = static_cast< bool >(val4);
10377	<	{
10378	<	try {
10379	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4);
10380	<	} catch (const std::exception& e) {
10381	<	SWIG_exception(SWIG_RuntimeError, e.what());
10382	<	}
10383	<	}
10384	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
10385	<	if (SWIG_IsNewObj(res2)) delete arg2;
10386	<	if (SWIG_IsNewObj(res3)) delete arg3;
10387	<	return resultobj;
10388	<	fail:
10389	<	if (SWIG_IsNewObj(res2)) delete arg2;
10390	<	if (SWIG_IsNewObj(res3)) delete arg3;
10391	<	return NULL;
10392	<	}
10393	<
10394	<
10395	<	SWIGINTERN PyObject *_wrap_BossSession_listMatch__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10396	<	PyObject *resultobj = 0;
10397	<	BossSession *arg1 = (BossSession *) 0 ;
10398	<	std::string *arg2 = 0 ;
10399	<	std::string *arg3 = 0 ;
10400	<	std::vector<std::string,std::allocator<std::string > > result;
10401	<	void *argp1 = 0 ;
10402	<	int res1 = 0 ;
10403	<	int res2 = SWIG_OLDOBJ ;
10404	<	int res3 = SWIG_OLDOBJ ;
10405	<	PyObject * obj0 = 0 ;
10406	<	PyObject * obj1 = 0 ;
10407	<	PyObject * obj2 = 0 ;
10408	<
10409	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_listMatch",&obj0,&obj1,&obj2)) SWIG_fail;
10410	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10411	<	if (!SWIG_IsOK(res1)) {
10412	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_listMatch" "', argument " "1"" of type '" "BossSession *""'");
10413	<	}
10414	<	arg1 = reinterpret_cast< BossSession * >(argp1);
10415	<	{
10416	<	std::string *ptr = (std::string *)0;
10417	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
10418	<	if (!SWIG_IsOK(res2)) {
10419	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10420	<	}
10421	<	if (!ptr) {
10422	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10423	<	}
10424	<	arg2 = ptr;
10425	<	}
10426	<	{
10427	<	std::string *ptr = (std::string *)0;
10428	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10429	<	if (!SWIG_IsOK(res3)) {
10430	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10431	<	}
10432	<	if (!ptr) {
10433	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
2865	>	if (obj3) {
2866	>	{
2867	>	if (PyString_Check(obj3))
2868	>	arg4 = std::string(PyString_AsString(obj3));
2869	>	else
2870	>	SWIG_exception(SWIG_TypeError, "string expected");
2871	>	}
2872		}
2873	<	arg3 = ptr;
2874	<	}
2875	<	{
2876	<	try {
2877	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3);
2878	<	} catch (const std::exception& e) {
2879	<	SWIG_exception(SWIG_RuntimeError, e.what());
2873	>	{
2874	>	try {
2875	>	result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2876	>
2877	>	}catch (const BossSchedFailure & e) {
2878	>	PyErr_SetString ( SchedulerError, e.what() );
2879	>	return NULL;
2880	>	}catch (const std::exception& e) {
2881	>	PyErr_SetString ( BossError, e.what() );
2882	>	return NULL;
2883	>	}
2884		}
2885	<	}
2886	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
2887	<	if (SWIG_IsNewObj(res2)) delete arg2;
2888	<	if (SWIG_IsNewObj(res3)) delete arg3;
10447	<	return resultobj;
10448	<	fail:
10449	<	if (SWIG_IsNewObj(res2)) delete arg2;
10450	<	if (SWIG_IsNewObj(res3)) delete arg3;
10451	<	return NULL;
2885	>	resultobj = PyInt_FromLong((long)result);
2886	>	return resultobj;
2887	>	fail:
2888	>	return NULL;
2889		}
2890
2891
2892	<	SWIGINTERN PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
2893	<	int argc;
2894	<	PyObject *argv[7];
2895	<	int ii;
2896	<
2897	<	if (!PyTuple_Check(args)) SWIG_fail;
2898	<	argc = PyObject_Length(args);
2899	<	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
2900	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2901	<	}
2902	<	if (argc == 3) {
2903	<	int _v;
2904	<	void *vptr = 0;
2905	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2906	<	_v = SWIG_CheckState(res);
2907	<	if (_v) {
2908	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
2909	<	_v = SWIG_CheckState(res);
2910	<	if (_v) {
2911	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
2912	<	_v = SWIG_CheckState(res);
2913	<	if (_v) {
2914	<	return _wrap_BossSession_listMatch__SWIG_3(self, args);
2892	>	static PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
2893	>	PyObject *resultobj;
2894	>	BossSession *arg1 = (BossSession *) 0 ;
2895	>	std::string *arg2 = 0 ;
2896	>	std::string *arg3 = 0 ;
2897	>	bool arg4 = (bool) false ;
2898	>	std::string const &arg5_defvalue = "" ;
2899	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2900	>	std::string const &arg6_defvalue = "" ;
2901	>	std::string *arg6 = (std::string *) &arg6_defvalue ;
2902	>	std::vector<std::string > result;
2903	>	std::string temp2 ;
2904	>	std::string temp3 ;
2905	>	std::string temp5 ;
2906	>	std::string temp6 ;
2907	>	PyObject * obj0 = 0 ;
2908	>	PyObject * obj1 = 0 ;
2909	>	PyObject * obj2 = 0 ;
2910	>	PyObject * obj3 = 0 ;
2911	>	PyObject * obj4 = 0 ;
2912	>	PyObject * obj5 = 0 ;
2913	>
2914	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2915	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2916	>	{
2917	>	if (PyString_Check(obj1)) {
2918	>	temp2 = std::string(PyString_AsString(obj1));
2919	>	arg2 = &temp2;
2920	>	}else {
2921	>	SWIG_exception(SWIG_TypeError, "string expected");
2922		}
10479	–	}
2923		}
2924	<	}
2925	<	if (argc == 4) {
2926	<	int _v;
2927	<	void *vptr = 0;
2928	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2929	<	_v = SWIG_CheckState(res);
10487	<	if (_v) {
10488	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
10489	<	_v = SWIG_CheckState(res);
10490	<	if (_v) {
10491	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
10492	<	_v = SWIG_CheckState(res);
10493	<	if (_v) {
10494	<	{
10495	<	int res = SWIG_AsVal_bool(argv[3], NULL);
10496	<	_v = SWIG_CheckState(res);
10497	<	}
10498	<	if (_v) {
10499	<	return _wrap_BossSession_listMatch__SWIG_2(self, args);
10500	<	}
2924	>	{
2925	>	if (PyString_Check(obj2)) {
2926	>	temp3 = std::string(PyString_AsString(obj2));
2927	>	arg3 = &temp3;
2928	>	}else {
2929	>	SWIG_exception(SWIG_TypeError, "string expected");
2930		}
10502	–	}
2931		}
2932	<	}
2933	<	if (argc == 5) {
2934	<	int _v;
2935	<	void *vptr = 0;
2936	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2937	<	_v = SWIG_CheckState(res);
2938	<	if (_v) {
2939	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
2940	<	_v = SWIG_CheckState(res);
2941	<	if (_v) {
2942	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
10515	<	_v = SWIG_CheckState(res);
10516	<	if (_v) {
10517	<	{
10518	<	int res = SWIG_AsVal_bool(argv[3], NULL);
10519	<	_v = SWIG_CheckState(res);
10520	<	}
10521	<	if (_v) {
10522	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
10523	<	_v = SWIG_CheckState(res);
10524	<	if (_v) {
10525	<	return _wrap_BossSession_listMatch__SWIG_1(self, args);
2932	>	if (obj3) {
2933	>	arg4 = PyInt_AsLong(obj3) ? true : false;
2934	>	if (PyErr_Occurred()) SWIG_fail;
2935	>	}
2936	>	if (obj4) {
2937	>	{
2938	>	if (PyString_Check(obj4)) {
2939	>	temp5 = std::string(PyString_AsString(obj4));
2940	>	arg5 = &temp5;
2941	>	}else {
2942	>	SWIG_exception(SWIG_TypeError, "string expected");
2943		}
10527	–	}
2944		}
10529	–	}
2945		}
2946	<	}
2947	<	if (argc == 6) {
2948	<	int _v;
2949	<	void *vptr = 0;
2950	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2951	<	_v = SWIG_CheckState(res);
2952	<	if (_v) {
10538	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
10539	<	_v = SWIG_CheckState(res);
10540	<	if (_v) {
10541	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
10542	<	_v = SWIG_CheckState(res);
10543	<	if (_v) {
10544	<	{
10545	<	int res = SWIG_AsVal_bool(argv[3], NULL);
10546	<	_v = SWIG_CheckState(res);
10547	<	}
10548	<	if (_v) {
10549	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
10550	<	_v = SWIG_CheckState(res);
10551	<	if (_v) {
10552	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
10553	<	_v = SWIG_CheckState(res);
10554	<	if (_v) {
10555	<	return _wrap_BossSession_listMatch__SWIG_0(self, args);
10556	<	}
2946	>	if (obj5) {
2947	>	{
2948	>	if (PyString_Check(obj5)) {
2949	>	temp6 = std::string(PyString_AsString(obj5));
2950	>	arg6 = &temp6;
2951	>	}else {
2952	>	SWIG_exception(SWIG_TypeError, "string expected");
2953		}
10558	–	}
2954		}
10560	–	}
10561	–	}
10562	–	}
10563	–
10564	–	fail:
10565	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_listMatch'");
10566	–	return NULL;
10567	–	}
10568	–
10569	–
10570	–	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10571	–	PyObject *resultobj = 0;
10572	–	BossSession *arg1 = (BossSession *) 0 ;
10573	–	int arg2 ;
10574	–	std::string *arg3 = 0 ;
10575	–	std::string *arg4 = 0 ;
10576	–	std::string *arg5 = 0 ;
10577	–	std::string arg6 ;
10578	–	std::string arg7 ;
10579	–	std::string arg8 ;
10580	–	std::string arg9 ;
10581	–	void *argp1 = 0 ;
10582	–	int res1 = 0 ;
10583	–	int val2 ;
10584	–	int ecode2 = 0 ;
10585	–	int res3 = SWIG_OLDOBJ ;
10586	–	int res4 = SWIG_OLDOBJ ;
10587	–	int res5 = SWIG_OLDOBJ ;
10588	–	PyObject * obj0 = 0 ;
10589	–	PyObject * obj1 = 0 ;
10590	–	PyObject * obj2 = 0 ;
10591	–	PyObject * obj3 = 0 ;
10592	–	PyObject * obj4 = 0 ;
10593	–	PyObject * obj5 = 0 ;
10594	–	PyObject * obj6 = 0 ;
10595	–	PyObject * obj7 = 0 ;
10596	–	PyObject * obj8 = 0 ;
10597	–
10598	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
10599	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10600	–	if (!SWIG_IsOK(res1)) {
10601	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
10602	–	}
10603	–	arg1 = reinterpret_cast< BossSession * >(argp1);
10604	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
10605	–	if (!SWIG_IsOK(ecode2)) {
10606	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
10607	–	}
10608	–	arg2 = static_cast< int >(val2);
10609	–	{
10610	–	std::string *ptr = (std::string *)0;
10611	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10612	–	if (!SWIG_IsOK(res3)) {
10613	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10614	–	}
10615	–	if (!ptr) {
10616	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10617	–	}
10618	–	arg3 = ptr;
10619	–	}
10620	–	{
10621	–	std::string *ptr = (std::string *)0;
10622	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
10623	–	if (!SWIG_IsOK(res4)) {
10624	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10625	–	}
10626	–	if (!ptr) {
10627	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10628	–	}
10629	–	arg4 = ptr;
10630	–	}
10631	–	{
10632	–	std::string *ptr = (std::string *)0;
10633	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10634	–	if (!SWIG_IsOK(res5)) {
10635	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10636	–	}
10637	–	if (!ptr) {
10638	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10639	–	}
10640	–	arg5 = ptr;
10641	–	}
10642	–	{
10643	–	std::string *ptr = (std::string *)0;
10644	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
10645	–	if (!SWIG_IsOK(res) || !ptr) {
10646	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "6"" of type '" "std::string""'");
10647	–	}
10648	–	arg6 = *ptr;
10649	–	if (SWIG_IsNewObj(res)) delete ptr;
10650	–	}
10651	–	{
10652	–	std::string *ptr = (std::string *)0;
10653	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
10654	–	if (!SWIG_IsOK(res) || !ptr) {
10655	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "7"" of type '" "std::string""'");
10656	–	}
10657	–	arg7 = *ptr;
10658	–	if (SWIG_IsNewObj(res)) delete ptr;
10659	–	}
10660	–	{
10661	–	std::string *ptr = (std::string *)0;
10662	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
10663	–	if (!SWIG_IsOK(res) || !ptr) {
10664	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "8"" of type '" "std::string""'");
10665	–	}
10666	–	arg8 = *ptr;
10667	–	if (SWIG_IsNewObj(res)) delete ptr;
10668	–	}
10669	–	{
10670	–	std::string *ptr = (std::string *)0;
10671	–	int res = SWIG_AsPtr_std_string(obj8, &ptr);
10672	–	if (!SWIG_IsOK(res) || !ptr) {
10673	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "9"" of type '" "std::string""'");
10674	–	}
10675	–	arg9 = *ptr;
10676	–	if (SWIG_IsNewObj(res)) delete ptr;
10677	–	}
10678	–	{
10679	–	try {
10680	–	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
10681	–	} catch (const std::exception& e) {
10682	–	SWIG_exception(SWIG_RuntimeError, e.what());
10683	–	}
10684	–	}
10685	–	resultobj = SWIG_Py_Void();
10686	–	if (SWIG_IsNewObj(res3)) delete arg3;
10687	–	if (SWIG_IsNewObj(res4)) delete arg4;
10688	–	if (SWIG_IsNewObj(res5)) delete arg5;
10689	–	return resultobj;
10690	–	fail:
10691	–	if (SWIG_IsNewObj(res3)) delete arg3;
10692	–	if (SWIG_IsNewObj(res4)) delete arg4;
10693	–	if (SWIG_IsNewObj(res5)) delete arg5;
10694	–	return NULL;
10695	–	}
10696	–
10697	–
10698	–	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10699	–	PyObject *resultobj = 0;
10700	–	BossSession *arg1 = (BossSession *) 0 ;
10701	–	int arg2 ;
10702	–	std::string *arg3 = 0 ;
10703	–	std::string *arg4 = 0 ;
10704	–	std::string *arg5 = 0 ;
10705	–	std::string arg6 ;
10706	–	std::string arg7 ;
10707	–	std::string arg8 ;
10708	–	void *argp1 = 0 ;
10709	–	int res1 = 0 ;
10710	–	int val2 ;
10711	–	int ecode2 = 0 ;
10712	–	int res3 = SWIG_OLDOBJ ;
10713	–	int res4 = SWIG_OLDOBJ ;
10714	–	int res5 = SWIG_OLDOBJ ;
10715	–	PyObject * obj0 = 0 ;
10716	–	PyObject * obj1 = 0 ;
10717	–	PyObject * obj2 = 0 ;
10718	–	PyObject * obj3 = 0 ;
10719	–	PyObject * obj4 = 0 ;
10720	–	PyObject * obj5 = 0 ;
10721	–	PyObject * obj6 = 0 ;
10722	–	PyObject * obj7 = 0 ;
10723	–
10724	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
10725	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10726	–	if (!SWIG_IsOK(res1)) {
10727	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
10728	–	}
10729	–	arg1 = reinterpret_cast< BossSession * >(argp1);
10730	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
10731	–	if (!SWIG_IsOK(ecode2)) {
10732	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
10733	–	}
10734	–	arg2 = static_cast< int >(val2);
10735	–	{
10736	–	std::string *ptr = (std::string *)0;
10737	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10738	–	if (!SWIG_IsOK(res3)) {
10739	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10740	–	}
10741	–	if (!ptr) {
10742	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10743	–	}
10744	–	arg3 = ptr;
10745	–	}
10746	–	{
10747	–	std::string *ptr = (std::string *)0;
10748	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
10749	–	if (!SWIG_IsOK(res4)) {
10750	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10751	–	}
10752	–	if (!ptr) {
10753	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10754	–	}
10755	–	arg4 = ptr;
10756	–	}
10757	–	{
10758	–	std::string *ptr = (std::string *)0;
10759	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10760	–	if (!SWIG_IsOK(res5)) {
10761	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10762	–	}
10763	–	if (!ptr) {
10764	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10765	–	}
10766	–	arg5 = ptr;
10767	–	}
10768	–	{
10769	–	std::string *ptr = (std::string *)0;
10770	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
10771	–	if (!SWIG_IsOK(res) || !ptr) {
10772	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "6"" of type '" "std::string""'");
10773	–	}
10774	–	arg6 = *ptr;
10775	–	if (SWIG_IsNewObj(res)) delete ptr;
10776	–	}
10777	–	{
10778	–	std::string *ptr = (std::string *)0;
10779	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
10780	–	if (!SWIG_IsOK(res) || !ptr) {
10781	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "7"" of type '" "std::string""'");
10782	–	}
10783	–	arg7 = *ptr;
10784	–	if (SWIG_IsNewObj(res)) delete ptr;
10785	–	}
10786	–	{
10787	–	std::string *ptr = (std::string *)0;
10788	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
10789	–	if (!SWIG_IsOK(res) || !ptr) {
10790	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "8"" of type '" "std::string""'");
10791	–	}
10792	–	arg8 = *ptr;
10793	–	if (SWIG_IsNewObj(res)) delete ptr;
10794	–	}
10795	–	{
10796	–	try {
10797	–	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8);
10798	–	} catch (const std::exception& e) {
10799	–	SWIG_exception(SWIG_RuntimeError, e.what());
10800	–	}
10801	–	}
10802	–	resultobj = SWIG_Py_Void();
10803	–	if (SWIG_IsNewObj(res3)) delete arg3;
10804	–	if (SWIG_IsNewObj(res4)) delete arg4;
10805	–	if (SWIG_IsNewObj(res5)) delete arg5;
10806	–	return resultobj;
10807	–	fail:
10808	–	if (SWIG_IsNewObj(res3)) delete arg3;
10809	–	if (SWIG_IsNewObj(res4)) delete arg4;
10810	–	if (SWIG_IsNewObj(res5)) delete arg5;
10811	–	return NULL;
10812	–	}
10813	–
10814	–
10815	–	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10816	–	PyObject *resultobj = 0;
10817	–	BossSession *arg1 = (BossSession *) 0 ;
10818	–	int arg2 ;
10819	–	std::string *arg3 = 0 ;
10820	–	std::string *arg4 = 0 ;
10821	–	std::string *arg5 = 0 ;
10822	–	std::string arg6 ;
10823	–	std::string arg7 ;
10824	–	void *argp1 = 0 ;
10825	–	int res1 = 0 ;
10826	–	int val2 ;
10827	–	int ecode2 = 0 ;
10828	–	int res3 = SWIG_OLDOBJ ;
10829	–	int res4 = SWIG_OLDOBJ ;
10830	–	int res5 = SWIG_OLDOBJ ;
10831	–	PyObject * obj0 = 0 ;
10832	–	PyObject * obj1 = 0 ;
10833	–	PyObject * obj2 = 0 ;
10834	–	PyObject * obj3 = 0 ;
10835	–	PyObject * obj4 = 0 ;
10836	–	PyObject * obj5 = 0 ;
10837	–	PyObject * obj6 = 0 ;
10838	–
10839	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10840	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10841	–	if (!SWIG_IsOK(res1)) {
10842	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
10843	–	}
10844	–	arg1 = reinterpret_cast< BossSession * >(argp1);
10845	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
10846	–	if (!SWIG_IsOK(ecode2)) {
10847	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
10848	–	}
10849	–	arg2 = static_cast< int >(val2);
10850	–	{
10851	–	std::string *ptr = (std::string *)0;
10852	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10853	–	if (!SWIG_IsOK(res3)) {
10854	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10855	–	}
10856	–	if (!ptr) {
10857	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10858	–	}
10859	–	arg3 = ptr;
10860	–	}
10861	–	{
10862	–	std::string *ptr = (std::string *)0;
10863	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
10864	–	if (!SWIG_IsOK(res4)) {
10865	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10866	–	}
10867	–	if (!ptr) {
10868	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10869	–	}
10870	–	arg4 = ptr;
10871	–	}
10872	–	{
10873	–	std::string *ptr = (std::string *)0;
10874	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10875	–	if (!SWIG_IsOK(res5)) {
10876	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10877	–	}
10878	–	if (!ptr) {
10879	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10880	–	}
10881	–	arg5 = ptr;
10882	–	}
10883	–	{
10884	–	std::string *ptr = (std::string *)0;
10885	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
10886	–	if (!SWIG_IsOK(res) || !ptr) {
10887	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "6"" of type '" "std::string""'");
10888	–	}
10889	–	arg6 = *ptr;
10890	–	if (SWIG_IsNewObj(res)) delete ptr;
10891	–	}
10892	–	{
10893	–	std::string *ptr = (std::string *)0;
10894	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
10895	–	if (!SWIG_IsOK(res) || !ptr) {
10896	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "7"" of type '" "std::string""'");
2955		}
2956	<	arg7 = *ptr;
2957	<	if (SWIG_IsNewObj(res)) delete ptr;
2958	<	}
2959	<	{
2960	<	try {
2961	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
2962	<	} catch (const std::exception& e) {
2963	<	SWIG_exception(SWIG_RuntimeError, e.what());
2964	<	}
2965	<	}
2966	<	resultobj = SWIG_Py_Void();
10909	<	if (SWIG_IsNewObj(res3)) delete arg3;
10910	<	if (SWIG_IsNewObj(res4)) delete arg4;
10911	<	if (SWIG_IsNewObj(res5)) delete arg5;
10912	<	return resultobj;
10913	<	fail:
10914	<	if (SWIG_IsNewObj(res3)) delete arg3;
10915	<	if (SWIG_IsNewObj(res4)) delete arg4;
10916	<	if (SWIG_IsNewObj(res5)) delete arg5;
10917	<	return NULL;
10918	<	}
10919	<
10920	<
10921	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10922	<	PyObject *resultobj = 0;
10923	<	BossSession *arg1 = (BossSession *) 0 ;
10924	<	int arg2 ;
10925	<	std::string *arg3 = 0 ;
10926	<	std::string *arg4 = 0 ;
10927	<	std::string *arg5 = 0 ;
10928	<	std::string arg6 ;
10929	<	void *argp1 = 0 ;
10930	<	int res1 = 0 ;
10931	<	int val2 ;
10932	<	int ecode2 = 0 ;
10933	<	int res3 = SWIG_OLDOBJ ;
10934	<	int res4 = SWIG_OLDOBJ ;
10935	<	int res5 = SWIG_OLDOBJ ;
10936	<	PyObject * obj0 = 0 ;
10937	<	PyObject * obj1 = 0 ;
10938	<	PyObject * obj2 = 0 ;
10939	<	PyObject * obj3 = 0 ;
10940	<	PyObject * obj4 = 0 ;
10941	<	PyObject * obj5 = 0 ;
10942	<
10943	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10944	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10945	<	if (!SWIG_IsOK(res1)) {
10946	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
10947	<	}
10948	<	arg1 = reinterpret_cast< BossSession * >(argp1);
10949	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
10950	<	if (!SWIG_IsOK(ecode2)) {
10951	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
10952	<	}
10953	<	arg2 = static_cast< int >(val2);
10954	<	{
10955	<	std::string *ptr = (std::string *)0;
10956	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10957	<	if (!SWIG_IsOK(res3)) {
10958	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10959	<	}
10960	<	if (!ptr) {
10961	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10962	<	}
10963	<	arg3 = ptr;
10964	<	}
10965	<	{
10966	<	std::string *ptr = (std::string *)0;
10967	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
10968	<	if (!SWIG_IsOK(res4)) {
10969	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10970	<	}
10971	<	if (!ptr) {
10972	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10973	<	}
10974	<	arg4 = ptr;
10975	<	}
10976	<	{
10977	<	std::string *ptr = (std::string *)0;
10978	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10979	<	if (!SWIG_IsOK(res5)) {
10980	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10981	<	}
10982	<	if (!ptr) {
10983	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10984	<	}
10985	<	arg5 = ptr;
10986	<	}
10987	<	{
10988	<	std::string *ptr = (std::string *)0;
10989	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
10990	<	if (!SWIG_IsOK(res) || !ptr) {
10991	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "6"" of type '" "std::string""'");
10992	<	}
10993	<	arg6 = *ptr;
10994	<	if (SWIG_IsNewObj(res)) delete ptr;
10995	<	}
10996	<	{
10997	<	try {
10998	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
10999	<	} catch (const std::exception& e) {
11000	<	SWIG_exception(SWIG_RuntimeError, e.what());
11001	<	}
11002	<	}
11003	<	resultobj = SWIG_Py_Void();
11004	<	if (SWIG_IsNewObj(res3)) delete arg3;
11005	<	if (SWIG_IsNewObj(res4)) delete arg4;
11006	<	if (SWIG_IsNewObj(res5)) delete arg5;
11007	<	return resultobj;
11008	<	fail:
11009	<	if (SWIG_IsNewObj(res3)) delete arg3;
11010	<	if (SWIG_IsNewObj(res4)) delete arg4;
11011	<	if (SWIG_IsNewObj(res5)) delete arg5;
11012	<	return NULL;
11013	<	}
11014	<
11015	<
11016	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11017	<	PyObject *resultobj = 0;
11018	<	BossSession *arg1 = (BossSession *) 0 ;
11019	<	int arg2 ;
11020	<	std::string *arg3 = 0 ;
11021	<	std::string *arg4 = 0 ;
11022	<	std::string *arg5 = 0 ;
11023	<	void *argp1 = 0 ;
11024	<	int res1 = 0 ;
11025	<	int val2 ;
11026	<	int ecode2 = 0 ;
11027	<	int res3 = SWIG_OLDOBJ ;
11028	<	int res4 = SWIG_OLDOBJ ;
11029	<	int res5 = SWIG_OLDOBJ ;
11030	<	PyObject * obj0 = 0 ;
11031	<	PyObject * obj1 = 0 ;
11032	<	PyObject * obj2 = 0 ;
11033	<	PyObject * obj3 = 0 ;
11034	<	PyObject * obj4 = 0 ;
11035	<
11036	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11037	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11038	<	if (!SWIG_IsOK(res1)) {
11039	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
11040	<	}
11041	<	arg1 = reinterpret_cast< BossSession * >(argp1);
11042	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
11043	<	if (!SWIG_IsOK(ecode2)) {
11044	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
11045	<	}
11046	<	arg2 = static_cast< int >(val2);
11047	<	{
11048	<	std::string *ptr = (std::string *)0;
11049	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11050	<	if (!SWIG_IsOK(res3)) {
11051	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
11052	<	}
11053	<	if (!ptr) {
11054	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
11055	<	}
11056	<	arg3 = ptr;
11057	<	}
11058	<	{
11059	<	std::string *ptr = (std::string *)0;
11060	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
11061	<	if (!SWIG_IsOK(res4)) {
11062	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
11063	<	}
11064	<	if (!ptr) {
11065	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
11066	<	}
11067	<	arg4 = ptr;
11068	<	}
11069	<	{
11070	<	std::string *ptr = (std::string *)0;
11071	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
11072	<	if (!SWIG_IsOK(res5)) {
11073	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
11074	<	}
11075	<	if (!ptr) {
11076	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
2956	>	{
2957	>	try {
2958	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2959	>
2960	>	}catch (const BossSchedFailure & e) {
2961	>	PyErr_SetString ( SchedulerError, e.what() );
2962	>	return NULL;
2963	>	}catch (const std::exception& e) {
2964	>	PyErr_SetString ( BossError, e.what() );
2965	>	return NULL;
2966	>	}
2967		}
2968	<	arg5 = ptr;
2969	<	}
2970	<	{
2971	<	try {
2972	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
11083	<	} catch (const std::exception& e) {
11084	<	SWIG_exception(SWIG_RuntimeError, e.what());
2968	>	{
2969	>	resultobj = PyTuple_New((&result)->size());
2970	>	for (unsigned int i=0; i<(&result)->size(); i++)
2971	>	PyTuple_SetItem(resultobj,i,
2972	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2973		}
2974	<	}
2975	<	resultobj = SWIG_Py_Void();
2976	<	if (SWIG_IsNewObj(res3)) delete arg3;
11089	<	if (SWIG_IsNewObj(res4)) delete arg4;
11090	<	if (SWIG_IsNewObj(res5)) delete arg5;
11091	<	return resultobj;
11092	<	fail:
11093	<	if (SWIG_IsNewObj(res3)) delete arg3;
11094	<	if (SWIG_IsNewObj(res4)) delete arg4;
11095	<	if (SWIG_IsNewObj(res5)) delete arg5;
11096	<	return NULL;
2974	>	return resultobj;
2975	>	fail:
2976	>	return NULL;
2977		}
2978
2979
2980	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2981	<	PyObject *resultobj = 0;
2982	<	BossSession *arg1 = (BossSession *) 0 ;
2983	<	int arg2 ;
2984	<	std::string *arg3 = 0 ;
2985	<	std::string *arg4 = 0 ;
2986	<	void *argp1 = 0 ;
2987	<	int res1 = 0 ;
2988	<	int val2 ;
2989	<	int ecode2 = 0 ;
2990	<	int res3 = SWIG_OLDOBJ ;
2991	<	int res4 = SWIG_OLDOBJ ;
2992	<	PyObject * obj0 = 0 ;
2993	<	PyObject * obj1 = 0 ;
2994	<	PyObject * obj2 = 0 ;
2995	<	PyObject * obj3 = 0 ;
2996	<
2997	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
2998	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2999	<	if (!SWIG_IsOK(res1)) {
3000	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
3001	<	}
3002	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3003	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
3004	<	if (!SWIG_IsOK(ecode2)) {
3005	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
3006	<	}
3007	<	arg2 = static_cast< int >(val2);
3008	<	{
3009	<	std::string *ptr = (std::string *)0;
3010	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
3011	<	if (!SWIG_IsOK(res3)) {
3012	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
3013	<	}
3014	<	if (!ptr) {
3015	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
3016	<	}
11137	<	arg3 = ptr;
11138	<	}
11139	<	{
11140	<	std::string *ptr = (std::string *)0;
11141	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
11142	<	if (!SWIG_IsOK(res4)) {
11143	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
2980	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
2981	>	PyObject *resultobj;
2982	>	BossSession *arg1 = (BossSession *) 0 ;
2983	>	int arg2 = (int) SCHEDULED ;
2984	>	std::string const &arg3_defvalue = "all" ;
2985	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
2986	>	std::string const &arg4_defvalue = "all" ;
2987	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
2988	>	std::string const &arg5_defvalue = "" ;
2989	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2990	>	std::string arg6 = (std::string) "" ;
2991	>	std::string arg7 = (std::string) "" ;
2992	>	std::string arg8 = (std::string) "" ;
2993	>	std::string arg9 = (std::string) "" ;
2994	>	std::string temp3 ;
2995	>	std::string temp4 ;
2996	>	std::string temp5 ;
2997	>	PyObject * obj0 = 0 ;
2998	>	PyObject * obj2 = 0 ;
2999	>	PyObject * obj3 = 0 ;
3000	>	PyObject * obj4 = 0 ;
3001	>	PyObject * obj5 = 0 ;
3002	>	PyObject * obj6 = 0 ;
3003	>	PyObject * obj7 = 0 ;
3004	>	PyObject * obj8 = 0 ;
3005	>
3006	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
3007	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3008	>	if (obj2) {
3009	>	{
3010	>	if (PyString_Check(obj2)) {
3011	>	temp3 = std::string(PyString_AsString(obj2));
3012	>	arg3 = &temp3;
3013	>	}else {
3014	>	SWIG_exception(SWIG_TypeError, "string expected");
3015	>	}
3016	>	}
3017		}
3018	<	if (!ptr) {
3019	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
3018	>	if (obj3) {
3019	>	{
3020	>	if (PyString_Check(obj3)) {
3021	>	temp4 = std::string(PyString_AsString(obj3));
3022	>	arg4 = &temp4;
3023	>	}else {
3024	>	SWIG_exception(SWIG_TypeError, "string expected");
3025	>	}
3026	>	}
3027		}
3028	<	arg4 = ptr;
3029	<	}
3030	<	{
3031	<	try {
3032	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
3033	<	} catch (const std::exception& e) {
3034	<	SWIG_exception(SWIG_RuntimeError, e.what());
3028	>	if (obj4) {
3029	>	{
3030	>	if (PyString_Check(obj4)) {
3031	>	temp5 = std::string(PyString_AsString(obj4));
3032	>	arg5 = &temp5;
3033	>	}else {
3034	>	SWIG_exception(SWIG_TypeError, "string expected");
3035	>	}
3036	>	}
3037		}
3038	<	}
3039	<	resultobj = SWIG_Py_Void();
3040	<	if (SWIG_IsNewObj(res3)) delete arg3;
3041	<	if (SWIG_IsNewObj(res4)) delete arg4;
3042	<	return resultobj;
3043	<	fail:
3044	<	if (SWIG_IsNewObj(res3)) delete arg3;
11163	<	if (SWIG_IsNewObj(res4)) delete arg4;
11164	<	return NULL;
11165	<	}
11166	<
11167	<
11168	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11169	<	PyObject *resultobj = 0;
11170	<	BossSession *arg1 = (BossSession *) 0 ;
11171	<	int arg2 ;
11172	<	std::string *arg3 = 0 ;
11173	<	void *argp1 = 0 ;
11174	<	int res1 = 0 ;
11175	<	int val2 ;
11176	<	int ecode2 = 0 ;
11177	<	int res3 = SWIG_OLDOBJ ;
11178	<	PyObject * obj0 = 0 ;
11179	<	PyObject * obj1 = 0 ;
11180	<	PyObject * obj2 = 0 ;
11181	<
11182	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2)) SWIG_fail;
11183	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11184	<	if (!SWIG_IsOK(res1)) {
11185	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
11186	<	}
11187	<	arg1 = reinterpret_cast< BossSession * >(argp1);
11188	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
11189	<	if (!SWIG_IsOK(ecode2)) {
11190	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
11191	<	}
11192	<	arg2 = static_cast< int >(val2);
11193	<	{
11194	<	std::string *ptr = (std::string *)0;
11195	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11196	<	if (!SWIG_IsOK(res3)) {
11197	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
3038	>	if (obj5) {
3039	>	{
3040	>	if (PyString_Check(obj5))
3041	>	arg6 = std::string(PyString_AsString(obj5));
3042	>	else
3043	>	SWIG_exception(SWIG_TypeError, "string expected");
3044	>	}
3045		}
3046	<	if (!ptr) {
3047	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
3046	>	if (obj6) {
3047	>	{
3048	>	if (PyString_Check(obj6))
3049	>	arg7 = std::string(PyString_AsString(obj6));
3050	>	else
3051	>	SWIG_exception(SWIG_TypeError, "string expected");
3052	>	}
3053		}
3054	<	arg3 = ptr;
3055	<	}
3056	<	{
3057	<	try {
3058	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3);
3059	<	} catch (const std::exception& e) {
3060	<	SWIG_exception(SWIG_RuntimeError, e.what());
3054	>	if (obj7) {
3055	>	{
3056	>	if (PyString_Check(obj7))
3057	>	arg8 = std::string(PyString_AsString(obj7));
3058	>	else
3059	>	SWIG_exception(SWIG_TypeError, "string expected");
3060	>	}
3061		}
3062	<	}
3063	<	resultobj = SWIG_Py_Void();
3064	<	if (SWIG_IsNewObj(res3)) delete arg3;
3065	<	return resultobj;
3066	<	fail:
3067	<	if (SWIG_IsNewObj(res3)) delete arg3;
3068	<	return NULL;
11217	<	}
11218	<
11219	<
11220	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11221	<	PyObject *resultobj = 0;
11222	<	BossSession *arg1 = (BossSession *) 0 ;
11223	<	int arg2 ;
11224	<	void *argp1 = 0 ;
11225	<	int res1 = 0 ;
11226	<	int val2 ;
11227	<	int ecode2 = 0 ;
11228	<	PyObject * obj0 = 0 ;
11229	<	PyObject * obj1 = 0 ;
11230	<
11231	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_schedulerQuery",&obj0,&obj1)) SWIG_fail;
11232	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11233	<	if (!SWIG_IsOK(res1)) {
11234	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
11235	<	}
11236	<	arg1 = reinterpret_cast< BossSession * >(argp1);
11237	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
11238	<	if (!SWIG_IsOK(ecode2)) {
11239	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
11240	<	}
11241	<	arg2 = static_cast< int >(val2);
11242	<	{
11243	<	try {
11244	<	(arg1)->schedulerQuery(arg2);
11245	<	} catch (const std::exception& e) {
11246	<	SWIG_exception(SWIG_RuntimeError, e.what());
3062	>	if (obj8) {
3063	>	{
3064	>	if (PyString_Check(obj8))
3065	>	arg9 = std::string(PyString_AsString(obj8));
3066	>	else
3067	>	SWIG_exception(SWIG_TypeError, "string expected");
3068	>	}
3069		}
3070	<	}
3071	<	resultobj = SWIG_Py_Void();
3072	<	return resultobj;
3073	<	fail:
3074	<	return NULL;
3075	<	}
3076	<
3077	<
3078	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3079	<	PyObject *resultobj = 0;
3080	<	BossSession *arg1 = (BossSession *) 0 ;
11259	<	void *argp1 = 0 ;
11260	<	int res1 = 0 ;
11261	<	PyObject * obj0 = 0 ;
11262	<
11263	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulerQuery",&obj0)) SWIG_fail;
11264	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11265	<	if (!SWIG_IsOK(res1)) {
11266	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
11267	<	}
11268	<	arg1 = reinterpret_cast< BossSession * >(argp1);
11269	<	{
11270	<	try {
11271	<	(arg1)->schedulerQuery();
11272	<	} catch (const std::exception& e) {
11273	<	SWIG_exception(SWIG_RuntimeError, e.what());
3070	>	{
3071	>	try {
3072	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3073	>
3074	>	}catch (const BossSchedFailure & e) {
3075	>	PyErr_SetString ( SchedulerError, e.what() );
3076	>	return NULL;
3077	>	}catch (const std::exception& e) {
3078	>	PyErr_SetString ( BossError, e.what() );
3079	>	return NULL;
3080	>	}
3081		}
3082	<	}
3083	<	resultobj = SWIG_Py_Void();
3084	<	return resultobj;
3085	<	fail:
11279	<	return NULL;
3082	>	Py_INCREF(Py_None); resultobj = Py_None;
3083	>	return resultobj;
3084	>	fail:
3085	>	return NULL;
3086		}
3087
3088
3089	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3090	<	int argc;
3091	<	PyObject *argv[10];
3092	<	int ii;
3093	<
3094	<	if (!PyTuple_Check(args)) SWIG_fail;
3095	<	argc = PyObject_Length(args);
3096	<	for (ii = 0; (ii < argc) && (ii < 9); ii++) {
3097	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3098	<	}
3099	<	if (argc == 1) {
3100	<	int _v;
3101	<	void *vptr = 0;
3102	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3103	<	_v = SWIG_CheckState(res);
3104	<	if (_v) {
3105	<	return _wrap_BossSession_schedulerQuery__SWIG_8(self, args);
3106	<	}
3107	<	}
3108	<	if (argc == 2) {
3109	<	int _v;
3110	<	void *vptr = 0;
3111	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3112	<	_v = SWIG_CheckState(res);
3113	<	if (_v) {
3114	<	{
3115	<	int res = SWIG_AsVal_int(argv[1], NULL);
3116	<	_v = SWIG_CheckState(res);
3117	<	}
3118	<	if (_v) {
3119	<	return _wrap_BossSession_schedulerQuery__SWIG_7(self, args);
11314	<	}
11315	<	}
11316	<	}
11317	<	if (argc == 3) {
11318	<	int _v;
11319	<	void *vptr = 0;
11320	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11321	<	_v = SWIG_CheckState(res);
11322	<	if (_v) {
11323	<	{
11324	<	int res = SWIG_AsVal_int(argv[1], NULL);
11325	<	_v = SWIG_CheckState(res);
11326	<	}
11327	<	if (_v) {
11328	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11329	<	_v = SWIG_CheckState(res);
11330	<	if (_v) {
11331	<	return _wrap_BossSession_schedulerQuery__SWIG_6(self, args);
11332	<	}
11333	<	}
11334	<	}
11335	<	}
11336	<	if (argc == 4) {
11337	<	int _v;
11338	<	void *vptr = 0;
11339	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11340	<	_v = SWIG_CheckState(res);
11341	<	if (_v) {
11342	<	{
11343	<	int res = SWIG_AsVal_int(argv[1], NULL);
11344	<	_v = SWIG_CheckState(res);
11345	<	}
11346	<	if (_v) {
11347	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11348	<	_v = SWIG_CheckState(res);
11349	<	if (_v) {
11350	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
11351	<	_v = SWIG_CheckState(res);
11352	<	if (_v) {
11353	<	return _wrap_BossSession_schedulerQuery__SWIG_5(self, args);
11354	<	}
11355	<	}
11356	<	}
11357	<	}
11358	<	}
11359	<	if (argc == 5) {
11360	<	int _v;
11361	<	void *vptr = 0;
11362	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11363	<	_v = SWIG_CheckState(res);
11364	<	if (_v) {
11365	<	{
11366	<	int res = SWIG_AsVal_int(argv[1], NULL);
11367	<	_v = SWIG_CheckState(res);
11368	<	}
11369	<	if (_v) {
11370	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11371	<	_v = SWIG_CheckState(res);
11372	<	if (_v) {
11373	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
11374	<	_v = SWIG_CheckState(res);
11375	<	if (_v) {
11376	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
11377	<	_v = SWIG_CheckState(res);
11378	<	if (_v) {
11379	<	return _wrap_BossSession_schedulerQuery__SWIG_4(self, args);
3089	>	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3090	>	PyObject *resultobj;
3091	>	BossSession *arg1 = (BossSession *) 0 ;
3092	>	std::string const &arg2_defvalue = "all" ;
3093	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3094	>	std::string const &arg3_defvalue = "" ;
3095	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3096	>	std::string const &arg4_defvalue = "" ;
3097	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3098	>	std::string const &arg5_defvalue = "" ;
3099	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3100	>	std::vector<std::string > result;
3101	>	std::string temp2 ;
3102	>	std::string temp3 ;
3103	>	std::string temp4 ;
3104	>	std::string temp5 ;
3105	>	PyObject * obj0 = 0 ;
3106	>	PyObject * obj1 = 0 ;
3107	>	PyObject * obj2 = 0 ;
3108	>	PyObject * obj3 = 0 ;
3109	>	PyObject * obj4 = 0 ;
3110	>
3111	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3112	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3113	>	if (obj1) {
3114	>	{
3115	>	if (PyString_Check(obj1)) {
3116	>	temp2 = std::string(PyString_AsString(obj1));
3117	>	arg2 = &temp2;
3118	>	}else {
3119	>	SWIG_exception(SWIG_TypeError, "string expected");
3120		}
11381	–	}
3121		}
11383	–	}
3122		}
3123	<	}
3124	<	if (argc == 6) {
3125	<	int _v;
3126	<	void *vptr = 0;
3127	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3128	<	_v = SWIG_CheckState(res);
3129	<	if (_v) {
11392	<	{
11393	<	int res = SWIG_AsVal_int(argv[1], NULL);
11394	<	_v = SWIG_CheckState(res);
11395	<	}
11396	<	if (_v) {
11397	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11398	<	_v = SWIG_CheckState(res);
11399	<	if (_v) {
11400	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
11401	<	_v = SWIG_CheckState(res);
11402	<	if (_v) {
11403	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
11404	<	_v = SWIG_CheckState(res);
11405	<	if (_v) {
11406	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
11407	<	_v = SWIG_CheckState(res);
11408	<	if (_v) {
11409	<	return _wrap_BossSession_schedulerQuery__SWIG_3(self, args);
11410	<	}
3123	>	if (obj2) {
3124	>	{
3125	>	if (PyString_Check(obj2)) {
3126	>	temp3 = std::string(PyString_AsString(obj2));
3127	>	arg3 = &temp3;
3128	>	}else {
3129	>	SWIG_exception(SWIG_TypeError, "string expected");
3130		}
11412	–	}
3131		}
11414	–	}
3132		}
3133	<	}
3134	<	if (argc == 7) {
3135	<	int _v;
3136	<	void *vptr = 0;
3137	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3138	<	_v = SWIG_CheckState(res);
3139	<	if (_v) {
11423	<	{
11424	<	int res = SWIG_AsVal_int(argv[1], NULL);
11425	<	_v = SWIG_CheckState(res);
11426	<	}
11427	<	if (_v) {
11428	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11429	<	_v = SWIG_CheckState(res);
11430	<	if (_v) {
11431	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
11432	<	_v = SWIG_CheckState(res);
11433	<	if (_v) {
11434	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
11435	<	_v = SWIG_CheckState(res);
11436	<	if (_v) {
11437	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
11438	<	_v = SWIG_CheckState(res);
11439	<	if (_v) {
11440	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
11441	<	_v = SWIG_CheckState(res);
11442	<	if (_v) {
11443	<	return _wrap_BossSession_schedulerQuery__SWIG_2(self, args);
11444	<	}
11445	<	}
3133	>	if (obj3) {
3134	>	{
3135	>	if (PyString_Check(obj3)) {
3136	>	temp4 = std::string(PyString_AsString(obj3));
3137	>	arg4 = &temp4;
3138	>	}else {
3139	>	SWIG_exception(SWIG_TypeError, "string expected");
3140		}
11447	–	}
3141		}
11449	–	}
3142		}
3143	<	}
3144	<	if (argc == 8) {
3145	<	int _v;
3146	<	void *vptr = 0;
3147	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3148	<	_v = SWIG_CheckState(res);
3149	<	if (_v) {
11458	<	{
11459	<	int res = SWIG_AsVal_int(argv[1], NULL);
11460	<	_v = SWIG_CheckState(res);
11461	<	}
11462	<	if (_v) {
11463	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11464	<	_v = SWIG_CheckState(res);
11465	<	if (_v) {
11466	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
11467	<	_v = SWIG_CheckState(res);
11468	<	if (_v) {
11469	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
11470	<	_v = SWIG_CheckState(res);
11471	<	if (_v) {
11472	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
11473	<	_v = SWIG_CheckState(res);
11474	<	if (_v) {
11475	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
11476	<	_v = SWIG_CheckState(res);
11477	<	if (_v) {
11478	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
11479	<	_v = SWIG_CheckState(res);
11480	<	if (_v) {
11481	<	return _wrap_BossSession_schedulerQuery__SWIG_1(self, args);
11482	<	}
11483	<	}
11484	<	}
3143	>	if (obj4) {
3144	>	{
3145	>	if (PyString_Check(obj4)) {
3146	>	temp5 = std::string(PyString_AsString(obj4));
3147	>	arg5 = &temp5;
3148	>	}else {
3149	>	SWIG_exception(SWIG_TypeError, "string expected");
3150		}
11486	–	}
3151		}
11488	–	}
3152		}
3153	<	}
3154	<	if (argc == 9) {
3155	<	int _v;
3156	<	void *vptr = 0;
3157	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3158	<	_v = SWIG_CheckState(res);
3159	<	if (_v) {
3160	<	{
3161	<	int res = SWIG_AsVal_int(argv[1], NULL);
3162	<	_v = SWIG_CheckState(res);
11500	<	}
11501	<	if (_v) {
11502	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11503	<	_v = SWIG_CheckState(res);
11504	<	if (_v) {
11505	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
11506	<	_v = SWIG_CheckState(res);
11507	<	if (_v) {
11508	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
11509	<	_v = SWIG_CheckState(res);
11510	<	if (_v) {
11511	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
11512	<	_v = SWIG_CheckState(res);
11513	<	if (_v) {
11514	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
11515	<	_v = SWIG_CheckState(res);
11516	<	if (_v) {
11517	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
11518	<	_v = SWIG_CheckState(res);
11519	<	if (_v) {
11520	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
11521	<	_v = SWIG_CheckState(res);
11522	<	if (_v) {
11523	<	return _wrap_BossSession_schedulerQuery__SWIG_0(self, args);
11524	<	}
11525	<	}
11526	<	}
11527	<	}
11528	<	}
11529	<	}
3153	>	{
3154	>	try {
3155	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3156	>
3157	>	}catch (const BossSchedFailure & e) {
3158	>	PyErr_SetString ( SchedulerError, e.what() );
3159	>	return NULL;
3160	>	}catch (const std::exception& e) {
3161	>	PyErr_SetString ( BossError, e.what() );
3162	>	return NULL;
3163		}
11531	–	}
11532	–	}
11533	–	}
11534	–
11535	–	fail:
11536	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_schedulerQuery'");
11537	–	return NULL;
11538	–	}
11539	–
11540	–
11541	–	SWIGINTERN PyObject *_wrap_BossSession_selectTasks__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11542	–	PyObject *resultobj = 0;
11543	–	BossSession *arg1 = (BossSession *) 0 ;
11544	–	std::string *arg2 = 0 ;
11545	–	std::string *arg3 = 0 ;
11546	–	std::string *arg4 = 0 ;
11547	–	std::string *arg5 = 0 ;
11548	–	std::vector<std::string,std::allocator<std::string > > result;
11549	–	void *argp1 = 0 ;
11550	–	int res1 = 0 ;
11551	–	int res2 = SWIG_OLDOBJ ;
11552	–	int res3 = SWIG_OLDOBJ ;
11553	–	int res4 = SWIG_OLDOBJ ;
11554	–	int res5 = SWIG_OLDOBJ ;
11555	–	PyObject * obj0 = 0 ;
11556	–	PyObject * obj1 = 0 ;
11557	–	PyObject * obj2 = 0 ;
11558	–	PyObject * obj3 = 0 ;
11559	–	PyObject * obj4 = 0 ;
11560	–
11561	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11562	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11563	–	if (!SWIG_IsOK(res1)) {
11564	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_selectTasks" "', argument " "1"" of type '" "BossSession *""'");
11565	–	}
11566	–	arg1 = reinterpret_cast< BossSession * >(argp1);
11567	–	{
11568	–	std::string *ptr = (std::string *)0;
11569	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11570	–	if (!SWIG_IsOK(res2)) {
11571	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11572	–	}
11573	–	if (!ptr) {
11574	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11575	–	}
11576	–	arg2 = ptr;
11577	–	}
11578	–	{
11579	–	std::string *ptr = (std::string *)0;
11580	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11581	–	if (!SWIG_IsOK(res3)) {
11582	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11583	–	}
11584	–	if (!ptr) {
11585	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
3164		}
3165	<	arg3 = ptr;
3166	<	}
3167	<	{
3168	<	std::string *ptr = (std::string *)0;
3169	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
11592	<	if (!SWIG_IsOK(res4)) {
11593	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_selectTasks" "', argument " "4"" of type '" "std::string const &""'");
11594	<	}
11595	<	if (!ptr) {
11596	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "4"" of type '" "std::string const &""'");
11597	<	}
11598	<	arg4 = ptr;
11599	<	}
11600	<	{
11601	<	std::string *ptr = (std::string *)0;
11602	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
11603	<	if (!SWIG_IsOK(res5)) {
11604	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_selectTasks" "', argument " "5"" of type '" "std::string const &""'");
11605	<	}
11606	<	if (!ptr) {
11607	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "5"" of type '" "std::string const &""'");
11608	<	}
11609	<	arg5 = ptr;
11610	<	}
11611	<	{
11612	<	try {
11613	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
11614	<	} catch (const std::exception& e) {
11615	<	SWIG_exception(SWIG_RuntimeError, e.what());
11616	<	}
11617	<	}
11618	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
11619	<	if (SWIG_IsNewObj(res2)) delete arg2;
11620	<	if (SWIG_IsNewObj(res3)) delete arg3;
11621	<	if (SWIG_IsNewObj(res4)) delete arg4;
11622	<	if (SWIG_IsNewObj(res5)) delete arg5;
11623	<	return resultobj;
11624	<	fail:
11625	<	if (SWIG_IsNewObj(res2)) delete arg2;
11626	<	if (SWIG_IsNewObj(res3)) delete arg3;
11627	<	if (SWIG_IsNewObj(res4)) delete arg4;
11628	<	if (SWIG_IsNewObj(res5)) delete arg5;
11629	<	return NULL;
11630	<	}
11631	<
11632	<
11633	<	SWIGINTERN PyObject *_wrap_BossSession_selectTasks__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11634	<	PyObject *resultobj = 0;
11635	<	BossSession *arg1 = (BossSession *) 0 ;
11636	<	std::string *arg2 = 0 ;
11637	<	std::string *arg3 = 0 ;
11638	<	std::string *arg4 = 0 ;
11639	<	std::vector<std::string,std::allocator<std::string > > result;
11640	<	void *argp1 = 0 ;
11641	<	int res1 = 0 ;
11642	<	int res2 = SWIG_OLDOBJ ;
11643	<	int res3 = SWIG_OLDOBJ ;
11644	<	int res4 = SWIG_OLDOBJ ;
11645	<	PyObject * obj0 = 0 ;
11646	<	PyObject * obj1 = 0 ;
11647	<	PyObject * obj2 = 0 ;
11648	<	PyObject * obj3 = 0 ;
11649	<
11650	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11651	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11652	<	if (!SWIG_IsOK(res1)) {
11653	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_selectTasks" "', argument " "1"" of type '" "BossSession *""'");
11654	<	}
11655	<	arg1 = reinterpret_cast< BossSession * >(argp1);
11656	<	{
11657	<	std::string *ptr = (std::string *)0;
11658	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11659	<	if (!SWIG_IsOK(res2)) {
11660	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11661	<	}
11662	<	if (!ptr) {
11663	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11664	<	}
11665	<	arg2 = ptr;
11666	<	}
11667	<	{
11668	<	std::string *ptr = (std::string *)0;
11669	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11670	<	if (!SWIG_IsOK(res3)) {
11671	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11672	<	}
11673	<	if (!ptr) {
11674	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11675	<	}
11676	<	arg3 = ptr;
11677	<	}
11678	<	{
11679	<	std::string *ptr = (std::string *)0;
11680	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
11681	<	if (!SWIG_IsOK(res4)) {
11682	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_selectTasks" "', argument " "4"" of type '" "std::string const &""'");
11683	<	}
11684	<	if (!ptr) {
11685	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "4"" of type '" "std::string const &""'");
11686	<	}
11687	<	arg4 = ptr;
11688	<	}
11689	<	{
11690	<	try {
11691	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
11692	<	} catch (const std::exception& e) {
11693	<	SWIG_exception(SWIG_RuntimeError, e.what());
11694	<	}
11695	<	}
11696	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
11697	<	if (SWIG_IsNewObj(res2)) delete arg2;
11698	<	if (SWIG_IsNewObj(res3)) delete arg3;
11699	<	if (SWIG_IsNewObj(res4)) delete arg4;
11700	<	return resultobj;
11701	<	fail:
11702	<	if (SWIG_IsNewObj(res2)) delete arg2;
11703	<	if (SWIG_IsNewObj(res3)) delete arg3;
11704	<	if (SWIG_IsNewObj(res4)) delete arg4;
11705	<	return NULL;
11706	<	}
11707	<
11708	<
11709	<	SWIGINTERN PyObject *_wrap_BossSession_selectTasks__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11710	<	PyObject *resultobj = 0;
11711	<	BossSession *arg1 = (BossSession *) 0 ;
11712	<	std::string *arg2 = 0 ;
11713	<	std::string *arg3 = 0 ;
11714	<	std::vector<std::string,std::allocator<std::string > > result;
11715	<	void *argp1 = 0 ;
11716	<	int res1 = 0 ;
11717	<	int res2 = SWIG_OLDOBJ ;
11718	<	int res3 = SWIG_OLDOBJ ;
11719	<	PyObject * obj0 = 0 ;
11720	<	PyObject * obj1 = 0 ;
11721	<	PyObject * obj2 = 0 ;
11722	<
11723	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_selectTasks",&obj0,&obj1,&obj2)) SWIG_fail;
11724	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11725	<	if (!SWIG_IsOK(res1)) {
11726	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_selectTasks" "', argument " "1"" of type '" "BossSession *""'");
11727	<	}
11728	<	arg1 = reinterpret_cast< BossSession * >(argp1);
11729	<	{
11730	<	std::string *ptr = (std::string *)0;
11731	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11732	<	if (!SWIG_IsOK(res2)) {
11733	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11734	<	}
11735	<	if (!ptr) {
11736	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11737	<	}
11738	<	arg2 = ptr;
11739	<	}
11740	<	{
11741	<	std::string *ptr = (std::string *)0;
11742	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11743	<	if (!SWIG_IsOK(res3)) {
11744	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11745	<	}
11746	<	if (!ptr) {
11747	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11748	<	}
11749	<	arg3 = ptr;
11750	<	}
11751	<	{
11752	<	try {
11753	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3);
11754	<	} catch (const std::exception& e) {
11755	<	SWIG_exception(SWIG_RuntimeError, e.what());
11756	<	}
11757	<	}
11758	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
11759	<	if (SWIG_IsNewObj(res2)) delete arg2;
11760	<	if (SWIG_IsNewObj(res3)) delete arg3;
11761	<	return resultobj;
11762	<	fail:
11763	<	if (SWIG_IsNewObj(res2)) delete arg2;
11764	<	if (SWIG_IsNewObj(res3)) delete arg3;
11765	<	return NULL;
11766	<	}
11767	<
11768	<
11769	<	SWIGINTERN PyObject *_wrap_BossSession_selectTasks__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11770	<	PyObject *resultobj = 0;
11771	<	BossSession *arg1 = (BossSession *) 0 ;
11772	<	std::string *arg2 = 0 ;
11773	<	std::vector<std::string,std::allocator<std::string > > result;
11774	<	void *argp1 = 0 ;
11775	<	int res1 = 0 ;
11776	<	int res2 = SWIG_OLDOBJ ;
11777	<	PyObject * obj0 = 0 ;
11778	<	PyObject * obj1 = 0 ;
11779	<
11780	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasks",&obj0,&obj1)) SWIG_fail;
11781	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11782	<	if (!SWIG_IsOK(res1)) {
11783	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_selectTasks" "', argument " "1"" of type '" "BossSession *""'");
11784	<	}
11785	<	arg1 = reinterpret_cast< BossSession * >(argp1);
11786	<	{
11787	<	std::string *ptr = (std::string *)0;
11788	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11789	<	if (!SWIG_IsOK(res2)) {
11790	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11791	<	}
11792	<	if (!ptr) {
11793	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11794	<	}
11795	<	arg2 = ptr;
11796	<	}
11797	<	{
11798	<	try {
11799	<	result = (arg1)->selectTasks((std::string const &)*arg2);
11800	<	} catch (const std::exception& e) {
11801	<	SWIG_exception(SWIG_RuntimeError, e.what());
11802	<	}
11803	<	}
11804	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
11805	<	if (SWIG_IsNewObj(res2)) delete arg2;
11806	<	return resultobj;
11807	<	fail:
11808	<	if (SWIG_IsNewObj(res2)) delete arg2;
11809	<	return NULL;
11810	<	}
11811	<
11812	<
11813	<	SWIGINTERN PyObject *_wrap_BossSession_selectTasks__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11814	<	PyObject *resultobj = 0;
11815	<	BossSession *arg1 = (BossSession *) 0 ;
11816	<	std::vector<std::string,std::allocator<std::string > > result;
11817	<	void *argp1 = 0 ;
11818	<	int res1 = 0 ;
11819	<	PyObject * obj0 = 0 ;
11820	<
11821	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_selectTasks",&obj0)) SWIG_fail;
11822	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11823	<	if (!SWIG_IsOK(res1)) {
11824	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_selectTasks" "', argument " "1"" of type '" "BossSession *""'");
11825	<	}
11826	<	arg1 = reinterpret_cast< BossSession * >(argp1);
11827	<	{
11828	<	try {
11829	<	result = (arg1)->selectTasks();
11830	<	} catch (const std::exception& e) {
11831	<	SWIG_exception(SWIG_RuntimeError, e.what());
3165	>	{
3166	>	resultobj = PyTuple_New((&result)->size());
3167	>	for (unsigned int i=0; i<(&result)->size(); i++)
3168	>	PyTuple_SetItem(resultobj,i,
3169	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3170		}
3171	<	}
3172	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
3173	<	return resultobj;
11836	<	fail:
11837	<	return NULL;
3171	>	return resultobj;
3172	>	fail:
3173	>	return NULL;
3174		}
3175
3176
3177	<	SWIGINTERN PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3178	<	int argc;
3179	<	PyObject *argv[6];
3180	<	int ii;
3181	<
3182	<	if (!PyTuple_Check(args)) SWIG_fail;
3183	<	argc = PyObject_Length(args);
3184	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
3185	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3186	<	}
3187	<	if (argc == 1) {
3188	<	int _v;
3189	<	void *vptr = 0;
3190	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3191	<	_v = SWIG_CheckState(res);
3192	<	if (_v) {
3193	<	return _wrap_BossSession_selectTasks__SWIG_4(self, args);
3194	<	}
3195	<	}
3196	<	if (argc == 2) {
3197	<	int _v;
3198	<	void *vptr = 0;
3199	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3200	<	_v = SWIG_CheckState(res);
3201	<	if (_v) {
3202	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3203	<	_v = SWIG_CheckState(res);
3204	<	if (_v) {
3205	<	return _wrap_BossSession_selectTasks__SWIG_3(self, args);
3206	<	}
3207	<	}
3208	<	}
3209	<	if (argc == 3) {
3210	<	int _v;
3211	<	void *vptr = 0;
3212	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3213	<	_v = SWIG_CheckState(res);
3214	<	if (_v) {
3215	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
11880	<	_v = SWIG_CheckState(res);
11881	<	if (_v) {
11882	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11883	<	_v = SWIG_CheckState(res);
11884	<	if (_v) {
11885	<	return _wrap_BossSession_selectTasks__SWIG_2(self, args);
3177	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3178	>	PyObject *resultobj;
3179	>	BossSession *arg1 = (BossSession *) 0 ;
3180	>	int arg2 = (int) SCHEDULED ;
3181	>	std::string const &arg3_defvalue = "all" ;
3182	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3183	>	std::string const &arg4_defvalue = "all" ;
3184	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3185	>	std::string const &arg5_defvalue = "" ;
3186	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3187	>	std::string arg6 = (std::string) "" ;
3188	>	std::string arg7 = (std::string) "" ;
3189	>	std::string arg8 = (std::string) "" ;
3190	>	std::string arg9 = (std::string) "" ;
3191	>	bool arg10 = (bool) false ;
3192	>	SwigValueWrapper< std::vector<BossTask * > > result;
3193	>	std::string temp3 ;
3194	>	std::string temp4 ;
3195	>	std::string temp5 ;
3196	>	PyObject * obj0 = 0 ;
3197	>	PyObject * obj2 = 0 ;
3198	>	PyObject * obj3 = 0 ;
3199	>	PyObject * obj4 = 0 ;
3200	>	PyObject * obj5 = 0 ;
3201	>	PyObject * obj6 = 0 ;
3202	>	PyObject * obj7 = 0 ;
3203	>	PyObject * obj8 = 0 ;
3204	>	PyObject * obj9 = 0 ;
3205	>
3206	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3207	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3208	>	if (obj2) {
3209	>	{
3210	>	if (PyString_Check(obj2)) {
3211	>	temp3 = std::string(PyString_AsString(obj2));
3212	>	arg3 = &temp3;
3213	>	}else {
3214	>	SWIG_exception(SWIG_TypeError, "string expected");
3215	>	}
3216		}
11887	–	}
3217		}
3218	<	}
3219	<	if (argc == 4) {
3220	<	int _v;
3221	<	void *vptr = 0;
3222	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3223	<	_v = SWIG_CheckState(res);
3224	<	if (_v) {
3225	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
11897	<	_v = SWIG_CheckState(res);
11898	<	if (_v) {
11899	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11900	<	_v = SWIG_CheckState(res);
11901	<	if (_v) {
11902	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
11903	<	_v = SWIG_CheckState(res);
11904	<	if (_v) {
11905	<	return _wrap_BossSession_selectTasks__SWIG_1(self, args);
11906	<	}
3218	>	if (obj3) {
3219	>	{
3220	>	if (PyString_Check(obj3)) {
3221	>	temp4 = std::string(PyString_AsString(obj3));
3222	>	arg4 = &temp4;
3223	>	}else {
3224	>	SWIG_exception(SWIG_TypeError, "string expected");
3225	>	}
3226		}
11908	–	}
3227		}
3228	<	}
3229	<	if (argc == 5) {
3230	<	int _v;
3231	<	void *vptr = 0;
3232	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3233	<	_v = SWIG_CheckState(res);
3234	<	if (_v) {
11917	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
11918	<	_v = SWIG_CheckState(res);
11919	<	if (_v) {
11920	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11921	<	_v = SWIG_CheckState(res);
11922	<	if (_v) {
11923	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
11924	<	_v = SWIG_CheckState(res);
11925	<	if (_v) {
11926	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
11927	<	_v = SWIG_CheckState(res);
11928	<	if (_v) {
11929	<	return _wrap_BossSession_selectTasks__SWIG_0(self, args);
3228	>	if (obj4) {
3229	>	{
3230	>	if (PyString_Check(obj4)) {
3231	>	temp5 = std::string(PyString_AsString(obj4));
3232	>	arg5 = &temp5;
3233	>	}else {
3234	>	SWIG_exception(SWIG_TypeError, "string expected");
3235		}
11931	–	}
3236		}
11933	–	}
11934	–	}
11935	–	}
11936	–
11937	–	fail:
11938	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_selectTasks'");
11939	–	return NULL;
11940	–	}
11941	–
11942	–
11943	–	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11944	–	PyObject *resultobj = 0;
11945	–	BossSession *arg1 = (BossSession *) 0 ;
11946	–	int arg2 ;
11947	–	std::string *arg3 = 0 ;
11948	–	std::string *arg4 = 0 ;
11949	–	std::string *arg5 = 0 ;
11950	–	std::string arg6 ;
11951	–	std::string arg7 ;
11952	–	std::string arg8 ;
11953	–	std::string arg9 ;
11954	–	bool arg10 ;
11955	–	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
11956	–	void *argp1 = 0 ;
11957	–	int res1 = 0 ;
11958	–	int val2 ;
11959	–	int ecode2 = 0 ;
11960	–	int res3 = SWIG_OLDOBJ ;
11961	–	int res4 = SWIG_OLDOBJ ;
11962	–	int res5 = SWIG_OLDOBJ ;
11963	–	bool val10 ;
11964	–	int ecode10 = 0 ;
11965	–	PyObject * obj0 = 0 ;
11966	–	PyObject * obj1 = 0 ;
11967	–	PyObject * obj2 = 0 ;
11968	–	PyObject * obj3 = 0 ;
11969	–	PyObject * obj4 = 0 ;
11970	–	PyObject * obj5 = 0 ;
11971	–	PyObject * obj6 = 0 ;
11972	–	PyObject * obj7 = 0 ;
11973	–	PyObject * obj8 = 0 ;
11974	–	PyObject * obj9 = 0 ;
11975	–
11976	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
11977	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11978	–	if (!SWIG_IsOK(res1)) {
11979	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
11980	–	}
11981	–	arg1 = reinterpret_cast< BossSession * >(argp1);
11982	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
11983	–	if (!SWIG_IsOK(ecode2)) {
11984	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
11985	–	}
11986	–	arg2 = static_cast< int >(val2);
11987	–	{
11988	–	std::string *ptr = (std::string *)0;
11989	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11990	–	if (!SWIG_IsOK(res3)) {
11991	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
11992	–	}
11993	–	if (!ptr) {
11994	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
3237		}
3238	<	arg3 = ptr;
3239	<	}
3240	<	{
3241	<	std::string *ptr = (std::string *)0;
3242	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
3243	<	if (!SWIG_IsOK(res4)) {
3244	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12003	<	}
12004	<	if (!ptr) {
12005	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12006	<	}
12007	<	arg4 = ptr;
12008	<	}
12009	<	{
12010	<	std::string *ptr = (std::string *)0;
12011	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
12012	<	if (!SWIG_IsOK(res5)) {
12013	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
3238	>	if (obj5) {
3239	>	{
3240	>	if (PyString_Check(obj5))
3241	>	arg6 = std::string(PyString_AsString(obj5));
3242	>	else
3243	>	SWIG_exception(SWIG_TypeError, "string expected");
3244	>	}
3245		}
3246	<	if (!ptr) {
3247	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
3246	>	if (obj6) {
3247	>	{
3248	>	if (PyString_Check(obj6))
3249	>	arg7 = std::string(PyString_AsString(obj6));
3250	>	else
3251	>	SWIG_exception(SWIG_TypeError, "string expected");
3252	>	}
3253		}
3254	<	arg5 = ptr;
3255	<	}
3256	<	{
3257	<	std::string *ptr = (std::string *)0;
3258	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
3259	<	if (!SWIG_IsOK(res) || !ptr) {
3260	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "6"" of type '" "std::string""'");
3254	>	if (obj7) {
3255	>	{
3256	>	if (PyString_Check(obj7))
3257	>	arg8 = std::string(PyString_AsString(obj7));
3258	>	else
3259	>	SWIG_exception(SWIG_TypeError, "string expected");
3260	>	}
3261		}
3262	<	arg6 = *ptr;
3263	<	if (SWIG_IsNewObj(res)) delete ptr;
3264	<	}
3265	<	{
3266	<	std::string *ptr = (std::string *)0;
3267	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
3268	<	if (!SWIG_IsOK(res) || !ptr) {
12033	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "7"" of type '" "std::string""'");
3262	>	if (obj8) {
3263	>	{
3264	>	if (PyString_Check(obj8))
3265	>	arg9 = std::string(PyString_AsString(obj8));
3266	>	else
3267	>	SWIG_exception(SWIG_TypeError, "string expected");
3268	>	}
3269		}
3270	<	arg7 = *ptr;
3271	<	if (SWIG_IsNewObj(res)) delete ptr;
3272	<	}
12038	<	{
12039	<	std::string *ptr = (std::string *)0;
12040	<	int res = SWIG_AsPtr_std_string(obj7, &ptr);
12041	<	if (!SWIG_IsOK(res) || !ptr) {
12042	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "8"" of type '" "std::string""'");
3270	>	if (obj9) {
3271	>	arg10 = PyInt_AsLong(obj9) ? true : false;
3272	>	if (PyErr_Occurred()) SWIG_fail;
3273		}
3274	<	arg8 = *ptr;
3275	<	if (SWIG_IsNewObj(res)) delete ptr;
3276	<	}
3277	<	{
3278	<	std::string *ptr = (std::string *)0;
3279	<	int res = SWIG_AsPtr_std_string(obj8, &ptr);
3280	<	if (!SWIG_IsOK(res) || !ptr) {
3281	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "9"" of type '" "std::string""'");
3274	>	{
3275	>	try {
3276	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3277	>
3278	>	}catch (const BossSchedFailure & e) {
3279	>	PyErr_SetString ( SchedulerError, e.what() );
3280	>	return NULL;
3281	>	}catch (const std::exception& e) {
3282	>	PyErr_SetString ( BossError, e.what() );
3283	>	return NULL;
3284	>	}
3285		}
3286	<	arg9 = *ptr;
3287	<	if (SWIG_IsNewObj(res)) delete ptr;
3288	<	}
3289	<	ecode10 = SWIG_AsVal_bool(obj9, &val10);
12057	<	if (!SWIG_IsOK(ecode10)) {
12058	<	SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "BossSession_query" "', argument " "10"" of type '" "bool""'");
12059	<	}
12060	<	arg10 = static_cast< bool >(val10);
12061	<	{
12062	<	try {
12063	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
12064	<	} catch (const std::exception& e) {
12065	<	SWIG_exception(SWIG_RuntimeError, e.what());
3286	>	{
3287	>	std::vector<BossTask * > * resultptr;
3288	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3289	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3290		}
3291	<	}
3292	<	resultobj = SWIG_NewPointerObj((new std::vector<BossTask *,std::allocator<BossTask * > >(static_cast< const std::vector<BossTask *,std::allocator<BossTask * > >& >(result))), SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, SWIG_POINTER_OWN |  0 );
3293	<	if (SWIG_IsNewObj(res3)) delete arg3;
12070	<	if (SWIG_IsNewObj(res4)) delete arg4;
12071	<	if (SWIG_IsNewObj(res5)) delete arg5;
12072	<	return resultobj;
12073	<	fail:
12074	<	if (SWIG_IsNewObj(res3)) delete arg3;
12075	<	if (SWIG_IsNewObj(res4)) delete arg4;
12076	<	if (SWIG_IsNewObj(res5)) delete arg5;
12077	<	return NULL;
3291	>	return resultobj;
3292	>	fail:
3293	>	return NULL;
3294		}
3295
3296
3297	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3298	<	PyObject *resultobj = 0;
3299	<	BossSession *arg1 = (BossSession *) 0 ;
3300	<	int arg2 ;
3301	<	std::string *arg3 = 0 ;
3302	<	std::string *arg4 = 0 ;
3303	<	std::string *arg5 = 0 ;
3304	<	std::string arg6 ;
3305	<	std::string arg7 ;
3306	<	std::string arg8 ;
3307	<	std::string arg9 ;
3308	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3309	<	void *argp1 = 0 ;
12094	<	int res1 = 0 ;
12095	<	int val2 ;
12096	<	int ecode2 = 0 ;
12097	<	int res3 = SWIG_OLDOBJ ;
12098	<	int res4 = SWIG_OLDOBJ ;
12099	<	int res5 = SWIG_OLDOBJ ;
12100	<	PyObject * obj0 = 0 ;
12101	<	PyObject * obj1 = 0 ;
12102	<	PyObject * obj2 = 0 ;
12103	<	PyObject * obj3 = 0 ;
12104	<	PyObject * obj4 = 0 ;
12105	<	PyObject * obj5 = 0 ;
12106	<	PyObject * obj6 = 0 ;
12107	<	PyObject * obj7 = 0 ;
12108	<	PyObject * obj8 = 0 ;
12109	<
12110	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
12111	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
12112	<	if (!SWIG_IsOK(res1)) {
12113	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
12114	<	}
12115	<	arg1 = reinterpret_cast< BossSession * >(argp1);
12116	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
12117	<	if (!SWIG_IsOK(ecode2)) {
12118	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
12119	<	}
12120	<	arg2 = static_cast< int >(val2);
12121	<	{
12122	<	std::string *ptr = (std::string *)0;
12123	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
12124	<	if (!SWIG_IsOK(res3)) {
12125	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12126	<	}
12127	<	if (!ptr) {
12128	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12129	<	}
12130	<	arg3 = ptr;
12131	<	}
12132	<	{
12133	<	std::string *ptr = (std::string *)0;
12134	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
12135	<	if (!SWIG_IsOK(res4)) {
12136	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12137	<	}
12138	<	if (!ptr) {
12139	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12140	<	}
12141	<	arg4 = ptr;
12142	<	}
12143	<	{
12144	<	std::string *ptr = (std::string *)0;
12145	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
12146	<	if (!SWIG_IsOK(res5)) {
12147	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12148	<	}
12149	<	if (!ptr) {
12150	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12151	<	}
12152	<	arg5 = ptr;
12153	<	}
12154	<	{
12155	<	std::string *ptr = (std::string *)0;
12156	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
12157	<	if (!SWIG_IsOK(res) || !ptr) {
12158	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "6"" of type '" "std::string""'");
12159	<	}
12160	<	arg6 = *ptr;
12161	<	if (SWIG_IsNewObj(res)) delete ptr;
12162	<	}
12163	<	{
12164	<	std::string *ptr = (std::string *)0;
12165	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
12166	<	if (!SWIG_IsOK(res) || !ptr) {
12167	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "7"" of type '" "std::string""'");
12168	<	}
12169	<	arg7 = *ptr;
12170	<	if (SWIG_IsNewObj(res)) delete ptr;
12171	<	}
12172	<	{
12173	<	std::string *ptr = (std::string *)0;
12174	<	int res = SWIG_AsPtr_std_string(obj7, &ptr);
12175	<	if (!SWIG_IsOK(res) || !ptr) {
12176	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "8"" of type '" "std::string""'");
12177	<	}
12178	<	arg8 = *ptr;
12179	<	if (SWIG_IsNewObj(res)) delete ptr;
12180	<	}
12181	<	{
12182	<	std::string *ptr = (std::string *)0;
12183	<	int res = SWIG_AsPtr_std_string(obj8, &ptr);
12184	<	if (!SWIG_IsOK(res) || !ptr) {
12185	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "9"" of type '" "std::string""'");
3297	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3298	>	PyObject *resultobj;
3299	>	BossSession *arg1 = (BossSession *) 0 ;
3300	>	std::vector<std::string > *arg2 = 0 ;
3301	>	PyObject *result;
3302	>	PyObject * obj0 = 0 ;
3303	>	PyObject * obj1 = 0 ;
3304	>
3305	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3306	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3307	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3308	>	if (arg2 == NULL) {
3309	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3310		}
3311	<	arg9 = *ptr;
3312	<	if (SWIG_IsNewObj(res)) delete ptr;
3313	<	}
3314	<	{
3315	<	try {
3316	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3317	<	} catch (const std::exception& e) {
3318	<	SWIG_exception(SWIG_RuntimeError, e.what());
3311	>	{
3312	>	try {
3313	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3314	>
3315	>	}catch (const BossSchedFailure & e) {
3316	>	PyErr_SetString ( SchedulerError, e.what() );
3317	>	return NULL;
3318	>	}catch (const std::exception& e) {
3319	>	PyErr_SetString ( BossError, e.what() );
3320	>	return NULL;
3321	>	}
3322		}
3323	<	}
3324	<	resultobj = SWIG_NewPointerObj((new std::vector<BossTask *,std::allocator<BossTask * > >(static_cast< const std::vector<BossTask *,std::allocator<BossTask * > >& >(result))), SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, SWIG_POINTER_OWN |  0 );
3325	<	if (SWIG_IsNewObj(res3)) delete arg3;
3326	<	if (SWIG_IsNewObj(res4)) delete arg4;
12200	<	if (SWIG_IsNewObj(res5)) delete arg5;
12201	<	return resultobj;
12202	<	fail:
12203	<	if (SWIG_IsNewObj(res3)) delete arg3;
12204	<	if (SWIG_IsNewObj(res4)) delete arg4;
12205	<	if (SWIG_IsNewObj(res5)) delete arg5;
12206	<	return NULL;
3323	>	resultobj = result;
3324	>	return resultobj;
3325	>	fail:
3326	>	return NULL;
3327		}
3328
3329
3330	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3331	<	PyObject *resultobj = 0;
3332	<	BossSession *arg1 = (BossSession *) 0 ;
3333	<	int arg2 ;
3334	<	std::string *arg3 = 0 ;
3335	<	std::string *arg4 = 0 ;
3336	<	std::string *arg5 = 0 ;
3337	<	std::string arg6 ;
3338	<	std::string arg7 ;
3339	<	std::string arg8 ;
3340	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3341	<	void *argp1 = 0 ;
3342	<	int res1 = 0 ;
3343	<	int val2 ;
3344	<	int ecode2 = 0 ;
3345	<	int res3 = SWIG_OLDOBJ ;
3346	<	int res4 = SWIG_OLDOBJ ;
3347	<	int res5 = SWIG_OLDOBJ ;
3348	<	PyObject * obj0 = 0 ;
12229	<	PyObject * obj1 = 0 ;
12230	<	PyObject * obj2 = 0 ;
12231	<	PyObject * obj3 = 0 ;
12232	<	PyObject * obj4 = 0 ;
12233	<	PyObject * obj5 = 0 ;
12234	<	PyObject * obj6 = 0 ;
12235	<	PyObject * obj7 = 0 ;
12236	<
12237	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
12238	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
12239	<	if (!SWIG_IsOK(res1)) {
12240	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
12241	<	}
12242	<	arg1 = reinterpret_cast< BossSession * >(argp1);
12243	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
12244	<	if (!SWIG_IsOK(ecode2)) {
12245	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
12246	<	}
12247	<	arg2 = static_cast< int >(val2);
12248	<	{
12249	<	std::string *ptr = (std::string *)0;
12250	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
12251	<	if (!SWIG_IsOK(res3)) {
12252	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12253	<	}
12254	<	if (!ptr) {
12255	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12256	<	}
12257	<	arg3 = ptr;
12258	<	}
12259	<	{
12260	<	std::string *ptr = (std::string *)0;
12261	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
12262	<	if (!SWIG_IsOK(res4)) {
12263	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12264	<	}
12265	<	if (!ptr) {
12266	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12267	<	}
12268	<	arg4 = ptr;
12269	<	}
12270	<	{
12271	<	std::string *ptr = (std::string *)0;
12272	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
12273	<	if (!SWIG_IsOK(res5)) {
12274	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12275	<	}
12276	<	if (!ptr) {
12277	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12278	<	}
12279	<	arg5 = ptr;
12280	<	}
12281	<	{
12282	<	std::string *ptr = (std::string *)0;
12283	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
12284	<	if (!SWIG_IsOK(res) || !ptr) {
12285	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "6"" of type '" "std::string""'");
12286	<	}
12287	<	arg6 = *ptr;
12288	<	if (SWIG_IsNewObj(res)) delete ptr;
12289	<	}
12290	<	{
12291	<	std::string *ptr = (std::string *)0;
12292	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
12293	<	if (!SWIG_IsOK(res) || !ptr) {
12294	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "7"" of type '" "std::string""'");
12295	<	}
12296	<	arg7 = *ptr;
12297	<	if (SWIG_IsNewObj(res)) delete ptr;
12298	<	}
12299	<	{
12300	<	std::string *ptr = (std::string *)0;
12301	<	int res = SWIG_AsPtr_std_string(obj7, &ptr);
12302	<	if (!SWIG_IsOK(res) || !ptr) {
12303	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "8"" of type '" "std::string""'");
12304	<	}
12305	<	arg8 = *ptr;
12306	<	if (SWIG_IsNewObj(res)) delete ptr;
12307	<	}
12308	<	{
12309	<	try {
12310	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8);
12311	<	} catch (const std::exception& e) {
12312	<	SWIG_exception(SWIG_RuntimeError, e.what());
3330	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3331	>	PyObject *resultobj;
3332	>	BossSession *arg1 = (BossSession *) 0 ;
3333	>	PyObject *result;
3334	>	PyObject * obj0 = 0 ;
3335	>
3336	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3337	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3338	>	{
3339	>	try {
3340	>	result = (PyObject *)BossSession_CHTools(arg1);
3341	>
3342	>	}catch (const BossSchedFailure & e) {
3343	>	PyErr_SetString ( SchedulerError, e.what() );
3344	>	return NULL;
3345	>	}catch (const std::exception& e) {
3346	>	PyErr_SetString ( BossError, e.what() );
3347	>	return NULL;
3348	>	}
3349		}
3350	<	}
3351	<	resultobj = SWIG_NewPointerObj((new std::vector<BossTask *,std::allocator<BossTask * > >(static_cast< const std::vector<BossTask *,std::allocator<BossTask * > >& >(result))), SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, SWIG_POINTER_OWN |  0 );
3352	<	if (SWIG_IsNewObj(res3)) delete arg3;
3353	<	if (SWIG_IsNewObj(res4)) delete arg4;
12318	<	if (SWIG_IsNewObj(res5)) delete arg5;
12319	<	return resultobj;
12320	<	fail:
12321	<	if (SWIG_IsNewObj(res3)) delete arg3;
12322	<	if (SWIG_IsNewObj(res4)) delete arg4;
12323	<	if (SWIG_IsNewObj(res5)) delete arg5;
12324	<	return NULL;
3350	>	resultobj = result;
3351	>	return resultobj;
3352	>	fail:
3353	>	return NULL;
3354		}
3355
3356
3357	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3358	<	PyObject *resultobj = 0;
3359	<	BossSession *arg1 = (BossSession *) 0 ;
3360	<	int arg2 ;
3361	<	std::string *arg3 = 0 ;
3362	<	std::string *arg4 = 0 ;
3363	<	std::string *arg5 = 0 ;
3364	<	std::string arg6 ;
3365	<	std::string arg7 ;
3366	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3367	<	void *argp1 = 0 ;
3368	<	int res1 = 0 ;
3369	<	int val2 ;
3370	<	int ecode2 = 0 ;
3371	<	int res3 = SWIG_OLDOBJ ;
3372	<	int res4 = SWIG_OLDOBJ ;
3373	<	int res5 = SWIG_OLDOBJ ;
3374	<	PyObject * obj0 = 0 ;
3375	<	PyObject * obj1 = 0 ;
12347	<	PyObject * obj2 = 0 ;
12348	<	PyObject * obj3 = 0 ;
12349	<	PyObject * obj4 = 0 ;
12350	<	PyObject * obj5 = 0 ;
12351	<	PyObject * obj6 = 0 ;
12352	<
12353	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
12354	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
12355	<	if (!SWIG_IsOK(res1)) {
12356	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
12357	<	}
12358	<	arg1 = reinterpret_cast< BossSession * >(argp1);
12359	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
12360	<	if (!SWIG_IsOK(ecode2)) {
12361	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
12362	<	}
12363	<	arg2 = static_cast< int >(val2);
12364	<	{
12365	<	std::string *ptr = (std::string *)0;
12366	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
12367	<	if (!SWIG_IsOK(res3)) {
12368	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12369	<	}
12370	<	if (!ptr) {
12371	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12372	<	}
12373	<	arg3 = ptr;
12374	<	}
12375	<	{
12376	<	std::string *ptr = (std::string *)0;
12377	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
12378	<	if (!SWIG_IsOK(res4)) {
12379	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12380	<	}
12381	<	if (!ptr) {
12382	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12383	<	}
12384	<	arg4 = ptr;
12385	<	}
12386	<	{
12387	<	std::string *ptr = (std::string *)0;
12388	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
12389	<	if (!SWIG_IsOK(res5)) {
12390	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12391	<	}
12392	<	if (!ptr) {
12393	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12394	<	}
12395	<	arg5 = ptr;
12396	<	}
12397	<	{
12398	<	std::string *ptr = (std::string *)0;
12399	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
12400	<	if (!SWIG_IsOK(res) || !ptr) {
12401	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "6"" of type '" "std::string""'");
12402	<	}
12403	<	arg6 = *ptr;
12404	<	if (SWIG_IsNewObj(res)) delete ptr;
12405	<	}
12406	<	{
12407	<	std::string *ptr = (std::string *)0;
12408	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
12409	<	if (!SWIG_IsOK(res) || !ptr) {
12410	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "7"" of type '" "std::string""'");
12411	<	}
12412	<	arg7 = *ptr;
12413	<	if (SWIG_IsNewObj(res)) delete ptr;
12414	<	}
12415	<	{
12416	<	try {
12417	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
12418	<	} catch (const std::exception& e) {
12419	<	SWIG_exception(SWIG_RuntimeError, e.what());
3357	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3358	>	PyObject *resultobj;
3359	>	BossSession *arg1 = (BossSession *) 0 ;
3360	>	PyObject *result;
3361	>	PyObject * obj0 = 0 ;
3362	>
3363	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3364	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3365	>	{
3366	>	try {
3367	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3368	>
3369	>	}catch (const BossSchedFailure & e) {
3370	>	PyErr_SetString ( SchedulerError, e.what() );
3371	>	return NULL;
3372	>	}catch (const std::exception& e) {
3373	>	PyErr_SetString ( BossError, e.what() );
3374	>	return NULL;
3375	>	}
3376		}
3377	<	}
3378	<	resultobj = SWIG_NewPointerObj((new std::vector<BossTask *,std::allocator<BossTask * > >(static_cast< const std::vector<BossTask *,std::allocator<BossTask * > >& >(result))), SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, SWIG_POINTER_OWN |  0 );
3379	<	if (SWIG_IsNewObj(res3)) delete arg3;
3380	<	if (SWIG_IsNewObj(res4)) delete arg4;
12425	<	if (SWIG_IsNewObj(res5)) delete arg5;
12426	<	return resultobj;
12427	<	fail:
12428	<	if (SWIG_IsNewObj(res3)) delete arg3;
12429	<	if (SWIG_IsNewObj(res4)) delete arg4;
12430	<	if (SWIG_IsNewObj(res5)) delete arg5;
12431	<	return NULL;
3377	>	resultobj = result;
3378	>	return resultobj;
3379	>	fail:
3380	>	return NULL;
3381		}
3382
3383
3384	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3385	<	PyObject *resultobj = 0;
3386	<	BossSession *arg1 = (BossSession *) 0 ;
3387	<	int arg2 ;
3388	<	std::string *arg3 = 0 ;
3389	<	std::string *arg4 = 0 ;
3390	<	std::string *arg5 = 0 ;
3391	<	std::string arg6 ;
3392	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3393	<	void *argp1 = 0 ;
3394	<	int res1 = 0 ;
3395	<	int val2 ;
3396	<	int ecode2 = 0 ;
3397	<	int res3 = SWIG_OLDOBJ ;
3398	<	int res4 = SWIG_OLDOBJ ;
3399	<	int res5 = SWIG_OLDOBJ ;
3400	<	PyObject * obj0 = 0 ;
3401	<	PyObject * obj1 = 0 ;
3402	<	PyObject * obj2 = 0 ;
12454	<	PyObject * obj3 = 0 ;
12455	<	PyObject * obj4 = 0 ;
12456	<	PyObject * obj5 = 0 ;
12457	<
12458	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
12459	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
12460	<	if (!SWIG_IsOK(res1)) {
12461	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
12462	<	}
12463	<	arg1 = reinterpret_cast< BossSession * >(argp1);
12464	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
12465	<	if (!SWIG_IsOK(ecode2)) {
12466	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
12467	<	}
12468	<	arg2 = static_cast< int >(val2);
12469	<	{
12470	<	std::string *ptr = (std::string *)0;
12471	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
12472	<	if (!SWIG_IsOK(res3)) {
12473	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12474	<	}
12475	<	if (!ptr) {
12476	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12477	<	}
12478	<	arg3 = ptr;
12479	<	}
12480	<	{
12481	<	std::string *ptr = (std::string *)0;
12482	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
12483	<	if (!SWIG_IsOK(res4)) {
12484	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12485	<	}
12486	<	if (!ptr) {
12487	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12488	<	}
12489	<	arg4 = ptr;
12490	<	}
12491	<	{
12492	<	std::string *ptr = (std::string *)0;
12493	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
12494	<	if (!SWIG_IsOK(res5)) {
12495	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12496	<	}
12497	<	if (!ptr) {
12498	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12499	<	}
12500	<	arg5 = ptr;
12501	<	}
12502	<	{
12503	<	std::string *ptr = (std::string *)0;
12504	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
12505	<	if (!SWIG_IsOK(res) || !ptr) {
12506	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "6"" of type '" "std::string""'");
12507	<	}
12508	<	arg6 = *ptr;
12509	<	if (SWIG_IsNewObj(res)) delete ptr;
12510	<	}
12511	<	{
12512	<	try {
12513	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
12514	<	} catch (const std::exception& e) {
12515	<	SWIG_exception(SWIG_RuntimeError, e.what());
3384	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3385	>	PyObject *resultobj;
3386	>	BossSession *arg1 = (BossSession *) 0 ;
3387	>	PyObject *result;
3388	>	PyObject * obj0 = 0 ;
3389	>
3390	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3391	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3392	>	{
3393	>	try {
3394	>	result = (PyObject *)BossSession_RTMons(arg1);
3395	>
3396	>	}catch (const BossSchedFailure & e) {
3397	>	PyErr_SetString ( SchedulerError, e.what() );
3398	>	return NULL;
3399	>	}catch (const std::exception& e) {
3400	>	PyErr_SetString ( BossError, e.what() );
3401	>	return NULL;
3402	>	}
3403		}
3404	<	}
3405	<	resultobj = SWIG_NewPointerObj((new std::vector<BossTask *,std::allocator<BossTask * > >(static_cast< const std::vector<BossTask *,std::allocator<BossTask * > >& >(result))), SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, SWIG_POINTER_OWN |  0 );
3406	<	if (SWIG_IsNewObj(res3)) delete arg3;
3407	<	if (SWIG_IsNewObj(res4)) delete arg4;
12521	<	if (SWIG_IsNewObj(res5)) delete arg5;
12522	<	return resultobj;
12523	<	fail:
12524	<	if (SWIG_IsNewObj(res3)) delete arg3;
12525	<	if (SWIG_IsNewObj(res4)) delete arg4;
12526	<	if (SWIG_IsNewObj(res5)) delete arg5;
12527	<	return NULL;
3404	>	resultobj = result;
3405	>	return resultobj;
3406	>	fail:
3407	>	return NULL;
3408		}
3409
3410
3411	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3412	<	PyObject *resultobj = 0;
3413	<	BossSession *arg1 = (BossSession *) 0 ;
3414	<	int arg2 ;
3415	<	std::string *arg3 = 0 ;
3416	<	std::string *arg4 = 0 ;
3417	<	std::string *arg5 = 0 ;
3418	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3419	<	void *argp1 = 0 ;
3420	<	int res1 = 0 ;
3421	<	int val2 ;
3422	<	int ecode2 = 0 ;
3423	<	int res3 = SWIG_OLDOBJ ;
3424	<	int res4 = SWIG_OLDOBJ ;
3425	<	int res5 = SWIG_OLDOBJ ;
3426	<	PyObject * obj0 = 0 ;
3427	<	PyObject * obj1 = 0 ;
3428	<	PyObject * obj2 = 0 ;
3429	<	PyObject * obj3 = 0 ;
12550	<	PyObject * obj4 = 0 ;
12551	<
12552	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12553	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
12554	<	if (!SWIG_IsOK(res1)) {
12555	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
12556	<	}
12557	<	arg1 = reinterpret_cast< BossSession * >(argp1);
12558	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
12559	<	if (!SWIG_IsOK(ecode2)) {
12560	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
12561	<	}
12562	<	arg2 = static_cast< int >(val2);
12563	<	{
12564	<	std::string *ptr = (std::string *)0;
12565	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
12566	<	if (!SWIG_IsOK(res3)) {
12567	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12568	<	}
12569	<	if (!ptr) {
12570	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12571	<	}
12572	<	arg3 = ptr;
12573	<	}
12574	<	{
12575	<	std::string *ptr = (std::string *)0;
12576	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
12577	<	if (!SWIG_IsOK(res4)) {
12578	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12579	<	}
12580	<	if (!ptr) {
12581	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12582	<	}
12583	<	arg4 = ptr;
12584	<	}
12585	<	{
12586	<	std::string *ptr = (std::string *)0;
12587	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
12588	<	if (!SWIG_IsOK(res5)) {
12589	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12590	<	}
12591	<	if (!ptr) {
12592	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12593	<	}
12594	<	arg5 = ptr;
12595	<	}
12596	<	{
12597	<	try {
12598	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
12599	<	} catch (const std::exception& e) {
12600	<	SWIG_exception(SWIG_RuntimeError, e.what());
3411	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3412	>	PyObject *resultobj;
3413	>	BossSession *arg1 = (BossSession *) 0 ;
3414	>	PyObject *result;
3415	>	PyObject * obj0 = 0 ;
3416	>
3417	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3418	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3419	>	{
3420	>	try {
3421	>	result = (PyObject *)BossSession_schedulers(arg1);
3422	>
3423	>	}catch (const BossSchedFailure & e) {
3424	>	PyErr_SetString ( SchedulerError, e.what() );
3425	>	return NULL;
3426	>	}catch (const std::exception& e) {
3427	>	PyErr_SetString ( BossError, e.what() );
3428	>	return NULL;
3429	>	}
3430		}
3431	<	}
3432	<	resultobj = SWIG_NewPointerObj((new std::vector<BossTask *,std::allocator<BossTask * > >(static_cast< const std::vector<BossTask *,std::allocator<BossTask * > >& >(result))), SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, SWIG_POINTER_OWN |  0 );
3433	<	if (SWIG_IsNewObj(res3)) delete arg3;
3434	<	if (SWIG_IsNewObj(res4)) delete arg4;
12606	<	if (SWIG_IsNewObj(res5)) delete arg5;
12607	<	return resultobj;
12608	<	fail:
12609	<	if (SWIG_IsNewObj(res3)) delete arg3;
12610	<	if (SWIG_IsNewObj(res4)) delete arg4;
12611	<	if (SWIG_IsNewObj(res5)) delete arg5;
12612	<	return NULL;
3431	>	resultobj = result;
3432	>	return resultobj;
3433	>	fail:
3434	>	return NULL;
3435		}
3436
3437
3438	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3439	<	PyObject *resultobj = 0;
3440	<	BossSession *arg1 = (BossSession *) 0 ;
3441	<	int arg2 ;
3442	<	std::string *arg3 = 0 ;
3443	<	std::string *arg4 = 0 ;
3444	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3445	<	void *argp1 = 0 ;
3446	<	int res1 = 0 ;
3447	<	int val2 ;
3448	<	int ecode2 = 0 ;
3449	<	int res3 = SWIG_OLDOBJ ;
3450	<	int res4 = SWIG_OLDOBJ ;
3451	<	PyObject * obj0 = 0 ;
3452	<	PyObject * obj1 = 0 ;
3453	<	PyObject * obj2 = 0 ;
3454	<	PyObject * obj3 = 0 ;
3455	<
3456	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3457	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3458	<	if (!SWIG_IsOK(res1)) {
3459	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
3460	<	}
3461	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3462	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
3463	<	if (!SWIG_IsOK(ecode2)) {
3464	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
3465	<	}
3466	<	arg2 = static_cast< int >(val2);
3467	<	{
3468	<	std::string *ptr = (std::string *)0;
12647	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
12648	<	if (!SWIG_IsOK(res3)) {
12649	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12650	<	}
12651	<	if (!ptr) {
12652	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12653	<	}
12654	<	arg3 = ptr;
12655	<	}
12656	<	{
12657	<	std::string *ptr = (std::string *)0;
12658	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
12659	<	if (!SWIG_IsOK(res4)) {
12660	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12661	<	}
12662	<	if (!ptr) {
12663	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12664	<	}
12665	<	arg4 = ptr;
12666	<	}
12667	<	{
12668	<	try {
12669	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
12670	<	} catch (const std::exception& e) {
12671	<	SWIG_exception(SWIG_RuntimeError, e.what());
3438	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3439	>	PyObject *resultobj;
3440	>	BossSession *arg1 = (BossSession *) 0 ;
3441	>	std::string *arg2 = 0 ;
3442	>	std::string *arg3 = 0 ;
3443	>	std::string const &arg4_defvalue = "" ;
3444	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3445	>	std::string const &arg5_defvalue = "" ;
3446	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3447	>	bool arg6 = (bool) false ;
3448	>	PyObject *result;
3449	>	std::string temp2 ;
3450	>	std::string temp3 ;
3451	>	std::string temp4 ;
3452	>	std::string temp5 ;
3453	>	PyObject * obj0 = 0 ;
3454	>	PyObject * obj1 = 0 ;
3455	>	PyObject * obj2 = 0 ;
3456	>	PyObject * obj3 = 0 ;
3457	>	PyObject * obj4 = 0 ;
3458	>	PyObject * obj5 = 0 ;
3459	>
3460	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
3461	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3462	>	{
3463	>	if (PyString_Check(obj1)) {
3464	>	temp2 = std::string(PyString_AsString(obj1));
3465	>	arg2 = &temp2;
3466	>	}else {
3467	>	SWIG_exception(SWIG_TypeError, "string expected");
3468	>	}
3469		}
3470	<	}
3471	<	resultobj = SWIG_NewPointerObj((new std::vector<BossTask *,std::allocator<BossTask * > >(static_cast< const std::vector<BossTask *,std::allocator<BossTask * > >& >(result))), SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, SWIG_POINTER_OWN |  0 );
3472	<	if (SWIG_IsNewObj(res3)) delete arg3;
3473	<	if (SWIG_IsNewObj(res4)) delete arg4;
3474	<	return resultobj;
3475	<	fail:
3476	<	if (SWIG_IsNewObj(res3)) delete arg3;
12680	<	if (SWIG_IsNewObj(res4)) delete arg4;
12681	<	return NULL;
12682	<	}
12683	<
12684	<
12685	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12686	<	PyObject *resultobj = 0;
12687	<	BossSession *arg1 = (BossSession *) 0 ;
12688	<	int arg2 ;
12689	<	std::string *arg3 = 0 ;
12690	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
12691	<	void *argp1 = 0 ;
12692	<	int res1 = 0 ;
12693	<	int val2 ;
12694	<	int ecode2 = 0 ;
12695	<	int res3 = SWIG_OLDOBJ ;
12696	<	PyObject * obj0 = 0 ;
12697	<	PyObject * obj1 = 0 ;
12698	<	PyObject * obj2 = 0 ;
12699	<
12700	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_query",&obj0,&obj1,&obj2)) SWIG_fail;
12701	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
12702	<	if (!SWIG_IsOK(res1)) {
12703	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
12704	<	}
12705	<	arg1 = reinterpret_cast< BossSession * >(argp1);
12706	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
12707	<	if (!SWIG_IsOK(ecode2)) {
12708	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
12709	<	}
12710	<	arg2 = static_cast< int >(val2);
12711	<	{
12712	<	std::string *ptr = (std::string *)0;
12713	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
12714	<	if (!SWIG_IsOK(res3)) {
12715	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
3470	>	{
3471	>	if (PyString_Check(obj2)) {
3472	>	temp3 = std::string(PyString_AsString(obj2));
3473	>	arg3 = &temp3;
3474	>	}else {
3475	>	SWIG_exception(SWIG_TypeError, "string expected");
3476	>	}
3477		}
3478	<	if (!ptr) {
3479	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
3478	>	if (obj3) {
3479	>	{
3480	>	if (PyString_Check(obj3)) {
3481	>	temp4 = std::string(PyString_AsString(obj3));
3482	>	arg4 = &temp4;
3483	>	}else {
3484	>	SWIG_exception(SWIG_TypeError, "string expected");
3485	>	}
3486	>	}
3487		}
3488	<	arg3 = ptr;
3489	<	}
3490	<	{
3491	<	try {
3492	<	result = (arg1)->query(arg2,(std::string const &)*arg3);
3493	<	} catch (const std::exception& e) {
3494	<	SWIG_exception(SWIG_RuntimeError, e.what());
3488	>	if (obj4) {
3489	>	{
3490	>	if (PyString_Check(obj4)) {
3491	>	temp5 = std::string(PyString_AsString(obj4));
3492	>	arg5 = &temp5;
3493	>	}else {
3494	>	SWIG_exception(SWIG_TypeError, "string expected");
3495	>	}
3496	>	}
3497		}
3498	<	}
3499	<	resultobj = SWIG_NewPointerObj((new std::vector<BossTask *,std::allocator<BossTask * > >(static_cast< const std::vector<BossTask *,std::allocator<BossTask * > >& >(result))), SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, SWIG_POINTER_OWN |  0 );
3500	<	if (SWIG_IsNewObj(res3)) delete arg3;
12731	<	return resultobj;
12732	<	fail:
12733	<	if (SWIG_IsNewObj(res3)) delete arg3;
12734	<	return NULL;
12735	<	}
12736	<
12737	<
12738	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12739	<	PyObject *resultobj = 0;
12740	<	BossSession *arg1 = (BossSession *) 0 ;
12741	<	int arg2 ;
12742	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
12743	<	void *argp1 = 0 ;
12744	<	int res1 = 0 ;
12745	<	int val2 ;
12746	<	int ecode2 = 0 ;
12747	<	PyObject * obj0 = 0 ;
12748	<	PyObject * obj1 = 0 ;
12749	<
12750	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_query",&obj0,&obj1)) SWIG_fail;
12751	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
12752	<	if (!SWIG_IsOK(res1)) {
12753	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
12754	<	}
12755	<	arg1 = reinterpret_cast< BossSession * >(argp1);
12756	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
12757	<	if (!SWIG_IsOK(ecode2)) {
12758	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
12759	<	}
12760	<	arg2 = static_cast< int >(val2);
12761	<	{
12762	<	try {
12763	<	result = (arg1)->query(arg2);
12764	<	} catch (const std::exception& e) {
12765	<	SWIG_exception(SWIG_RuntimeError, e.what());
3498	>	if (obj5) {
3499	>	arg6 = PyInt_AsLong(obj5) ? true : false;
3500	>	if (PyErr_Occurred()) SWIG_fail;
3501		}
3502	<	}
3503	<	resultobj = SWIG_NewPointerObj((new std::vector<BossTask *,std::allocator<BossTask * > >(static_cast< const std::vector<BossTask *,std::allocator<BossTask * > >& >(result))), SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, SWIG_POINTER_OWN |  0 );
3504	<	return resultobj;
3505	<	fail:
3506	<	return NULL;
3507	<	}
3508	<
3509	<
3510	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3511	<	PyObject *resultobj = 0;
3512	<	BossSession *arg1 = (BossSession *) 0 ;
12778	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
12779	<	void *argp1 = 0 ;
12780	<	int res1 = 0 ;
12781	<	PyObject * obj0 = 0 ;
12782	<
12783	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_query",&obj0)) SWIG_fail;
12784	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
12785	<	if (!SWIG_IsOK(res1)) {
12786	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
12787	<	}
12788	<	arg1 = reinterpret_cast< BossSession * >(argp1);
12789	<	{
12790	<	try {
12791	<	result = (arg1)->query();
12792	<	} catch (const std::exception& e) {
12793	<	SWIG_exception(SWIG_RuntimeError, e.what());
3502	>	{
3503	>	try {
3504	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3505	>
3506	>	}catch (const BossSchedFailure & e) {
3507	>	PyErr_SetString ( SchedulerError, e.what() );
3508	>	return NULL;
3509	>	}catch (const std::exception& e) {
3510	>	PyErr_SetString ( BossError, e.what() );
3511	>	return NULL;
3512	>	}
3513		}
3514	<	}
3515	<	resultobj = SWIG_NewPointerObj((new std::vector<BossTask *,std::allocator<BossTask * > >(static_cast< const std::vector<BossTask *,std::allocator<BossTask * > >& >(result))), SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, SWIG_POINTER_OWN |  0 );
3516	<	return resultobj;
3517	<	fail:
12799	<	return NULL;
3514	>	resultobj = result;
3515	>	return resultobj;
3516	>	fail:
3517	>	return NULL;
3518		}
3519
3520
3521	<	SWIGINTERN PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3522	<	int argc;
3523	<	PyObject *argv[11];
3524	<	int ii;
3525	<
3526	<	if (!PyTuple_Check(args)) SWIG_fail;
3527	<	argc = PyObject_Length(args);
3528	<	for (ii = 0; (ii < argc) && (ii < 10); ii++) {
3529	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3530	<	}
3531	<	if (argc == 1) {
3532	<	int _v;
3533	<	void *vptr = 0;
3534	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3535	<	_v = SWIG_CheckState(res);
3536	<	if (_v) {
3537	<	return _wrap_BossSession_query__SWIG_9(self, args);
3538	<	}
3539	<	}
3540	<	if (argc == 2) {
3541	<	int _v;
3542	<	void *vptr = 0;
3543	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3544	<	_v = SWIG_CheckState(res);
3545	<	if (_v) {
3546	<	{
3547	<	int res = SWIG_AsVal_int(argv[1], NULL);
3548	<	_v = SWIG_CheckState(res);
3549	<	}
3550	<	if (_v) {
3551	<	return _wrap_BossSession_query__SWIG_8(self, args);
3552	<	}
3553	<	}
3554	<	}
3555	<	if (argc == 3) {
3556	<	int _v;
3557	<	void *vptr = 0;
3558	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3559	<	_v = SWIG_CheckState(res);
12842	<	if (_v) {
12843	<	{
12844	<	int res = SWIG_AsVal_int(argv[1], NULL);
12845	<	_v = SWIG_CheckState(res);
12846	<	}
12847	<	if (_v) {
12848	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
12849	<	_v = SWIG_CheckState(res);
12850	<	if (_v) {
12851	<	return _wrap_BossSession_query__SWIG_7(self, args);
3521	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3522	>	PyObject *resultobj;
3523	>	BossSession *arg1 = (BossSession *) 0 ;
3524	>	int arg2 = (int) SCHEDULED ;
3525	>	std::string const &arg3_defvalue = "all" ;
3526	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3527	>	std::string const &arg4_defvalue = "all" ;
3528	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3529	>	std::string const &arg5_defvalue = "" ;
3530	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3531	>	std::string arg6 = (std::string) "" ;
3532	>	std::string arg7 = (std::string) "" ;
3533	>	std::string arg8 = (std::string) "" ;
3534	>	std::string arg9 = (std::string) "" ;
3535	>	bool arg10 = (bool) false ;
3536	>	PyObject *result;
3537	>	std::string temp3 ;
3538	>	std::string temp4 ;
3539	>	std::string temp5 ;
3540	>	PyObject * obj0 = 0 ;
3541	>	PyObject * obj2 = 0 ;
3542	>	PyObject * obj3 = 0 ;
3543	>	PyObject * obj4 = 0 ;
3544	>	PyObject * obj5 = 0 ;
3545	>	PyObject * obj6 = 0 ;
3546	>	PyObject * obj7 = 0 ;
3547	>	PyObject * obj8 = 0 ;
3548	>	PyObject * obj9 = 0 ;
3549	>
3550	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3551	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3552	>	if (obj2) {
3553	>	{
3554	>	if (PyString_Check(obj2)) {
3555	>	temp3 = std::string(PyString_AsString(obj2));
3556	>	arg3 = &temp3;
3557	>	}else {
3558	>	SWIG_exception(SWIG_TypeError, "string expected");
3559	>	}
3560		}
12853	–	}
3561		}
3562	<	}
3563	<	if (argc == 4) {
3564	<	int _v;
3565	<	void *vptr = 0;
3566	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3567	<	_v = SWIG_CheckState(res);
3568	<	if (_v) {
3569	<	{
12863	<	int res = SWIG_AsVal_int(argv[1], NULL);
12864	<	_v = SWIG_CheckState(res);
12865	<	}
12866	<	if (_v) {
12867	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
12868	<	_v = SWIG_CheckState(res);
12869	<	if (_v) {
12870	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
12871	<	_v = SWIG_CheckState(res);
12872	<	if (_v) {
12873	<	return _wrap_BossSession_query__SWIG_6(self, args);
12874	<	}
3562	>	if (obj3) {
3563	>	{
3564	>	if (PyString_Check(obj3)) {
3565	>	temp4 = std::string(PyString_AsString(obj3));
3566	>	arg4 = &temp4;
3567	>	}else {
3568	>	SWIG_exception(SWIG_TypeError, "string expected");
3569	>	}
3570		}
12876	–	}
3571		}
3572	<	}
3573	<	if (argc == 5) {
3574	<	int _v;
3575	<	void *vptr = 0;
3576	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3577	<	_v = SWIG_CheckState(res);
3578	<	if (_v) {
12885	<	{
12886	<	int res = SWIG_AsVal_int(argv[1], NULL);
12887	<	_v = SWIG_CheckState(res);
12888	<	}
12889	<	if (_v) {
12890	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
12891	<	_v = SWIG_CheckState(res);
12892	<	if (_v) {
12893	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
12894	<	_v = SWIG_CheckState(res);
12895	<	if (_v) {
12896	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
12897	<	_v = SWIG_CheckState(res);
12898	<	if (_v) {
12899	<	return _wrap_BossSession_query__SWIG_5(self, args);
3572	>	if (obj4) {
3573	>	{
3574	>	if (PyString_Check(obj4)) {
3575	>	temp5 = std::string(PyString_AsString(obj4));
3576	>	arg5 = &temp5;
3577	>	}else {
3578	>	SWIG_exception(SWIG_TypeError, "string expected");
3579		}
12901	–	}
3580		}
12903	–	}
3581		}
3582	<	}
3583	<	if (argc == 6) {
3584	<	int _v;
3585	<	void *vptr = 0;
3586	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3587	<	_v = SWIG_CheckState(res);
12911	<	if (_v) {
12912	<	{
12913	<	int res = SWIG_AsVal_int(argv[1], NULL);
12914	<	_v = SWIG_CheckState(res);
12915	<	}
12916	<	if (_v) {
12917	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
12918	<	_v = SWIG_CheckState(res);
12919	<	if (_v) {
12920	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
12921	<	_v = SWIG_CheckState(res);
12922	<	if (_v) {
12923	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
12924	<	_v = SWIG_CheckState(res);
12925	<	if (_v) {
12926	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
12927	<	_v = SWIG_CheckState(res);
12928	<	if (_v) {
12929	<	return _wrap_BossSession_query__SWIG_4(self, args);
12930	<	}
12931	<	}
12932	<	}
3582	>	if (obj5) {
3583	>	{
3584	>	if (PyString_Check(obj5))
3585	>	arg6 = std::string(PyString_AsString(obj5));
3586	>	else
3587	>	SWIG_exception(SWIG_TypeError, "string expected");
3588		}
12934	–	}
3589		}
3590	<	}
3591	<	if (argc == 7) {
3592	<	int _v;
3593	<	void *vptr = 0;
3594	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3595	<	_v = SWIG_CheckState(res);
12942	<	if (_v) {
12943	<	{
12944	<	int res = SWIG_AsVal_int(argv[1], NULL);
12945	<	_v = SWIG_CheckState(res);
12946	<	}
12947	<	if (_v) {
12948	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
12949	<	_v = SWIG_CheckState(res);
12950	<	if (_v) {
12951	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
12952	<	_v = SWIG_CheckState(res);
12953	<	if (_v) {
12954	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
12955	<	_v = SWIG_CheckState(res);
12956	<	if (_v) {
12957	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
12958	<	_v = SWIG_CheckState(res);
12959	<	if (_v) {
12960	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
12961	<	_v = SWIG_CheckState(res);
12962	<	if (_v) {
12963	<	return _wrap_BossSession_query__SWIG_3(self, args);
12964	<	}
12965	<	}
12966	<	}
12967	<	}
3590	>	if (obj6) {
3591	>	{
3592	>	if (PyString_Check(obj6))
3593	>	arg7 = std::string(PyString_AsString(obj6));
3594	>	else
3595	>	SWIG_exception(SWIG_TypeError, "string expected");
3596		}
12969	–	}
3597		}
3598	<	}
3599	<	if (argc == 8) {
3600	<	int _v;
3601	<	void *vptr = 0;
3602	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3603	<	_v = SWIG_CheckState(res);
12977	<	if (_v) {
12978	<	{
12979	<	int res = SWIG_AsVal_int(argv[1], NULL);
12980	<	_v = SWIG_CheckState(res);
12981	<	}
12982	<	if (_v) {
12983	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
12984	<	_v = SWIG_CheckState(res);
12985	<	if (_v) {
12986	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
12987	<	_v = SWIG_CheckState(res);
12988	<	if (_v) {
12989	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
12990	<	_v = SWIG_CheckState(res);
12991	<	if (_v) {
12992	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
12993	<	_v = SWIG_CheckState(res);
12994	<	if (_v) {
12995	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
12996	<	_v = SWIG_CheckState(res);
12997	<	if (_v) {
12998	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
12999	<	_v = SWIG_CheckState(res);
13000	<	if (_v) {
13001	<	return _wrap_BossSession_query__SWIG_2(self, args);
13002	<	}
13003	<	}
13004	<	}
13005	<	}
13006	<	}
3598	>	if (obj7) {
3599	>	{
3600	>	if (PyString_Check(obj7))
3601	>	arg8 = std::string(PyString_AsString(obj7));
3602	>	else
3603	>	SWIG_exception(SWIG_TypeError, "string expected");
3604		}
13008	–	}
3605		}
3606	<	}
3607	<	if (argc == 9) {
3608	<	int _v;
3609	<	void *vptr = 0;
3610	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3611	<	_v = SWIG_CheckState(res);
13016	<	if (_v) {
13017	<	{
13018	<	int res = SWIG_AsVal_int(argv[1], NULL);
13019	<	_v = SWIG_CheckState(res);
13020	<	}
13021	<	if (_v) {
13022	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
13023	<	_v = SWIG_CheckState(res);
13024	<	if (_v) {
13025	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
13026	<	_v = SWIG_CheckState(res);
13027	<	if (_v) {
13028	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
13029	<	_v = SWIG_CheckState(res);
13030	<	if (_v) {
13031	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
13032	<	_v = SWIG_CheckState(res);
13033	<	if (_v) {
13034	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
13035	<	_v = SWIG_CheckState(res);
13036	<	if (_v) {
13037	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
13038	<	_v = SWIG_CheckState(res);
13039	<	if (_v) {
13040	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
13041	<	_v = SWIG_CheckState(res);
13042	<	if (_v) {
13043	<	return _wrap_BossSession_query__SWIG_1(self, args);
13044	<	}
13045	<	}
13046	<	}
13047	<	}
13048	<	}
13049	<	}
3606	>	if (obj8) {
3607	>	{
3608	>	if (PyString_Check(obj8))
3609	>	arg9 = std::string(PyString_AsString(obj8));
3610	>	else
3611	>	SWIG_exception(SWIG_TypeError, "string expected");
3612		}
13051	–	}
3613		}
3614	<	}
3615	<	if (argc == 10) {
3616	<	int _v;
3617	<	void *vptr = 0;
3618	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3619	<	_v = SWIG_CheckState(res);
3620	<	if (_v) {
3621	<	{
3622	<	int res = SWIG_AsVal_int(argv[1], NULL);
3623	<	_v = SWIG_CheckState(res);
3624	<	}
3625	<	if (_v) {
3626	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
3627	<	_v = SWIG_CheckState(res);
13067	<	if (_v) {
13068	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
13069	<	_v = SWIG_CheckState(res);
13070	<	if (_v) {
13071	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
13072	<	_v = SWIG_CheckState(res);
13073	<	if (_v) {
13074	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
13075	<	_v = SWIG_CheckState(res);
13076	<	if (_v) {
13077	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
13078	<	_v = SWIG_CheckState(res);
13079	<	if (_v) {
13080	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
13081	<	_v = SWIG_CheckState(res);
13082	<	if (_v) {
13083	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
13084	<	_v = SWIG_CheckState(res);
13085	<	if (_v) {
13086	<	{
13087	<	int res = SWIG_AsVal_bool(argv[9], NULL);
13088	<	_v = SWIG_CheckState(res);
13089	<	}
13090	<	if (_v) {
13091	<	return _wrap_BossSession_query__SWIG_0(self, args);
13092	<	}
13093	<	}
13094	<	}
13095	<	}
13096	<	}
13097	<	}
13098	<	}
3614	>	if (obj9) {
3615	>	arg10 = PyInt_AsLong(obj9) ? true : false;
3616	>	if (PyErr_Occurred()) SWIG_fail;
3617	>	}
3618	>	{
3619	>	try {
3620	>	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3621	>
3622	>	}catch (const BossSchedFailure & e) {
3623	>	PyErr_SetString ( SchedulerError, e.what() );
3624	>	return NULL;
3625	>	}catch (const std::exception& e) {
3626	>	PyErr_SetString ( BossError, e.what() );
3627	>	return NULL;
3628		}
13100	–	}
3629		}
3630	<	}
3631	<
3632	<	fail:
3633	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_query'");
13106	<	return NULL;
3630	>	resultobj = result;
3631	>	return resultobj;
3632	>	fail:
3633	>	return NULL;
3634		}
3635
3636
3637	<	SWIGINTERN PyObject *_wrap_BossSession_show(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3638	<	PyObject *resultobj = 0;
3639	<	BossSession *arg1 = (BossSession *) 0 ;
3640	<	std::vector<std::string,std::allocator<std::string > > *arg2 = 0 ;
3641	<	PyObject *result = 0 ;
3642	<	void *argp1 = 0 ;
3643	<	int res1 = 0 ;
3644	<	void *argp2 = 0 ;
3645	<	int res2 = 0 ;
3646	<	PyObject * obj0 = 0 ;
3647	<	PyObject * obj1 = 0 ;
3648	<
3649	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) SWIG_fail;
3650	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3651	<	if (!SWIG_IsOK(res1)) {
3652	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_show" "', argument " "1"" of type '" "BossSession *""'");
3653	<	}
3654	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3655	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t,  0 );
3656	<	if (!SWIG_IsOK(res2)) {
3657	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_show" "', argument " "2"" of type '" "std::vector<std::string,std::allocator<std::string > > &""'");
3658	<	}
13132	<	if (!argp2) {
13133	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_show" "', argument " "2"" of type '" "std::vector<std::string,std::allocator<std::string > > &""'");
13134	<	}
13135	<	arg2 = reinterpret_cast< std::vector<std::string,std::allocator<std::string > > * >(argp2);
13136	<	{
13137	<	try {
13138	<	result = (PyObject *)BossSession_show(arg1,*arg2);
13139	<	} catch (const std::exception& e) {
13140	<	SWIG_exception(SWIG_RuntimeError, e.what());
3637	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3638	>	PyObject *obj;
3639	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3640	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3641	>	Py_INCREF(obj);
3642	>	return Py_BuildValue((char *)"");
3643	>	}
3644	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3645	>	PyObject *resultobj;
3646	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3647	>	char *arg2 ;
3648	>	PyObject * obj0 = 0 ;
3649	>
3650	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3651	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3652	>	{
3653	>	if (arg2) {
3654	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3655	>	strcpy((char *) arg1->key,arg2);
3656	>	}else {
3657	>	arg1->key = 0;
3658	>	}
3659		}
3660	<	}
3661	<	resultobj = result;
3662	<	return resultobj;
3663	<	fail:
13146	<	return NULL;
3660	>	Py_INCREF(Py_None); resultobj = Py_None;
3661	>	return resultobj;
3662	>	fail:
3663	>	return NULL;
3664		}
3665
3666
3667	<	SWIGINTERN PyObject *_wrap_BossSession_CHTools(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3668	<	PyObject *resultobj = 0;
3669	<	BossSession *arg1 = (BossSession *) 0 ;
3670	<	PyObject *result = 0 ;
3671	<	void *argp1 = 0 ;
3672	<	int res1 = 0 ;
3673	<	PyObject * obj0 = 0 ;
3674	<
3675	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) SWIG_fail;
3676	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3677	<	if (!SWIG_IsOK(res1)) {
3678	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_CHTools" "', argument " "1"" of type '" "BossSession *""'");
3679	<	}
3680	<	arg1 = reinterpret_cast< BossSession * >(argp1);
13164	<	{
13165	<	try {
13166	<	result = (PyObject *)BossSession_CHTools(arg1);
13167	<	} catch (const std::exception& e) {
13168	<	SWIG_exception(SWIG_RuntimeError, e.what());
13169	<	}
13170	<	}
13171	<	resultobj = result;
13172	<	return resultobj;
13173	<	fail:
13174	<	return NULL;
3667	>	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3668	>	PyObject *resultobj;
3669	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3670	>	char *result;
3671	>	PyObject * obj0 = 0 ;
3672	>
3673	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3674	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3675	>	result = (char *) ((arg1)->key);
3676	>
3677	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3678	>	return resultobj;
3679	>	fail:
3680	>	return NULL;
3681		}
3682
3683
3684	<	SWIGINTERN PyObject *_wrap_BossSession_ProgramTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3685	<	PyObject *resultobj = 0;
3686	<	BossSession *arg1 = (BossSession *) 0 ;
3687	<	PyObject *result = 0 ;
3688	<	void *argp1 = 0 ;
3689	<	int res1 = 0 ;
3690	<	PyObject * obj0 = 0 ;
3691	<
3692	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) SWIG_fail;
3693	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3694	<	if (!SWIG_IsOK(res1)) {
3695	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_ProgramTypes" "', argument " "1"" of type '" "BossSession *""'");
3696	<	}
3697	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3698	<	{
3699	<	try {
3700	<	result = (PyObject *)BossSession_ProgramTypes(arg1);
13195	<	} catch (const std::exception& e) {
13196	<	SWIG_exception(SWIG_RuntimeError, e.what());
3684	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3685	>	PyObject *resultobj;
3686	>	char *arg1 ;
3687	>	BossTaskException *result;
3688	>
3689	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3690	>	{
3691	>	try {
3692	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3693	>
3694	>	}catch (const BossSchedFailure & e) {
3695	>	PyErr_SetString ( SchedulerError, e.what() );
3696	>	return NULL;
3697	>	}catch (const std::exception& e) {
3698	>	PyErr_SetString ( BossError, e.what() );
3699	>	return NULL;
3700	>	}
3701		}
3702	<	}
3703	<	resultobj = result;
3704	<	return resultobj;
3705	<	fail:
13202	<	return NULL;
3702	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3703	>	return resultobj;
3704	>	fail:
3705	>	return NULL;
3706		}
3707
3708
3709	<	SWIGINTERN PyObject *_wrap_BossSession_RTMons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3710	<	PyObject *resultobj = 0;
3711	<	BossSession *arg1 = (BossSession *) 0 ;
3712	<	PyObject *result = 0 ;
3713	<	void *argp1 = 0 ;
3714	<	int res1 = 0 ;
3715	<	PyObject * obj0 = 0 ;
3716	<
3717	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) SWIG_fail;
3718	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3719	<	if (!SWIG_IsOK(res1)) {
3720	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTMons" "', argument " "1"" of type '" "BossSession *""'");
3721	<	}
3722	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3723	<	{
3724	<	try {
3725	<	result = (PyObject *)BossSession_RTMons(arg1);
3726	<	} catch (const std::exception& e) {
3727	<	SWIG_exception(SWIG_RuntimeError, e.what());
3709	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3710	>	PyObject *resultobj;
3711	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3712	>	char *result;
3713	>	PyObject * obj0 = 0 ;
3714	>
3715	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3716	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3717	>	{
3718	>	try {
3719	>	result = (char *)((BossTaskException const *)arg1)->what();
3720	>
3721	>	}catch (const BossSchedFailure & e) {
3722	>	PyErr_SetString ( SchedulerError, e.what() );
3723	>	return NULL;
3724	>	}catch (const std::exception& e) {
3725	>	PyErr_SetString ( BossError, e.what() );
3726	>	return NULL;
3727	>	}
3728		}
3729	<	}
3730	<	resultobj = result;
3731	<	return resultobj;
3732	<	fail:
13230	<	return NULL;
3729	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3730	>	return resultobj;
3731	>	fail:
3732	>	return NULL;
3733		}
3734
3735
3736	<	SWIGINTERN PyObject *_wrap_BossSession_schedulers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3737	<	PyObject *resultobj = 0;
3738	<	BossSession *arg1 = (BossSession *) 0 ;
3739	<	PyObject *result = 0 ;
3740	<	void *argp1 = 0 ;
3741	<	int res1 = 0 ;
3742	<	PyObject * obj0 = 0 ;
3743	<
3744	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) SWIG_fail;
3745	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3746	<	if (!SWIG_IsOK(res1)) {
3747	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulers" "', argument " "1"" of type '" "BossSession *""'");
3748	<	}
3749	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3750	<	{
3751	<	try {
3752	<	result = (PyObject *)BossSession_schedulers(arg1);
3753	<	} catch (const std::exception& e) {
13252	<	SWIG_exception(SWIG_RuntimeError, e.what());
3736	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3737	>	PyObject *resultobj;
3738	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3739	>	PyObject * obj0 = 0 ;
3740	>
3741	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3742	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3743	>	{
3744	>	try {
3745	>	delete arg1;
3746	>
3747	>	}catch (const BossSchedFailure & e) {
3748	>	PyErr_SetString ( SchedulerError, e.what() );
3749	>	return NULL;
3750	>	}catch (const std::exception& e) {
3751	>	PyErr_SetString ( BossError, e.what() );
3752	>	return NULL;
3753	>	}
3754		}
3755	<	}
3756	<	resultobj = result;
3757	<	return resultobj;
3758	<	fail:
13258	<	return NULL;
3755	>	Py_INCREF(Py_None); resultobj = Py_None;
3756	>	return resultobj;
3757	>	fail:
3758	>	return NULL;
3759		}
3760
3761
3762	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3763	<	PyObject *resultobj = 0;
3764	<	BossSession *arg1 = (BossSession *) 0 ;
3765	<	std::string *arg2 = 0 ;
3766	<	std::string *arg3 = 0 ;
3767	<	std::string *arg4 = 0 ;
3768	<	std::string *arg5 = 0 ;
3769	<	bool arg6 ;
3770	<	PyObject *result = 0 ;
3771	<	void *argp1 = 0 ;
3772	<	int res1 = 0 ;
3773	<	int res2 = SWIG_OLDOBJ ;
3774	<	int res3 = SWIG_OLDOBJ ;
3775	<	int res4 = SWIG_OLDOBJ ;
3776	<	int res5 = SWIG_OLDOBJ ;
3777	<	bool val6 ;
3778	<	int ecode6 = 0 ;
3779	<	PyObject * obj0 = 0 ;
3780	<	PyObject * obj1 = 0 ;
3781	<	PyObject * obj2 = 0 ;
3782	<	PyObject * obj3 = 0 ;
3783	<	PyObject * obj4 = 0 ;
3784	<	PyObject * obj5 = 0 ;
3785	<
3786	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
3787	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13288	<	if (!SWIG_IsOK(res1)) {
13289	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedListMatch" "', argument " "1"" of type '" "BossSession *""'");
13290	<	}
13291	<	arg1 = reinterpret_cast< BossSession * >(argp1);
13292	<	{
13293	<	std::string *ptr = (std::string *)0;
13294	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
13295	<	if (!SWIG_IsOK(res2)) {
13296	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13297	<	}
13298	<	if (!ptr) {
13299	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13300	<	}
13301	<	arg2 = ptr;
13302	<	}
13303	<	{
13304	<	std::string *ptr = (std::string *)0;
13305	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
13306	<	if (!SWIG_IsOK(res3)) {
13307	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13308	<	}
13309	<	if (!ptr) {
13310	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13311	<	}
13312	<	arg3 = ptr;
13313	<	}
13314	<	{
13315	<	std::string *ptr = (std::string *)0;
13316	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
13317	<	if (!SWIG_IsOK(res4)) {
13318	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedListMatch" "', argument " "4"" of type '" "std::string const &""'");
13319	<	}
13320	<	if (!ptr) {
13321	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "4"" of type '" "std::string const &""'");
13322	<	}
13323	<	arg4 = ptr;
13324	<	}
13325	<	{
13326	<	std::string *ptr = (std::string *)0;
13327	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
13328	<	if (!SWIG_IsOK(res5)) {
13329	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedListMatch" "', argument " "5"" of type '" "std::string const &""'");
13330	<	}
13331	<	if (!ptr) {
13332	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "5"" of type '" "std::string const &""'");
13333	<	}
13334	<	arg5 = ptr;
13335	<	}
13336	<	ecode6 = SWIG_AsVal_bool(obj5, &val6);
13337	<	if (!SWIG_IsOK(ecode6)) {
13338	<	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BossSession_schedListMatch" "', argument " "6"" of type '" "bool""'");
13339	<	}
13340	<	arg6 = static_cast< bool >(val6);
13341	<	{
13342	<	try {
13343	<	result = (PyObject *)BossSession_schedListMatch__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
13344	<	} catch (const std::exception& e) {
13345	<	SWIG_exception(SWIG_RuntimeError, e.what());
3762	>	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3763	>	PyObject *obj;
3764	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3765	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3766	>	Py_INCREF(obj);
3767	>	return Py_BuildValue((char *)"");
3768	>	}
3769	>	static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3770	>	PyObject *resultobj;
3771	>	BossDatabase *arg1 = (BossDatabase *) 0 ;
3772	>	BossTask *result;
3773	>	PyObject * obj0 = 0 ;
3774	>
3775	>	if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
3776	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3777	>	{
3778	>	try {
3779	>	result = (BossTask *)new BossTask(arg1);
3780	>
3781	>	}catch (const BossSchedFailure & e) {
3782	>	PyErr_SetString ( SchedulerError, e.what() );
3783	>	return NULL;
3784	>	}catch (const std::exception& e) {
3785	>	PyErr_SetString ( BossError, e.what() );
3786	>	return NULL;
3787	>	}
3788		}
3789	<	}
3790	<	resultobj = result;
3791	<	if (SWIG_IsNewObj(res2)) delete arg2;
3792	<	if (SWIG_IsNewObj(res3)) delete arg3;
13351	<	if (SWIG_IsNewObj(res4)) delete arg4;
13352	<	if (SWIG_IsNewObj(res5)) delete arg5;
13353	<	return resultobj;
13354	<	fail:
13355	<	if (SWIG_IsNewObj(res2)) delete arg2;
13356	<	if (SWIG_IsNewObj(res3)) delete arg3;
13357	<	if (SWIG_IsNewObj(res4)) delete arg4;
13358	<	if (SWIG_IsNewObj(res5)) delete arg5;
13359	<	return NULL;
3789	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3790	>	return resultobj;
3791	>	fail:
3792	>	return NULL;
3793		}
3794
3795
3796	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3797	<	PyObject *resultobj = 0;
3798	<	BossSession *arg1 = (BossSession *) 0 ;
3799	<	std::string *arg2 = 0 ;
3800	<	std::string *arg3 = 0 ;
3801	<	std::string *arg4 = 0 ;
3802	<	std::string *arg5 = 0 ;
3803	<	PyObject *result = 0 ;
3804	<	void *argp1 = 0 ;
3805	<	int res1 = 0 ;
3806	<	int res2 = SWIG_OLDOBJ ;
3807	<	int res3 = SWIG_OLDOBJ ;
3808	<	int res4 = SWIG_OLDOBJ ;
3809	<	int res5 = SWIG_OLDOBJ ;
3810	<	PyObject * obj0 = 0 ;
3811	<	PyObject * obj1 = 0 ;
3812	<	PyObject * obj2 = 0 ;
3813	<	PyObject * obj3 = 0 ;
13381	<	PyObject * obj4 = 0 ;
13382	<
13383	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13384	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13385	<	if (!SWIG_IsOK(res1)) {
13386	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedListMatch" "', argument " "1"" of type '" "BossSession *""'");
13387	<	}
13388	<	arg1 = reinterpret_cast< BossSession * >(argp1);
13389	<	{
13390	<	std::string *ptr = (std::string *)0;
13391	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
13392	<	if (!SWIG_IsOK(res2)) {
13393	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13394	<	}
13395	<	if (!ptr) {
13396	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13397	<	}
13398	<	arg2 = ptr;
13399	<	}
13400	<	{
13401	<	std::string *ptr = (std::string *)0;
13402	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
13403	<	if (!SWIG_IsOK(res3)) {
13404	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13405	<	}
13406	<	if (!ptr) {
13407	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13408	<	}
13409	<	arg3 = ptr;
13410	<	}
13411	<	{
13412	<	std::string *ptr = (std::string *)0;
13413	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
13414	<	if (!SWIG_IsOK(res4)) {
13415	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedListMatch" "', argument " "4"" of type '" "std::string const &""'");
13416	<	}
13417	<	if (!ptr) {
13418	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "4"" of type '" "std::string const &""'");
13419	<	}
13420	<	arg4 = ptr;
13421	<	}
13422	<	{
13423	<	std::string *ptr = (std::string *)0;
13424	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
13425	<	if (!SWIG_IsOK(res5)) {
13426	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedListMatch" "', argument " "5"" of type '" "std::string const &""'");
13427	<	}
13428	<	if (!ptr) {
13429	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "5"" of type '" "std::string const &""'");
3796	>	static PyObject *_wrap_new_BossTask__SWIG_1(PyObject *self, PyObject *args) {
3797	>	PyObject *resultobj;
3798	>	BossDatabase *arg1 = (BossDatabase *) 0 ;
3799	>	std::string *arg2 = 0 ;
3800	>	BossTask *result;
3801	>	std::string temp2 ;
3802	>	PyObject * obj0 = 0 ;
3803	>	PyObject * obj1 = 0 ;
3804	>
3805	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_BossTask",&obj0,&obj1)) goto fail;
3806	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3807	>	{
3808	>	if (PyString_Check(obj1)) {
3809	>	temp2 = std::string(PyString_AsString(obj1));
3810	>	arg2 = &temp2;
3811	>	}else {
3812	>	SWIG_exception(SWIG_TypeError, "string expected");
3813	>	}
3814		}
3815	<	arg5 = ptr;
3816	<	}
3817	<	{
3818	<	try {
3819	<	result = (PyObject *)BossSession_schedListMatch__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3820	<	} catch (const std::exception& e) {
3821	<	SWIG_exception(SWIG_RuntimeError, e.what());
3815	>	{
3816	>	try {
3817	>	result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3818	>
3819	>	}catch (const BossSchedFailure & e) {
3820	>	PyErr_SetString ( SchedulerError, e.what() );
3821	>	return NULL;
3822	>	}catch (const std::exception& e) {
3823	>	PyErr_SetString ( BossError, e.what() );
3824	>	return NULL;
3825	>	}
3826		}
3827	<	}
3828	<	resultobj = result;
3829	<	if (SWIG_IsNewObj(res2)) delete arg2;
3830	<	if (SWIG_IsNewObj(res3)) delete arg3;
13443	<	if (SWIG_IsNewObj(res4)) delete arg4;
13444	<	if (SWIG_IsNewObj(res5)) delete arg5;
13445	<	return resultobj;
13446	<	fail:
13447	<	if (SWIG_IsNewObj(res2)) delete arg2;
13448	<	if (SWIG_IsNewObj(res3)) delete arg3;
13449	<	if (SWIG_IsNewObj(res4)) delete arg4;
13450	<	if (SWIG_IsNewObj(res5)) delete arg5;
13451	<	return NULL;
3827	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3828	>	return resultobj;
3829	>	fail:
3830	>	return NULL;
3831		}
3832
3833
3834	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3835	<	PyObject *resultobj = 0;
3836	<	BossSession *arg1 = (BossSession *) 0 ;
3837	<	std::string *arg2 = 0 ;
3838	<	std::string *arg3 = 0 ;
3839	<	std::string *arg4 = 0 ;
3840	<	PyObject *result = 0 ;
3841	<	void *argp1 = 0 ;
3842	<	int res1 = 0 ;
3843	<	int res2 = SWIG_OLDOBJ ;
3844	<	int res3 = SWIG_OLDOBJ ;
3845	<	int res4 = SWIG_OLDOBJ ;
3846	<	PyObject * obj0 = 0 ;
3847	<	PyObject * obj1 = 0 ;
3848	<	PyObject * obj2 = 0 ;
3849	<	PyObject * obj3 = 0 ;
3850	<
3851	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13473	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13474	<	if (!SWIG_IsOK(res1)) {
13475	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedListMatch" "', argument " "1"" of type '" "BossSession *""'");
13476	<	}
13477	<	arg1 = reinterpret_cast< BossSession * >(argp1);
13478	<	{
13479	<	std::string *ptr = (std::string *)0;
13480	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
13481	<	if (!SWIG_IsOK(res2)) {
13482	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13483	<	}
13484	<	if (!ptr) {
13485	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13486	<	}
13487	<	arg2 = ptr;
13488	<	}
13489	<	{
13490	<	std::string *ptr = (std::string *)0;
13491	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
13492	<	if (!SWIG_IsOK(res3)) {
13493	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13494	<	}
13495	<	if (!ptr) {
13496	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13497	<	}
13498	<	arg3 = ptr;
13499	<	}
13500	<	{
13501	<	std::string *ptr = (std::string *)0;
13502	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
13503	<	if (!SWIG_IsOK(res4)) {
13504	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedListMatch" "', argument " "4"" of type '" "std::string const &""'");
13505	<	}
13506	<	if (!ptr) {
13507	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "4"" of type '" "std::string const &""'");
13508	<	}
13509	<	arg4 = ptr;
13510	<	}
13511	<	{
13512	<	try {
13513	<	result = (PyObject *)BossSession_schedListMatch__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
13514	<	} catch (const std::exception& e) {
13515	<	SWIG_exception(SWIG_RuntimeError, e.what());
3834	>	static PyObject *_wrap_delete_BossTask(PyObject *self, PyObject *args) {
3835	>	PyObject *resultobj;
3836	>	BossTask *arg1 = (BossTask *) 0 ;
3837	>	PyObject * obj0 = 0 ;
3838	>
3839	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTask",&obj0)) goto fail;
3840	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3841	>	{
3842	>	try {
3843	>	delete arg1;
3844	>
3845	>	}catch (const BossSchedFailure & e) {
3846	>	PyErr_SetString ( SchedulerError, e.what() );
3847	>	return NULL;
3848	>	}catch (const std::exception& e) {
3849	>	PyErr_SetString ( BossError, e.what() );
3850	>	return NULL;
3851	>	}
3852		}
3853	<	}
3854	<	resultobj = result;
3855	<	if (SWIG_IsNewObj(res2)) delete arg2;
3856	<	if (SWIG_IsNewObj(res3)) delete arg3;
13521	<	if (SWIG_IsNewObj(res4)) delete arg4;
13522	<	return resultobj;
13523	<	fail:
13524	<	if (SWIG_IsNewObj(res2)) delete arg2;
13525	<	if (SWIG_IsNewObj(res3)) delete arg3;
13526	<	if (SWIG_IsNewObj(res4)) delete arg4;
13527	<	return NULL;
3853	>	Py_INCREF(Py_None); resultobj = Py_None;
3854	>	return resultobj;
3855	>	fail:
3856	>	return NULL;
3857		}
3858
3859
3860	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3861	<	PyObject *resultobj = 0;
3862	<	BossSession *arg1 = (BossSession *) 0 ;
3863	<	std::string *arg2 = 0 ;
3864	<	std::string *arg3 = 0 ;
3865	<	PyObject *result = 0 ;
3866	<	void *argp1 = 0 ;
3867	<	int res1 = 0 ;
3868	<	int res2 = SWIG_OLDOBJ ;
3869	<	int res3 = SWIG_OLDOBJ ;
13541	<	PyObject * obj0 = 0 ;
13542	<	PyObject * obj1 = 0 ;
13543	<	PyObject * obj2 = 0 ;
13544	<
13545	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2)) SWIG_fail;
13546	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13547	<	if (!SWIG_IsOK(res1)) {
13548	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedListMatch" "', argument " "1"" of type '" "BossSession *""'");
13549	<	}
13550	<	arg1 = reinterpret_cast< BossSession * >(argp1);
13551	<	{
13552	<	std::string *ptr = (std::string *)0;
13553	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
13554	<	if (!SWIG_IsOK(res2)) {
13555	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13556	<	}
13557	<	if (!ptr) {
13558	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13559	<	}
13560	<	arg2 = ptr;
13561	<	}
13562	<	{
13563	<	std::string *ptr = (std::string *)0;
13564	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
13565	<	if (!SWIG_IsOK(res3)) {
13566	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13567	<	}
13568	<	if (!ptr) {
13569	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
3860	>	static PyObject *_wrap_new_BossTask__SWIG_2(PyObject *self, PyObject *args) {
3861	>	PyObject *resultobj;
3862	>	BossTask *arg1 = 0 ;
3863	>	BossTask *result;
3864	>	PyObject * obj0 = 0 ;
3865	>
3866	>	if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
3867	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3868	>	if (arg1 == NULL) {
3869	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3870		}
3871	<	arg3 = ptr;
3872	<	}
3873	<	{
3874	<	try {
3875	<	result = (PyObject *)BossSession_schedListMatch__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
3876	<	} catch (const std::exception& e) {
3877	<	SWIG_exception(SWIG_RuntimeError, e.what());
3871	>	{
3872	>	try {
3873	>	result = (BossTask *)new BossTask((BossTask const &)*arg1);
3874	>
3875	>	}catch (const BossSchedFailure & e) {
3876	>	PyErr_SetString ( SchedulerError, e.what() );
3877	>	return NULL;
3878	>	}catch (const std::exception& e) {
3879	>	PyErr_SetString ( BossError, e.what() );
3880	>	return NULL;
3881	>	}
3882		}
3883	<	}
3884	<	resultobj = result;
3885	<	if (SWIG_IsNewObj(res2)) delete arg2;
3886	<	if (SWIG_IsNewObj(res3)) delete arg3;
13583	<	return resultobj;
13584	<	fail:
13585	<	if (SWIG_IsNewObj(res2)) delete arg2;
13586	<	if (SWIG_IsNewObj(res3)) delete arg3;
13587	<	return NULL;
3883	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3884	>	return resultobj;
3885	>	fail:
3886	>	return NULL;
3887		}
3888
3889
3890	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3891	<	int argc;
3892	<	PyObject *argv[7];
3893	<	int ii;
3894	<
3895	<	if (!PyTuple_Check(args)) SWIG_fail;
3896	<	argc = PyObject_Length(args);
3897	<	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
3898	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3899	<	}
3900	<	if (argc == 3) {
3901	<	int _v;
3902	<	void *vptr = 0;
3903	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3904	<	_v = SWIG_CheckState(res);
3905	<	if (_v) {
3906	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3907	<	_v = SWIG_CheckState(res);
3908	<	if (_v) {
3909	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
13611	<	_v = SWIG_CheckState(res);
3890	>	static PyObject *_wrap_new_BossTask(PyObject *self, PyObject *args) {
3891	>	int argc;
3892	>	PyObject *argv[3];
3893	>	int ii;
3894	>
3895	>	argc = PyObject_Length(args);
3896	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3897	>	argv[ii] = PyTuple_GetItem(args,ii);
3898	>	}
3899	>	if (argc == 1) {
3900	>	int _v;
3901	>	{
3902	>	void *ptr;
3903	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
3904	>	_v = 0;
3905	>	PyErr_Clear();
3906	>	}else {
3907	>	_v = 1;
3908	>	}
3909	>	}
3910		if (_v) {
3911	<	return _wrap_BossSession_schedListMatch__SWIG_3(self, args);
3911	>	return _wrap_new_BossTask__SWIG_0(self,args);
3912		}
13615	–	}
3913		}
3914	<	}
3915	<	if (argc == 4) {
3916	<	int _v;
3917	<	void *vptr = 0;
3918	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3919	<	_v = SWIG_CheckState(res);
3920	<	if (_v) {
3921	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3922	<	_v = SWIG_CheckState(res);
3923	<	if (_v) {
3924	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
13628	<	_v = SWIG_CheckState(res);
3914	>	if (argc == 1) {
3915	>	int _v;
3916	>	{
3917	>	void *ptr;
3918	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3919	>	_v = 0;
3920	>	PyErr_Clear();
3921	>	}else {
3922	>	_v = 1;
3923	>	}
3924	>	}
3925		if (_v) {
3926	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
13631	<	_v = SWIG_CheckState(res);
13632	<	if (_v) {
13633	<	return _wrap_BossSession_schedListMatch__SWIG_2(self, args);
13634	<	}
3926	>	return _wrap_new_BossTask__SWIG_2(self,args);
3927		}
13636	–	}
3928		}
3929	<	}
3930	<	if (argc == 5) {
3931	<	int _v;
3932	<	void *vptr = 0;
3933	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3934	<	_v = SWIG_CheckState(res);
3935	<	if (_v) {
3936	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3937	<	_v = SWIG_CheckState(res);
13647	<	if (_v) {
13648	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
13649	<	_v = SWIG_CheckState(res);
13650	<	if (_v) {
13651	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
13652	<	_v = SWIG_CheckState(res);
13653	<	if (_v) {
13654	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
13655	<	_v = SWIG_CheckState(res);
13656	<	if (_v) {
13657	<	return _wrap_BossSession_schedListMatch__SWIG_1(self, args);
3929	>	if (argc == 2) {
3930	>	int _v;
3931	>	{
3932	>	void *ptr;
3933	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
3934	>	_v = 0;
3935	>	PyErr_Clear();
3936	>	}else {
3937	>	_v = 1;
3938		}
13659	–	}
3939		}
13661	–	}
13662	–	}
13663	–	}
13664	–	if (argc == 6) {
13665	–	int _v;
13666	–	void *vptr = 0;
13667	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
13668	–	_v = SWIG_CheckState(res);
13669	–	if (_v) {
13670	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
13671	–	_v = SWIG_CheckState(res);
13672	–	if (_v) {
13673	–	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
13674	–	_v = SWIG_CheckState(res);
3940		if (_v) {
3941	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
3942	<	_v = SWIG_CheckState(res);
3943	<	if (_v) {
13679	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
13680	<	_v = SWIG_CheckState(res);
3941	>	{
3942	>	_v = PyString_Check(argv[1]) ? 1 : 0;
3943	>	}
3944		if (_v) {
3945	<	{
13683	<	int res = SWIG_AsVal_bool(argv[5], NULL);
13684	<	_v = SWIG_CheckState(res);
13685	<	}
13686	<	if (_v) {
13687	<	return _wrap_BossSession_schedListMatch__SWIG_0(self, args);
13688	<	}
3945	>	return _wrap_new_BossTask__SWIG_1(self,args);
3946		}
13690	–	}
3947		}
13692	–	}
13693	–	}
13694	–	}
13695	–
13696	–	fail:
13697	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_schedListMatch'");
13698	–	return NULL;
13699	–	}
13700	–
13701	–
13702	–	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13703	–	PyObject *resultobj = 0;
13704	–	BossSession *arg1 = (BossSession *) 0 ;
13705	–	int arg2 ;
13706	–	std::string *arg3 = 0 ;
13707	–	std::string *arg4 = 0 ;
13708	–	std::string *arg5 = 0 ;
13709	–	std::string arg6 ;
13710	–	std::string arg7 ;
13711	–	std::string arg8 ;
13712	–	std::string arg9 ;
13713	–	bool arg10 ;
13714	–	PyObject *result = 0 ;
13715	–	void *argp1 = 0 ;
13716	–	int res1 = 0 ;
13717	–	int val2 ;
13718	–	int ecode2 = 0 ;
13719	–	int res3 = SWIG_OLDOBJ ;
13720	–	int res4 = SWIG_OLDOBJ ;
13721	–	int res5 = SWIG_OLDOBJ ;
13722	–	bool val10 ;
13723	–	int ecode10 = 0 ;
13724	–	PyObject * obj0 = 0 ;
13725	–	PyObject * obj1 = 0 ;
13726	–	PyObject * obj2 = 0 ;
13727	–	PyObject * obj3 = 0 ;
13728	–	PyObject * obj4 = 0 ;
13729	–	PyObject * obj5 = 0 ;
13730	–	PyObject * obj6 = 0 ;
13731	–	PyObject * obj7 = 0 ;
13732	–	PyObject * obj8 = 0 ;
13733	–	PyObject * obj9 = 0 ;
13734	–
13735	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
13736	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13737	–	if (!SWIG_IsOK(res1)) {
13738	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
13739	–	}
13740	–	arg1 = reinterpret_cast< BossSession * >(argp1);
13741	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
13742	–	if (!SWIG_IsOK(ecode2)) {
13743	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
13744	–	}
13745	–	arg2 = static_cast< int >(val2);
13746	–	{
13747	–	std::string *ptr = (std::string *)0;
13748	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
13749	–	if (!SWIG_IsOK(res3)) {
13750	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
13751	–	}
13752	–	if (!ptr) {
13753	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
13754	–	}
13755	–	arg3 = ptr;
13756	–	}
13757	–	{
13758	–	std::string *ptr = (std::string *)0;
13759	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
13760	–	if (!SWIG_IsOK(res4)) {
13761	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
3948		}
3949	<	if (!ptr) {
3950	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
3951	<	}
13766	<	arg4 = ptr;
13767	<	}
13768	<	{
13769	<	std::string *ptr = (std::string *)0;
13770	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
13771	<	if (!SWIG_IsOK(res5)) {
13772	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
13773	<	}
13774	<	if (!ptr) {
13775	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
13776	<	}
13777	<	arg5 = ptr;
13778	<	}
13779	<	{
13780	<	std::string *ptr = (std::string *)0;
13781	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
13782	<	if (!SWIG_IsOK(res) || !ptr) {
13783	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "6"" of type '" "std::string""'");
13784	<	}
13785	<	arg6 = *ptr;
13786	<	if (SWIG_IsNewObj(res)) delete ptr;
13787	<	}
13788	<	{
13789	<	std::string *ptr = (std::string *)0;
13790	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
13791	<	if (!SWIG_IsOK(res) || !ptr) {
13792	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "7"" of type '" "std::string""'");
13793	<	}
13794	<	arg7 = *ptr;
13795	<	if (SWIG_IsNewObj(res)) delete ptr;
13796	<	}
13797	<	{
13798	<	std::string *ptr = (std::string *)0;
13799	<	int res = SWIG_AsPtr_std_string(obj7, &ptr);
13800	<	if (!SWIG_IsOK(res) || !ptr) {
13801	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "8"" of type '" "std::string""'");
13802	<	}
13803	<	arg8 = *ptr;
13804	<	if (SWIG_IsNewObj(res)) delete ptr;
13805	<	}
13806	<	{
13807	<	std::string *ptr = (std::string *)0;
13808	<	int res = SWIG_AsPtr_std_string(obj8, &ptr);
13809	<	if (!SWIG_IsOK(res) || !ptr) {
13810	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "9"" of type '" "std::string""'");
13811	<	}
13812	<	arg9 = *ptr;
13813	<	if (SWIG_IsNewObj(res)) delete ptr;
13814	<	}
13815	<	ecode10 = SWIG_AsVal_bool(obj9, &val10);
13816	<	if (!SWIG_IsOK(ecode10)) {
13817	<	SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "BossSession_queryTasks" "', argument " "10"" of type '" "bool""'");
13818	<	}
13819	<	arg10 = static_cast< bool >(val10);
13820	<	{
13821	<	try {
13822	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
13823	<	} catch (const std::exception& e) {
13824	<	SWIG_exception(SWIG_RuntimeError, e.what());
13825	<	}
13826	<	}
13827	<	resultobj = result;
13828	<	if (SWIG_IsNewObj(res3)) delete arg3;
13829	<	if (SWIG_IsNewObj(res4)) delete arg4;
13830	<	if (SWIG_IsNewObj(res5)) delete arg5;
13831	<	return resultobj;
13832	<	fail:
13833	<	if (SWIG_IsNewObj(res3)) delete arg3;
13834	<	if (SWIG_IsNewObj(res4)) delete arg4;
13835	<	if (SWIG_IsNewObj(res5)) delete arg5;
13836	<	return NULL;
3949	>
3950	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_BossTask'");
3951	>	return NULL;
3952		}
3953
3954
3955	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3956	<	PyObject *resultobj = 0;
3957	<	BossSession *arg1 = (BossSession *) 0 ;
3958	<	int arg2 ;
3959	<	std::string *arg3 = 0 ;
3960	<	std::string *arg4 = 0 ;
3961	<	std::string *arg5 = 0 ;
3962	<	std::string arg6 ;
3963	<	std::string arg7 ;
3964	<	std::string arg8 ;
3965	<	std::string arg9 ;
3966	<	PyObject *result = 0 ;
3967	<	void *argp1 = 0 ;
3968	<	int res1 = 0 ;
3969	<	int val2 ;
3970	<	int ecode2 = 0 ;
3971	<	int res3 = SWIG_OLDOBJ ;
3972	<	int res4 = SWIG_OLDOBJ ;
3973	<	int res5 = SWIG_OLDOBJ ;
3974	<	PyObject * obj0 = 0 ;
3975	<	PyObject * obj1 = 0 ;
3976	<	PyObject * obj2 = 0 ;
13862	<	PyObject * obj3 = 0 ;
13863	<	PyObject * obj4 = 0 ;
13864	<	PyObject * obj5 = 0 ;
13865	<	PyObject * obj6 = 0 ;
13866	<	PyObject * obj7 = 0 ;
13867	<	PyObject * obj8 = 0 ;
13868	<
13869	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
13870	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13871	<	if (!SWIG_IsOK(res1)) {
13872	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
13873	<	}
13874	<	arg1 = reinterpret_cast< BossSession * >(argp1);
13875	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
13876	<	if (!SWIG_IsOK(ecode2)) {
13877	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
13878	<	}
13879	<	arg2 = static_cast< int >(val2);
13880	<	{
13881	<	std::string *ptr = (std::string *)0;
13882	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
13883	<	if (!SWIG_IsOK(res3)) {
13884	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
13885	<	}
13886	<	if (!ptr) {
13887	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
13888	<	}
13889	<	arg3 = ptr;
13890	<	}
13891	<	{
13892	<	std::string *ptr = (std::string *)0;
13893	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
13894	<	if (!SWIG_IsOK(res4)) {
13895	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
13896	<	}
13897	<	if (!ptr) {
13898	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
13899	<	}
13900	<	arg4 = ptr;
13901	<	}
13902	<	{
13903	<	std::string *ptr = (std::string *)0;
13904	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
13905	<	if (!SWIG_IsOK(res5)) {
13906	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
13907	<	}
13908	<	if (!ptr) {
13909	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
13910	<	}
13911	<	arg5 = ptr;
13912	<	}
13913	<	{
13914	<	std::string *ptr = (std::string *)0;
13915	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
13916	<	if (!SWIG_IsOK(res) || !ptr) {
13917	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "6"" of type '" "std::string""'");
13918	<	}
13919	<	arg6 = *ptr;
13920	<	if (SWIG_IsNewObj(res)) delete ptr;
13921	<	}
13922	<	{
13923	<	std::string *ptr = (std::string *)0;
13924	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
13925	<	if (!SWIG_IsOK(res) || !ptr) {
13926	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "7"" of type '" "std::string""'");
13927	<	}
13928	<	arg7 = *ptr;
13929	<	if (SWIG_IsNewObj(res)) delete ptr;
13930	<	}
13931	<	{
13932	<	std::string *ptr = (std::string *)0;
13933	<	int res = SWIG_AsPtr_std_string(obj7, &ptr);
13934	<	if (!SWIG_IsOK(res) || !ptr) {
13935	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "8"" of type '" "std::string""'");
13936	<	}
13937	<	arg8 = *ptr;
13938	<	if (SWIG_IsNewObj(res)) delete ptr;
13939	<	}
13940	<	{
13941	<	std::string *ptr = (std::string *)0;
13942	<	int res = SWIG_AsPtr_std_string(obj8, &ptr);
13943	<	if (!SWIG_IsOK(res) || !ptr) {
13944	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "9"" of type '" "std::string""'");
3955	>	static PyObject *_wrap_BossTask_id(PyObject *self, PyObject *args) {
3956	>	PyObject *resultobj;
3957	>	BossTask *arg1 = (BossTask *) 0 ;
3958	>	std::string *result;
3959	>	PyObject * obj0 = 0 ;
3960	>
3961	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_id",&obj0)) goto fail;
3962	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3963	>	{
3964	>	try {
3965	>	{
3966	>	std::string const &_result_ref = ((BossTask const *)arg1)->id();
3967	>	result = (std::string *) &_result_ref;
3968	>	}
3969	>
3970	>	}catch (const BossSchedFailure & e) {
3971	>	PyErr_SetString ( SchedulerError, e.what() );
3972	>	return NULL;
3973	>	}catch (const std::exception& e) {
3974	>	PyErr_SetString ( BossError, e.what() );
3975	>	return NULL;
3976	>	}
3977		}
3978	<	arg9 = *ptr;
3979	<	if (SWIG_IsNewObj(res)) delete ptr;
13948	<	}
13949	<	{
13950	<	try {
13951	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
13952	<	} catch (const std::exception& e) {
13953	<	SWIG_exception(SWIG_RuntimeError, e.what());
3978	>	{
3979	>	resultobj = PyString_FromStringAndSize(result->data(),result->size());
3980		}
3981	<	}
3982	<	resultobj = result;
3983	<	if (SWIG_IsNewObj(res3)) delete arg3;
13958	<	if (SWIG_IsNewObj(res4)) delete arg4;
13959	<	if (SWIG_IsNewObj(res5)) delete arg5;
13960	<	return resultobj;
13961	<	fail:
13962	<	if (SWIG_IsNewObj(res3)) delete arg3;
13963	<	if (SWIG_IsNewObj(res4)) delete arg4;
13964	<	if (SWIG_IsNewObj(res5)) delete arg5;
13965	<	return NULL;
3981	>	return resultobj;
3982	>	fail:
3983	>	return NULL;
3984		}
3985
3986
3987	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3988	<	PyObject *resultobj = 0;
3989	<	BossSession *arg1 = (BossSession *) 0 ;
3990	<	int arg2 ;
3991	<	std::string *arg3 = 0 ;
3992	<	std::string *arg4 = 0 ;
3993	<	std::string *arg5 = 0 ;
3994	<	std::string arg6 ;
3995	<	std::string arg7 ;
3996	<	std::string arg8 ;
3997	<	PyObject *result = 0 ;
3998	<	void *argp1 = 0 ;
3999	<	int res1 = 0 ;
4000	<	int val2 ;
4001	<	int ecode2 = 0 ;
4002	<	int res3 = SWIG_OLDOBJ ;
4003	<	int res4 = SWIG_OLDOBJ ;
4004	<	int res5 = SWIG_OLDOBJ ;
4005	<	PyObject * obj0 = 0 ;
4006	<	PyObject * obj1 = 0 ;
4007	<	PyObject * obj2 = 0 ;
4008	<	PyObject * obj3 = 0 ;
13991	<	PyObject * obj4 = 0 ;
13992	<	PyObject * obj5 = 0 ;
13993	<	PyObject * obj6 = 0 ;
13994	<	PyObject * obj7 = 0 ;
13995	<
13996	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
13997	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13998	<	if (!SWIG_IsOK(res1)) {
13999	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
14000	<	}
14001	<	arg1 = reinterpret_cast< BossSession * >(argp1);
14002	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
14003	<	if (!SWIG_IsOK(ecode2)) {
14004	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
14005	<	}
14006	<	arg2 = static_cast< int >(val2);
14007	<	{
14008	<	std::string *ptr = (std::string *)0;
14009	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
14010	<	if (!SWIG_IsOK(res3)) {
14011	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14012	<	}
14013	<	if (!ptr) {
14014	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14015	<	}
14016	<	arg3 = ptr;
14017	<	}
14018	<	{
14019	<	std::string *ptr = (std::string *)0;
14020	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
14021	<	if (!SWIG_IsOK(res4)) {
14022	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14023	<	}
14024	<	if (!ptr) {
14025	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14026	<	}
14027	<	arg4 = ptr;
14028	<	}
14029	<	{
14030	<	std::string *ptr = (std::string *)0;
14031	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
14032	<	if (!SWIG_IsOK(res5)) {
14033	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14034	<	}
14035	<	if (!ptr) {
14036	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14037	<	}
14038	<	arg5 = ptr;
14039	<	}
14040	<	{
14041	<	std::string *ptr = (std::string *)0;
14042	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
14043	<	if (!SWIG_IsOK(res) || !ptr) {
14044	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "6"" of type '" "std::string""'");
14045	<	}
14046	<	arg6 = *ptr;
14047	<	if (SWIG_IsNewObj(res)) delete ptr;
14048	<	}
14049	<	{
14050	<	std::string *ptr = (std::string *)0;
14051	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
14052	<	if (!SWIG_IsOK(res) || !ptr) {
14053	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "7"" of type '" "std::string""'");
14054	<	}
14055	<	arg7 = *ptr;
14056	<	if (SWIG_IsNewObj(res)) delete ptr;
14057	<	}
14058	<	{
14059	<	std::string *ptr = (std::string *)0;
14060	<	int res = SWIG_AsPtr_std_string(obj7, &ptr);
14061	<	if (!SWIG_IsOK(res) || !ptr) {
14062	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "8"" of type '" "std::string""'");
3987	>	static PyObject *_wrap_BossTask_name(PyObject *self, PyObject *args) {
3988	>	PyObject *resultobj;
3989	>	BossTask *arg1 = (BossTask *) 0 ;
3990	>	std::string *result;
3991	>	PyObject * obj0 = 0 ;
3992	>
3993	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_name",&obj0)) goto fail;
3994	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3995	>	{
3996	>	try {
3997	>	{
3998	>	std::string const &_result_ref = ((BossTask const *)arg1)->name();
3999	>	result = (std::string *) &_result_ref;
4000	>	}
4001	>
4002	>	}catch (const BossSchedFailure & e) {
4003	>	PyErr_SetString ( SchedulerError, e.what() );
4004	>	return NULL;
4005	>	}catch (const std::exception& e) {
4006	>	PyErr_SetString ( BossError, e.what() );
4007	>	return NULL;
4008	>	}
4009		}
4010	<	arg8 = *ptr;
4011	<	if (SWIG_IsNewObj(res)) delete ptr;
14066	<	}
14067	<	{
14068	<	try {
14069	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8);
14070	<	} catch (const std::exception& e) {
14071	<	SWIG_exception(SWIG_RuntimeError, e.what());
4010	>	{
4011	>	resultobj = PyString_FromStringAndSize(result->data(),result->size());
4012		}
4013	<	}
4014	<	resultobj = result;
4015	<	if (SWIG_IsNewObj(res3)) delete arg3;
14076	<	if (SWIG_IsNewObj(res4)) delete arg4;
14077	<	if (SWIG_IsNewObj(res5)) delete arg5;
14078	<	return resultobj;
14079	<	fail:
14080	<	if (SWIG_IsNewObj(res3)) delete arg3;
14081	<	if (SWIG_IsNewObj(res4)) delete arg4;
14082	<	if (SWIG_IsNewObj(res5)) delete arg5;
14083	<	return NULL;
4013	>	return resultobj;
4014	>	fail:
4015	>	return NULL;
4016		}
4017
4018
4019	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4020	<	PyObject *resultobj = 0;
4021	<	BossSession *arg1 = (BossSession *) 0 ;
4022	<	int arg2 ;
4023	<	std::string *arg3 = 0 ;
4024	<	std::string *arg4 = 0 ;
4025	<	std::string *arg5 = 0 ;
4026	<	std::string arg6 ;
4027	<	std::string arg7 ;
4028	<	PyObject *result = 0 ;
4029	<	void *argp1 = 0 ;
4030	<	int res1 = 0 ;
4031	<	int val2 ;
4032	<	int ecode2 = 0 ;
4033	<	int res3 = SWIG_OLDOBJ ;
4034	<	int res4 = SWIG_OLDOBJ ;
4035	<	int res5 = SWIG_OLDOBJ ;
4036	<	PyObject * obj0 = 0 ;
4037	<	PyObject * obj1 = 0 ;
14106	<	PyObject * obj2 = 0 ;
14107	<	PyObject * obj3 = 0 ;
14108	<	PyObject * obj4 = 0 ;
14109	<	PyObject * obj5 = 0 ;
14110	<	PyObject * obj6 = 0 ;
14111	<
14112	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
14113	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
14114	<	if (!SWIG_IsOK(res1)) {
14115	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
14116	<	}
14117	<	arg1 = reinterpret_cast< BossSession * >(argp1);
14118	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
14119	<	if (!SWIG_IsOK(ecode2)) {
14120	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
14121	<	}
14122	<	arg2 = static_cast< int >(val2);
14123	<	{
14124	<	std::string *ptr = (std::string *)0;
14125	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
14126	<	if (!SWIG_IsOK(res3)) {
14127	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14128	<	}
14129	<	if (!ptr) {
14130	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14131	<	}
14132	<	arg3 = ptr;
14133	<	}
14134	<	{
14135	<	std::string *ptr = (std::string *)0;
14136	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
14137	<	if (!SWIG_IsOK(res4)) {
14138	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14139	<	}
14140	<	if (!ptr) {
14141	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14142	<	}
14143	<	arg4 = ptr;
14144	<	}
14145	<	{
14146	<	std::string *ptr = (std::string *)0;
14147	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
14148	<	if (!SWIG_IsOK(res5)) {
14149	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14150	<	}
14151	<	if (!ptr) {
14152	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14153	<	}
14154	<	arg5 = ptr;
14155	<	}
14156	<	{
14157	<	std::string *ptr = (std::string *)0;
14158	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
14159	<	if (!SWIG_IsOK(res) || !ptr) {
14160	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "6"" of type '" "std::string""'");
14161	<	}
14162	<	arg6 = *ptr;
14163	<	if (SWIG_IsNewObj(res)) delete ptr;
14164	<	}
14165	<	{
14166	<	std::string *ptr = (std::string *)0;
14167	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
14168	<	if (!SWIG_IsOK(res) || !ptr) {
14169	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "7"" of type '" "std::string""'");
4019	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4020	>	PyObject *resultobj;
4021	>	BossTask *arg1 = (BossTask *) 0 ;
4022	>	std::map<std::string,std::string > result;
4023	>	PyObject * obj0 = 0 ;
4024	>
4025	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4026	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4027	>	{
4028	>	try {
4029	>	result = ((BossTask const *)arg1)->taskMap();
4030	>
4031	>	}catch (const BossSchedFailure & e) {
4032	>	PyErr_SetString ( SchedulerError, e.what() );
4033	>	return NULL;
4034	>	}catch (const std::exception& e) {
4035	>	PyErr_SetString ( BossError, e.what() );
4036	>	return NULL;
4037	>	}
4038		}
4039	<	arg7 = *ptr;
4040	<	if (SWIG_IsNewObj(res)) delete ptr;
4041	<	}
4042	<	{
4043	<	try {
4044	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
4045	<	} catch (const std::exception& e) {
14178	<	SWIG_exception(SWIG_RuntimeError, e.what());
4039	>	{
4040	>	resultobj = PyDict_New();
4041	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4042	>	PyDict_SetItem(resultobj,
4043	>	SwigString_FromString(i->first),
4044	>	SwigString_FromString(i->second));
4045	>	}
4046		}
4047	<	}
4048	<	resultobj = result;
4049	<	if (SWIG_IsNewObj(res3)) delete arg3;
14183	<	if (SWIG_IsNewObj(res4)) delete arg4;
14184	<	if (SWIG_IsNewObj(res5)) delete arg5;
14185	<	return resultobj;
14186	<	fail:
14187	<	if (SWIG_IsNewObj(res3)) delete arg3;
14188	<	if (SWIG_IsNewObj(res4)) delete arg4;
14189	<	if (SWIG_IsNewObj(res5)) delete arg5;
14190	<	return NULL;
4047	>	return resultobj;
4048	>	fail:
4049	>	return NULL;
4050		}
4051
4052
4053	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4054	<	PyObject *resultobj = 0;
4055	<	BossSession *arg1 = (BossSession *) 0 ;
4056	<	int arg2 ;
4057	<	std::string *arg3 = 0 ;
4058	<	std::string *arg4 = 0 ;
4059	<	std::string *arg5 = 0 ;
4060	<	std::string arg6 ;
4061	<	PyObject *result = 0 ;
4062	<	void *argp1 = 0 ;
4063	<	int res1 = 0 ;
4064	<	int val2 ;
4065	<	int ecode2 = 0 ;
4066	<	int res3 = SWIG_OLDOBJ ;
4067	<	int res4 = SWIG_OLDOBJ ;
4068	<	int res5 = SWIG_OLDOBJ ;
4069	<	PyObject * obj0 = 0 ;
4070	<	PyObject * obj1 = 0 ;
4071	<	PyObject * obj2 = 0 ;
14213	<	PyObject * obj3 = 0 ;
14214	<	PyObject * obj4 = 0 ;
14215	<	PyObject * obj5 = 0 ;
14216	<
14217	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14218	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
14219	<	if (!SWIG_IsOK(res1)) {
14220	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
14221	<	}
14222	<	arg1 = reinterpret_cast< BossSession * >(argp1);
14223	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
14224	<	if (!SWIG_IsOK(ecode2)) {
14225	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
14226	<	}
14227	<	arg2 = static_cast< int >(val2);
14228	<	{
14229	<	std::string *ptr = (std::string *)0;
14230	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
14231	<	if (!SWIG_IsOK(res3)) {
14232	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14233	<	}
14234	<	if (!ptr) {
14235	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14236	<	}
14237	<	arg3 = ptr;
14238	<	}
14239	<	{
14240	<	std::string *ptr = (std::string *)0;
14241	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
14242	<	if (!SWIG_IsOK(res4)) {
14243	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14244	<	}
14245	<	if (!ptr) {
14246	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14247	<	}
14248	<	arg4 = ptr;
14249	<	}
14250	<	{
14251	<	std::string *ptr = (std::string *)0;
14252	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
14253	<	if (!SWIG_IsOK(res5)) {
14254	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14255	<	}
14256	<	if (!ptr) {
14257	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14258	<	}
14259	<	arg5 = ptr;
14260	<	}
14261	<	{
14262	<	std::string *ptr = (std::string *)0;
14263	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
14264	<	if (!SWIG_IsOK(res) || !ptr) {
14265	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "6"" of type '" "std::string""'");
4053	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
4054	>	PyObject *resultobj;
4055	>	BossTask *arg1 = (BossTask *) 0 ;
4056	>	BossTask::job_iterator result;
4057	>	PyObject * obj0 = 0 ;
4058	>
4059	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
4060	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4061	>	{
4062	>	try {
4063	>	result = ((BossTask const *)arg1)->job_begin();
4064	>
4065	>	}catch (const BossSchedFailure & e) {
4066	>	PyErr_SetString ( SchedulerError, e.what() );
4067	>	return NULL;
4068	>	}catch (const std::exception& e) {
4069	>	PyErr_SetString ( BossError, e.what() );
4070	>	return NULL;
4071	>	}
4072		}
4073	<	arg6 = *ptr;
4074	<	if (SWIG_IsNewObj(res)) delete ptr;
4075	<	}
4076	<	{
14271	<	try {
14272	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
14273	<	} catch (const std::exception& e) {
14274	<	SWIG_exception(SWIG_RuntimeError, e.what());
4073	>	{
4074	>	BossTask::job_iterator * resultptr;
4075	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4076	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4077		}
4078	<	}
4079	<	resultobj = result;
4080	<	if (SWIG_IsNewObj(res3)) delete arg3;
14279	<	if (SWIG_IsNewObj(res4)) delete arg4;
14280	<	if (SWIG_IsNewObj(res5)) delete arg5;
14281	<	return resultobj;
14282	<	fail:
14283	<	if (SWIG_IsNewObj(res3)) delete arg3;
14284	<	if (SWIG_IsNewObj(res4)) delete arg4;
14285	<	if (SWIG_IsNewObj(res5)) delete arg5;
14286	<	return NULL;
4078	>	return resultobj;
4079	>	fail:
4080	>	return NULL;
4081		}
4082
4083
4084	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4085	<	PyObject *resultobj = 0;
4086	<	BossSession *arg1 = (BossSession *) 0 ;
4087	<	int arg2 ;
4088	<	std::string *arg3 = 0 ;
4089	<	std::string *arg4 = 0 ;
4090	<	std::string *arg5 = 0 ;
4091	<	PyObject *result = 0 ;
4092	<	void *argp1 = 0 ;
4093	<	int res1 = 0 ;
4094	<	int val2 ;
4095	<	int ecode2 = 0 ;
4096	<	int res3 = SWIG_OLDOBJ ;
4097	<	int res4 = SWIG_OLDOBJ ;
4098	<	int res5 = SWIG_OLDOBJ ;
4099	<	PyObject * obj0 = 0 ;
4100	<	PyObject * obj1 = 0 ;
4101	<	PyObject * obj2 = 0 ;
4102	<	PyObject * obj3 = 0 ;
14309	<	PyObject * obj4 = 0 ;
14310	<
14311	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14312	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
14313	<	if (!SWIG_IsOK(res1)) {
14314	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
14315	<	}
14316	<	arg1 = reinterpret_cast< BossSession * >(argp1);
14317	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
14318	<	if (!SWIG_IsOK(ecode2)) {
14319	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
14320	<	}
14321	<	arg2 = static_cast< int >(val2);
14322	<	{
14323	<	std::string *ptr = (std::string *)0;
14324	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
14325	<	if (!SWIG_IsOK(res3)) {
14326	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14327	<	}
14328	<	if (!ptr) {
14329	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14330	<	}
14331	<	arg3 = ptr;
14332	<	}
14333	<	{
14334	<	std::string *ptr = (std::string *)0;
14335	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
14336	<	if (!SWIG_IsOK(res4)) {
14337	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14338	<	}
14339	<	if (!ptr) {
14340	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14341	<	}
14342	<	arg4 = ptr;
14343	<	}
14344	<	{
14345	<	std::string *ptr = (std::string *)0;
14346	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
14347	<	if (!SWIG_IsOK(res5)) {
14348	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14349	<	}
14350	<	if (!ptr) {
14351	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
4084	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4085	>	PyObject *resultobj;
4086	>	BossTask *arg1 = (BossTask *) 0 ;
4087	>	BossTask::job_iterator result;
4088	>	PyObject * obj0 = 0 ;
4089	>
4090	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
4091	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4092	>	{
4093	>	try {
4094	>	result = ((BossTask const *)arg1)->job_end();
4095	>
4096	>	}catch (const BossSchedFailure & e) {
4097	>	PyErr_SetString ( SchedulerError, e.what() );
4098	>	return NULL;
4099	>	}catch (const std::exception& e) {
4100	>	PyErr_SetString ( BossError, e.what() );
4101	>	return NULL;
4102	>	}
4103		}
4104	<	arg5 = ptr;
4105	<	}
4106	<	{
4107	<	try {
14357	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
14358	<	} catch (const std::exception& e) {
14359	<	SWIG_exception(SWIG_RuntimeError, e.what());
4104	>	{
4105	>	BossTask::job_iterator * resultptr;
4106	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4107	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4108		}
4109	<	}
4110	<	resultobj = result;
4111	<	if (SWIG_IsNewObj(res3)) delete arg3;
14364	<	if (SWIG_IsNewObj(res4)) delete arg4;
14365	<	if (SWIG_IsNewObj(res5)) delete arg5;
14366	<	return resultobj;
14367	<	fail:
14368	<	if (SWIG_IsNewObj(res3)) delete arg3;
14369	<	if (SWIG_IsNewObj(res4)) delete arg4;
14370	<	if (SWIG_IsNewObj(res5)) delete arg5;
14371	<	return NULL;
4109	>	return resultobj;
4110	>	fail:
4111	>	return NULL;
4112		}
4113
4114
4115	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4116	<	PyObject *resultobj = 0;
4117	<	BossSession *arg1 = (BossSession *) 0 ;
4118	<	int arg2 ;
4119	<	std::string *arg3 = 0 ;
4120	<	std::string *arg4 = 0 ;
4121	<	PyObject *result = 0 ;
4122	<	void *argp1 = 0 ;
4123	<	int res1 = 0 ;
4124	<	int val2 ;
4125	<	int ecode2 = 0 ;
4126	<	int res3 = SWIG_OLDOBJ ;
4127	<	int res4 = SWIG_OLDOBJ ;
4128	<	PyObject * obj0 = 0 ;
4129	<	PyObject * obj1 = 0 ;
4130	<	PyObject * obj2 = 0 ;
4131	<	PyObject * obj3 = 0 ;
4132	<
4133	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14394	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
14395	<	if (!SWIG_IsOK(res1)) {
14396	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
14397	<	}
14398	<	arg1 = reinterpret_cast< BossSession * >(argp1);
14399	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
14400	<	if (!SWIG_IsOK(ecode2)) {
14401	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
14402	<	}
14403	<	arg2 = static_cast< int >(val2);
14404	<	{
14405	<	std::string *ptr = (std::string *)0;
14406	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
14407	<	if (!SWIG_IsOK(res3)) {
14408	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14409	<	}
14410	<	if (!ptr) {
14411	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14412	<	}
14413	<	arg3 = ptr;
14414	<	}
14415	<	{
14416	<	std::string *ptr = (std::string *)0;
14417	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
14418	<	if (!SWIG_IsOK(res4)) {
14419	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14420	<	}
14421	<	if (!ptr) {
14422	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
4115	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4116	>	PyObject *resultobj;
4117	>	BossTask *arg1 = (BossTask *) 0 ;
4118	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4119	>	PyObject * obj0 = 0 ;
4120	>
4121	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4122	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4123	>	{
4124	>	try {
4125	>	result = ((BossTask const *)arg1)->jobsMap();
4126	>
4127	>	}catch (const BossSchedFailure & e) {
4128	>	PyErr_SetString ( SchedulerError, e.what() );
4129	>	return NULL;
4130	>	}catch (const std::exception& e) {
4131	>	PyErr_SetString ( BossError, e.what() );
4132	>	return NULL;
4133	>	}
4134		}
4135	<	arg4 = ptr;
4136	<	}
4137	<	{
4138	<	try {
14428	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4);
14429	<	} catch (const std::exception& e) {
14430	<	SWIG_exception(SWIG_RuntimeError, e.what());
4135	>	{
4136	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4137	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4138	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4139		}
4140	<	}
4141	<	resultobj = result;
4142	<	if (SWIG_IsNewObj(res3)) delete arg3;
14435	<	if (SWIG_IsNewObj(res4)) delete arg4;
14436	<	return resultobj;
14437	<	fail:
14438	<	if (SWIG_IsNewObj(res3)) delete arg3;
14439	<	if (SWIG_IsNewObj(res4)) delete arg4;
14440	<	return NULL;
4140	>	return resultobj;
4141	>	fail:
4142	>	return NULL;
4143		}
4144
4145
4146	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4147	<	PyObject *resultobj = 0;
4148	<	BossSession *arg1 = (BossSession *) 0 ;
4149	<	int arg2 ;
4150	<	std::string *arg3 = 0 ;
4151	<	PyObject *result = 0 ;
4152	<	void *argp1 = 0 ;
4153	<	int res1 = 0 ;
4154	<	int val2 ;
4155	<	int ecode2 = 0 ;
4156	<	int res3 = SWIG_OLDOBJ ;
4157	<	PyObject * obj0 = 0 ;
4158	<	PyObject * obj1 = 0 ;
4159	<	PyObject * obj2 = 0 ;
4160	<
4161	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_queryTasks",&obj0,&obj1,&obj2)) SWIG_fail;
4162	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
4163	<	if (!SWIG_IsOK(res1)) {
14462	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
14463	<	}
14464	<	arg1 = reinterpret_cast< BossSession * >(argp1);
14465	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
14466	<	if (!SWIG_IsOK(ecode2)) {
14467	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
14468	<	}
14469	<	arg2 = static_cast< int >(val2);
14470	<	{
14471	<	std::string *ptr = (std::string *)0;
14472	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
14473	<	if (!SWIG_IsOK(res3)) {
14474	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
4146	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4147	>	PyObject *resultobj;
4148	>	BossTask *arg1 = (BossTask *) 0 ;
4149	>	SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
4150	>	std::map<std::string,std::string > *arg3 = 0 ;
4151	>	std::string result;
4152	>	std::vector<BossJob * >::const_iterator *argp2 ;
4153	>	PyObject * obj0 = 0 ;
4154	>	PyObject * obj1 = 0 ;
4155	>	PyObject * obj2 = 0 ;
4156	>
4157	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobMap",&obj0,&obj1,&obj2)) goto fail;
4158	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4159	>	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
4160	>	arg2 = *argp2;
4161	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4162	>	if (arg3 == NULL) {
4163	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
4164		}
4165	<	if (!ptr) {
4166	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
4165	>	{
4166	>	try {
4167	>	result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4168	>
4169	>	}catch (const BossSchedFailure & e) {
4170	>	PyErr_SetString ( SchedulerError, e.what() );
4171	>	return NULL;
4172	>	}catch (const std::exception& e) {
4173	>	PyErr_SetString ( BossError, e.what() );
4174	>	return NULL;
4175	>	}
4176		}
4177	<	arg3 = ptr;
4178	<	}
14481	<	{
14482	<	try {
14483	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3);
14484	<	} catch (const std::exception& e) {
14485	<	SWIG_exception(SWIG_RuntimeError, e.what());
4177	>	{
4178	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4179		}
4180	<	}
4181	<	resultobj = result;
4182	<	if (SWIG_IsNewObj(res3)) delete arg3;
14490	<	return resultobj;
14491	<	fail:
14492	<	if (SWIG_IsNewObj(res3)) delete arg3;
14493	<	return NULL;
4180	>	return resultobj;
4181	>	fail:
4182	>	return NULL;
4183		}
4184
4185
4186	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4187	<	PyObject *resultobj = 0;
4188	<	BossSession *arg1 = (BossSession *) 0 ;
4189	<	int arg2 ;
4190	<	PyObject *result = 0 ;
4191	<	void *argp1 = 0 ;
4192	<	int res1 = 0 ;
4193	<	int val2 ;
4194	<	int ecode2 = 0 ;
4195	<	PyObject * obj0 = 0 ;
4196	<	PyObject * obj1 = 0 ;
4197	<
4198	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_queryTasks",&obj0,&obj1)) SWIG_fail;
4199	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
4200	<	if (!SWIG_IsOK(res1)) {
4201	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
4202	<	}
4203	<	arg1 = reinterpret_cast< BossSession * >(argp1);
4204	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
4205	<	if (!SWIG_IsOK(ecode2)) {
4206	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
4207	<	}
4208	<	arg2 = static_cast< int >(val2);
14520	<	{
14521	<	try {
14522	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2);
14523	<	} catch (const std::exception& e) {
14524	<	SWIG_exception(SWIG_RuntimeError, e.what());
4186	>	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4187	>	PyObject *resultobj;
4188	>	BossTask *arg1 = (BossTask *) 0 ;
4189	>	unsigned int arg2 ;
4190	>	std::map<std::string,std::string > result;
4191	>	PyObject * obj0 = 0 ;
4192	>	PyObject * obj1 = 0 ;
4193	>
4194	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4195	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4196	>	arg2 = (unsigned int) PyInt_AsLong(obj1);
4197	>	if (PyErr_Occurred()) SWIG_fail;
4198	>	{
4199	>	try {
4200	>	result = ((BossTask const *)arg1)->jobMap(arg2);
4201	>
4202	>	}catch (const BossSchedFailure & e) {
4203	>	PyErr_SetString ( SchedulerError, e.what() );
4204	>	return NULL;
4205	>	}catch (const std::exception& e) {
4206	>	PyErr_SetString ( BossError, e.what() );
4207	>	return NULL;
4208	>	}
4209		}
4210	<	}
4211	<	resultobj = result;
4212	<	return resultobj;
4213	<	fail:
4214	<	return NULL;
4215	<	}
4216	<
14533	<
14534	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14535	<	PyObject *resultobj = 0;
14536	<	BossSession *arg1 = (BossSession *) 0 ;
14537	<	PyObject *result = 0 ;
14538	<	void *argp1 = 0 ;
14539	<	int res1 = 0 ;
14540	<	PyObject * obj0 = 0 ;
14541	<
14542	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_queryTasks",&obj0)) SWIG_fail;
14543	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
14544	<	if (!SWIG_IsOK(res1)) {
14545	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
14546	<	}
14547	<	arg1 = reinterpret_cast< BossSession * >(argp1);
14548	<	{
14549	<	try {
14550	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1);
14551	<	} catch (const std::exception& e) {
14552	<	SWIG_exception(SWIG_RuntimeError, e.what());
4210	>	{
4211	>	resultobj = PyDict_New();
4212	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4213	>	PyDict_SetItem(resultobj,
4214	>	SwigString_FromString(i->first),
4215	>	SwigString_FromString(i->second));
4216	>	}
4217		}
4218	<	}
4219	<	resultobj = result;
4220	<	return resultobj;
14557	<	fail:
14558	<	return NULL;
4218	>	return resultobj;
4219	>	fail:
4220	>	return NULL;
4221		}
4222
4223
4224	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
4225	<	int argc;
4226	<	PyObject *argv[11];
4227	<	int ii;
4228	<
4229	<	if (!PyTuple_Check(args)) SWIG_fail;
4230	<	argc = PyObject_Length(args);
4231	<	for (ii = 0; (ii < argc) && (ii < 10); ii++) {
14570	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
14571	<	}
14572	<	if (argc == 1) {
14573	<	int _v;
14574	<	void *vptr = 0;
14575	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14576	<	_v = SWIG_CheckState(res);
14577	<	if (_v) {
14578	<	return _wrap_BossSession_queryTasks__SWIG_9(self, args);
14579	<	}
14580	<	}
14581	<	if (argc == 2) {
14582	<	int _v;
14583	<	void *vptr = 0;
14584	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14585	<	_v = SWIG_CheckState(res);
14586	<	if (_v) {
14587	<	{
14588	<	int res = SWIG_AsVal_int(argv[1], NULL);
14589	<	_v = SWIG_CheckState(res);
14590	<	}
14591	<	if (_v) {
14592	<	return _wrap_BossSession_queryTasks__SWIG_8(self, args);
14593	<	}
14594	<	}
14595	<	}
14596	<	if (argc == 3) {
14597	<	int _v;
14598	<	void *vptr = 0;
14599	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14600	<	_v = SWIG_CheckState(res);
14601	<	if (_v) {
14602	<	{
14603	<	int res = SWIG_AsVal_int(argv[1], NULL);
14604	<	_v = SWIG_CheckState(res);
14605	<	}
14606	<	if (_v) {
14607	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
14608	<	_v = SWIG_CheckState(res);
14609	<	if (_v) {
14610	<	return _wrap_BossSession_queryTasks__SWIG_7(self, args);
14611	<	}
14612	<	}
14613	<	}
14614	<	}
14615	<	if (argc == 4) {
14616	<	int _v;
14617	<	void *vptr = 0;
14618	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14619	<	_v = SWIG_CheckState(res);
14620	<	if (_v) {
14621	<	{
14622	<	int res = SWIG_AsVal_int(argv[1], NULL);
14623	<	_v = SWIG_CheckState(res);
14624	<	}
14625	<	if (_v) {
14626	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
14627	<	_v = SWIG_CheckState(res);
14628	<	if (_v) {
14629	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
14630	<	_v = SWIG_CheckState(res);
14631	<	if (_v) {
14632	<	return _wrap_BossSession_queryTasks__SWIG_6(self, args);
14633	<	}
14634	<	}
14635	<	}
4224	>	static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4225	>	int argc;
4226	>	PyObject *argv[4];
4227	>	int ii;
4228	>
4229	>	argc = PyObject_Length(args);
4230	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4231	>	argv[ii] = PyTuple_GetItem(args,ii);
4232		}
4233	<	}
4234	<	if (argc == 5) {
4235	<	int _v;
4236	<	void *vptr = 0;
4237	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
4238	<	_v = SWIG_CheckState(res);
4239	<	if (_v) {
4240	<	{
4241	<	int res = SWIG_AsVal_int(argv[1], NULL);
14646	<	_v = SWIG_CheckState(res);
14647	<	}
14648	<	if (_v) {
14649	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
14650	<	_v = SWIG_CheckState(res);
14651	<	if (_v) {
14652	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
14653	<	_v = SWIG_CheckState(res);
14654	<	if (_v) {
14655	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
14656	<	_v = SWIG_CheckState(res);
14657	<	if (_v) {
14658	<	return _wrap_BossSession_queryTasks__SWIG_5(self, args);
4233	>	if (argc == 2) {
4234	>	int _v;
4235	>	{
4236	>	void *ptr;
4237	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4238	>	_v = 0;
4239	>	PyErr_Clear();
4240	>	}else {
4241	>	_v = 1;
4242		}
14660	–	}
4243		}
14662	–	}
14663	–	}
14664	–	}
14665	–	if (argc == 6) {
14666	–	int _v;
14667	–	void *vptr = 0;
14668	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14669	–	_v = SWIG_CheckState(res);
14670	–	if (_v) {
14671	–	{
14672	–	int res = SWIG_AsVal_int(argv[1], NULL);
14673	–	_v = SWIG_CheckState(res);
14674	–	}
14675	–	if (_v) {
14676	–	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
14677	–	_v = SWIG_CheckState(res);
4244		if (_v) {
4245	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
4246	<	_v = SWIG_CheckState(res);
4247	<	if (_v) {
14682	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
14683	<	_v = SWIG_CheckState(res);
4245	>	{
4246	>	_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4247	>	}
4248		if (_v) {
4249	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
14686	<	_v = SWIG_CheckState(res);
14687	<	if (_v) {
14688	<	return _wrap_BossSession_queryTasks__SWIG_4(self, args);
14689	<	}
4249	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4250		}
14691	–	}
4251		}
14693	–	}
4252		}
4253	<	}
4254	<	if (argc == 7) {
4255	<	int _v;
4256	<	void *vptr = 0;
4257	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
4258	<	_v = SWIG_CheckState(res);
4259	<	if (_v) {
4260	<	{
4261	<	int res = SWIG_AsVal_int(argv[1], NULL);
14704	<	_v = SWIG_CheckState(res);
14705	<	}
14706	<	if (_v) {
14707	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
14708	<	_v = SWIG_CheckState(res);
14709	<	if (_v) {
14710	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
14711	<	_v = SWIG_CheckState(res);
14712	<	if (_v) {
14713	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
14714	<	_v = SWIG_CheckState(res);
14715	<	if (_v) {
14716	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
14717	<	_v = SWIG_CheckState(res);
14718	<	if (_v) {
14719	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
14720	<	_v = SWIG_CheckState(res);
14721	<	if (_v) {
14722	<	return _wrap_BossSession_queryTasks__SWIG_3(self, args);
14723	<	}
14724	<	}
4253	>	if (argc == 3) {
4254	>	int _v;
4255	>	{
4256	>	void *ptr;
4257	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4258	>	_v = 0;
4259	>	PyErr_Clear();
4260	>	}else {
4261	>	_v = 1;
4262		}
14726	–	}
4263		}
14728	–	}
14729	–	}
14730	–	}
14731	–	if (argc == 8) {
14732	–	int _v;
14733	–	void *vptr = 0;
14734	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14735	–	_v = SWIG_CheckState(res);
14736	–	if (_v) {
14737	–	{
14738	–	int res = SWIG_AsVal_int(argv[1], NULL);
14739	–	_v = SWIG_CheckState(res);
14740	–	}
14741	–	if (_v) {
14742	–	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
14743	–	_v = SWIG_CheckState(res);
4264		if (_v) {
4265	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
4266	<	_v = SWIG_CheckState(res);
4267	<	if (_v) {
4268	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
4269	<	_v = SWIG_CheckState(res);
4270	<	if (_v) {
4271	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
14752	<	_v = SWIG_CheckState(res);
14753	<	if (_v) {
14754	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
14755	<	_v = SWIG_CheckState(res);
14756	<	if (_v) {
14757	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
14758	<	_v = SWIG_CheckState(res);
14759	<	if (_v) {
14760	<	return _wrap_BossSession_queryTasks__SWIG_2(self, args);
14761	<	}
4265	>	{
4266	>	void *ptr;
4267	>	if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator, 0) == -1) {
4268	>	_v = 0;
4269	>	PyErr_Clear();
4270	>	}else {
4271	>	_v = 1;
4272		}
14763	–	}
4273		}
14765	–	}
14766	–	}
14767	–	}
14768	–	}
14769	–	}
14770	–	if (argc == 9) {
14771	–	int _v;
14772	–	void *vptr = 0;
14773	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14774	–	_v = SWIG_CheckState(res);
14775	–	if (_v) {
14776	–	{
14777	–	int res = SWIG_AsVal_int(argv[1], NULL);
14778	–	_v = SWIG_CheckState(res);
14779	–	}
14780	–	if (_v) {
14781	–	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
14782	–	_v = SWIG_CheckState(res);
14783	–	if (_v) {
14784	–	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
14785	–	_v = SWIG_CheckState(res);
14786	–	if (_v) {
14787	–	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
14788	–	_v = SWIG_CheckState(res);
4274		if (_v) {
4275	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
4276	<	_v = SWIG_CheckState(res);
4277	<	if (_v) {
4278	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
4279	<	_v = SWIG_CheckState(res);
4280	<	if (_v) {
4281	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
14797	<	_v = SWIG_CheckState(res);
14798	<	if (_v) {
14799	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
14800	<	_v = SWIG_CheckState(res);
14801	<	if (_v) {
14802	<	return _wrap_BossSession_queryTasks__SWIG_1(self, args);
4275	>	{
4276	>	void *ptr;
4277	>	if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_std__mapTstd__string_std__string_t, 0) == -1) {
4278	>	_v = 0;
4279	>	PyErr_Clear();
4280	>	}else {
4281	>	_v = 1;
4282		}
14804	–	}
4283		}
14806	–	}
14807	–	}
14808	–	}
14809	–	}
14810	–	}
14811	–	}
14812	–	}
14813	–	if (argc == 10) {
14814	–	int _v;
14815	–	void *vptr = 0;
14816	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14817	–	_v = SWIG_CheckState(res);
14818	–	if (_v) {
14819	–	{
14820	–	int res = SWIG_AsVal_int(argv[1], NULL);
14821	–	_v = SWIG_CheckState(res);
14822	–	}
14823	–	if (_v) {
14824	–	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
14825	–	_v = SWIG_CheckState(res);
14826	–	if (_v) {
14827	–	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
14828	–	_v = SWIG_CheckState(res);
14829	–	if (_v) {
14830	–	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
14831	–	_v = SWIG_CheckState(res);
14832	–	if (_v) {
14833	–	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
14834	–	_v = SWIG_CheckState(res);
14835	–	if (_v) {
14836	–	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
14837	–	_v = SWIG_CheckState(res);
4284		if (_v) {
4285	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
14840	<	_v = SWIG_CheckState(res);
14841	<	if (_v) {
14842	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
14843	<	_v = SWIG_CheckState(res);
14844	<	if (_v) {
14845	<	{
14846	<	int res = SWIG_AsVal_bool(argv[9], NULL);
14847	<	_v = SWIG_CheckState(res);
14848	<	}
14849	<	if (_v) {
14850	<	return _wrap_BossSession_queryTasks__SWIG_0(self, args);
14851	<	}
14852	<	}
14853	<	}
4285	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4286		}
14855	–	}
4287		}
14857	–	}
4288		}
14859	–	}
14860	–	}
14861	–	}
14862	–
14863	–	fail:
14864	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_queryTasks'");
14865	–	return NULL;
14866	–	}
14867	–
14868	–
14869	–	SWIGINTERN PyObject *BossSession_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14870	–	PyObject *obj;
14871	–	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
14872	–	SWIG_TypeNewClientData(SWIGTYPE_p_BossSession, SWIG_NewClientData(obj));
14873	–	return SWIG_Py_Void();
14874	–	}
14875	–
14876	–	SWIGINTERN PyObject *_wrap_BossTaskException_key_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14877	–	PyObject *resultobj = 0;
14878	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
14879	–	char *arg2 = (char *) 0 ;
14880	–	void *argp1 = 0 ;
14881	–	int res1 = 0 ;
14882	–	int res2 ;
14883	–	char *buf2 = 0 ;
14884	–	int alloc2 = 0 ;
14885	–	PyObject * obj0 = 0 ;
14886	–	PyObject * obj1 = 0 ;
14887	–
14888	–	if (!PyArg_ParseTuple(args,(char *)"OO:BossTaskException_key_set",&obj0,&obj1)) SWIG_fail;
14889	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTaskException, 0 |  0 );
14890	–	if (!SWIG_IsOK(res1)) {
14891	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTaskException_key_set" "', argument " "1"" of type '" "BossTaskException *""'");
14892	–	}
14893	–	arg1 = reinterpret_cast< BossTaskException * >(argp1);
14894	–	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14895	–	if (!SWIG_IsOK(res2)) {
14896	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTaskException_key_set" "', argument " "2"" of type '" "char const *""'");
14897	–	}
14898	–	arg2 = buf2;
14899	–	if (arg2) {
14900	–	size_t size = strlen(arg2) + 1;
14901	–	arg1->key = reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
14902	–	} else {
14903	–	arg1->key = 0;
14904	–	}
14905	–	resultobj = SWIG_Py_Void();
14906	–	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
14907	–	return resultobj;
14908	–	fail:
14909	–	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
14910	–	return NULL;
14911	–	}
14912	–
14913	–
14914	–	SWIGINTERN PyObject *_wrap_BossTaskException_key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14915	–	PyObject *resultobj = 0;
14916	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
14917	–	char *result = 0 ;
14918	–	void *argp1 = 0 ;
14919	–	int res1 = 0 ;
14920	–	PyObject * obj0 = 0 ;
14921	–
14922	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) SWIG_fail;
14923	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTaskException, 0 |  0 );
14924	–	if (!SWIG_IsOK(res1)) {
14925	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTaskException_key_get" "', argument " "1"" of type '" "BossTaskException *""'");
14926	–	}
14927	–	arg1 = reinterpret_cast< BossTaskException * >(argp1);
14928	–	result = (char *) ((arg1)->key);
14929	–	resultobj = SWIG_FromCharPtr(result);
14930	–	return resultobj;
14931	–	fail:
14932	–	return NULL;
14933	–	}
14934	–
14935	–
14936	–	SWIGINTERN PyObject *_wrap_new_BossTaskException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14937	–	PyObject *resultobj = 0;
14938	–	char *arg1 = (char *) 0 ;
14939	–	BossTaskException *result = 0 ;
14940	–	int res1 ;
14941	–	char *buf1 = 0 ;
14942	–	int alloc1 = 0 ;
14943	–	PyObject * obj0 = 0 ;
14944	–
14945	–	if (!PyArg_ParseTuple(args,(char *)"O:new_BossTaskException",&obj0)) SWIG_fail;
14946	–	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
14947	–	if (!SWIG_IsOK(res1)) {
14948	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BossTaskException" "', argument " "1"" of type '" "char const *""'");
14949	–	}
14950	–	arg1 = buf1;
14951	–	{
14952	–	try {
14953	–	result = (BossTaskException *)new BossTaskException((char const *)arg1);
14954	–	} catch (const std::exception& e) {
14955	–	SWIG_exception(SWIG_RuntimeError, e.what());
14956	–	}
14957	–	}
14958	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTaskException, SWIG_POINTER_NEW |  0 );
14959	–	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
14960	–	return resultobj;
14961	–	fail:
14962	–	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
14963	–	return NULL;
14964	–	}
14965	–
14966	–
14967	–	SWIGINTERN PyObject *_wrap_BossTaskException_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14968	–	PyObject *resultobj = 0;
14969	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
14970	–	char *result = 0 ;
14971	–	void *argp1 = 0 ;
14972	–	int res1 = 0 ;
14973	–	PyObject * obj0 = 0 ;
14974	–
14975	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) SWIG_fail;
14976	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTaskException, 0 |  0 );
14977	–	if (!SWIG_IsOK(res1)) {
14978	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTaskException_what" "', argument " "1"" of type '" "BossTaskException const *""'");
14979	–	}
14980	–	arg1 = reinterpret_cast< BossTaskException * >(argp1);
14981	–	{
14982	–	try {
14983	–	result = (char *)((BossTaskException const *)arg1)->what();
14984	–	} catch (const std::exception& e) {
14985	–	SWIG_exception(SWIG_RuntimeError, e.what());
14986	–	}
14987	–	}
14988	–	resultobj = SWIG_FromCharPtr(result);
14989	–	return resultobj;
14990	–	fail:
14991	–	return NULL;
14992	–	}
14993	–
14994	–
14995	–	SWIGINTERN PyObject *_wrap_delete_BossTaskException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14996	–	PyObject *resultobj = 0;
14997	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
14998	–	void *argp1 = 0 ;
14999	–	int res1 = 0 ;
15000	–	PyObject * obj0 = 0 ;
15001	–
15002	–	if (!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) SWIG_fail;
15003	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTaskException, SWIG_POINTER_DISOWN |  0 );
15004	–	if (!SWIG_IsOK(res1)) {
15005	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BossTaskException" "', argument " "1"" of type '" "BossTaskException *""'");
15006	–	}
15007	–	arg1 = reinterpret_cast< BossTaskException * >(argp1);
15008	–	{
15009	–	try {
15010	–	delete arg1;
15011	–
15012	–	} catch (const std::exception& e) {
15013	–	SWIG_exception(SWIG_RuntimeError, e.what());
15014	–	}
15015	–	}
15016	–	resultobj = SWIG_Py_Void();
15017	–	return resultobj;
15018	–	fail:
15019	–	return NULL;
15020	–	}
15021	–
15022	–
15023	–	SWIGINTERN PyObject *BossTaskException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15024	–	PyObject *obj;
15025	–	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
15026	–	SWIG_TypeNewClientData(SWIGTYPE_p_BossTaskException, SWIG_NewClientData(obj));
15027	–	return SWIG_Py_Void();
15028	–	}
15029	–
15030	–	SWIGINTERN PyObject *_wrap_new_BossTask__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15031	–	PyObject *resultobj = 0;
15032	–	BossDatabase *arg1 = (BossDatabase *) 0 ;
15033	–	BossTask *result = 0 ;
15034	–	void *argp1 = 0 ;
15035	–	int res1 = 0 ;
15036	–	PyObject * obj0 = 0 ;
15037	–
15038	–	if (!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) SWIG_fail;
15039	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossDatabase, 0 |  0 );
15040	–	if (!SWIG_IsOK(res1)) {
15041	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BossTask" "', argument " "1"" of type '" "BossDatabase *""'");
15042	–	}
15043	–	arg1 = reinterpret_cast< BossDatabase * >(argp1);
15044	–	{
15045	–	try {
15046	–	result = (BossTask *)new BossTask(arg1);
15047	–	} catch (const std::exception& e) {
15048	–	SWIG_exception(SWIG_RuntimeError, e.what());
15049	–	}
15050	–	}
15051	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, SWIG_POINTER_NEW |  0 );
15052	–	return resultobj;
15053	–	fail:
15054	–	return NULL;
15055	–	}
15056	–
15057	–
15058	–	SWIGINTERN PyObject *_wrap_new_BossTask__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15059	–	PyObject *resultobj = 0;
15060	–	BossDatabase *arg1 = (BossDatabase *) 0 ;
15061	–	std::string *arg2 = 0 ;
15062	–	BossTask *result = 0 ;
15063	–	void *argp1 = 0 ;
15064	–	int res1 = 0 ;
15065	–	int res2 = SWIG_OLDOBJ ;
15066	–	PyObject * obj0 = 0 ;
15067	–	PyObject * obj1 = 0 ;
15068	–
15069	–	if (!PyArg_ParseTuple(args,(char *)"OO:new_BossTask",&obj0,&obj1)) SWIG_fail;
15070	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossDatabase, 0 |  0 );
15071	–	if (!SWIG_IsOK(res1)) {
15072	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BossTask" "', argument " "1"" of type '" "BossDatabase *""'");
15073	–	}
15074	–	arg1 = reinterpret_cast< BossDatabase * >(argp1);
15075	–	{
15076	–	std::string *ptr = (std::string *)0;
15077	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
15078	–	if (!SWIG_IsOK(res2)) {
15079	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BossTask" "', argument " "2"" of type '" "std::string const &""'");
15080	–	}
15081	–	if (!ptr) {
15082	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BossTask" "', argument " "2"" of type '" "std::string const &""'");
15083	–	}
15084	–	arg2 = ptr;
15085	–	}
15086	–	{
15087	–	try {
15088	–	result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
15089	–	} catch (const std::exception& e) {
15090	–	SWIG_exception(SWIG_RuntimeError, e.what());
15091	–	}
15092	–	}
15093	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, SWIG_POINTER_NEW |  0 );
15094	–	if (SWIG_IsNewObj(res2)) delete arg2;
15095	–	return resultobj;
15096	–	fail:
15097	–	if (SWIG_IsNewObj(res2)) delete arg2;
15098	–	return NULL;
15099	–	}
15100	–
15101	–
15102	–	SWIGINTERN PyObject *_wrap_delete_BossTask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15103	–	PyObject *resultobj = 0;
15104	–	BossTask *arg1 = (BossTask *) 0 ;
15105	–	void *argp1 = 0 ;
15106	–	int res1 = 0 ;
15107	–	PyObject * obj0 = 0 ;
15108	–
15109	–	if (!PyArg_ParseTuple(args,(char *)"O:delete_BossTask",&obj0)) SWIG_fail;
15110	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, SWIG_POINTER_DISOWN |  0 );
15111	–	if (!SWIG_IsOK(res1)) {
15112	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BossTask" "', argument " "1"" of type '" "BossTask *""'");
15113	–	}
15114	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15115	–	{
15116	–	try {
15117	–	delete arg1;
15118	–
15119	–	} catch (const std::exception& e) {
15120	–	SWIG_exception(SWIG_RuntimeError, e.what());
15121	–	}
15122	–	}
15123	–	resultobj = SWIG_Py_Void();
15124	–	return resultobj;
15125	–	fail:
15126	–	return NULL;
15127	–	}
15128	–
15129	–
15130	–	SWIGINTERN PyObject *_wrap_new_BossTask__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15131	–	PyObject *resultobj = 0;
15132	–	BossTask *arg1 = 0 ;
15133	–	BossTask *result = 0 ;
15134	–	void *argp1 = 0 ;
15135	–	int res1 = 0 ;
15136	–	PyObject * obj0 = 0 ;
15137	–
15138	–	if (!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) SWIG_fail;
15139	–	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_BossTask,  0  | 0);
15140	–	if (!SWIG_IsOK(res1)) {
15141	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BossTask" "', argument " "1"" of type '" "BossTask const &""'");
15142	–	}
15143	–	if (!argp1) {
15144	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BossTask" "', argument " "1"" of type '" "BossTask const &""'");
15145	–	}
15146	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15147	–	{
15148	–	try {
15149	–	result = (BossTask *)new BossTask((BossTask const &)*arg1);
15150	–	} catch (const std::exception& e) {
15151	–	SWIG_exception(SWIG_RuntimeError, e.what());
15152	–	}
15153	–	}
15154	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, SWIG_POINTER_NEW |  0 );
15155	–	return resultobj;
15156	–	fail:
15157	–	return NULL;
15158	–	}
15159	–
15160	–
15161	–	SWIGINTERN PyObject *_wrap_new_BossTask(PyObject *self, PyObject *args) {
15162	–	int argc;
15163	–	PyObject *argv[3];
15164	–	int ii;
15165	–
15166	–	if (!PyTuple_Check(args)) SWIG_fail;
15167	–	argc = PyObject_Length(args);
15168	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
15169	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
15170	–	}
15171	–	if (argc == 1) {
15172	–	int _v;
15173	–	void *vptr = 0;
15174	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossDatabase, 0);
15175	–	_v = SWIG_CheckState(res);
15176	–	if (_v) {
15177	–	return _wrap_new_BossTask__SWIG_0(self, args);
15178	–	}
15179	–	}
15180	–	if (argc == 1) {
15181	–	int _v;
15182	–	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_BossTask, 0);
15183	–	_v = SWIG_CheckState(res);
15184	–	if (_v) {
15185	–	return _wrap_new_BossTask__SWIG_2(self, args);
15186	–	}
15187	–	}
15188	–	if (argc == 2) {
15189	–	int _v;
15190	–	void *vptr = 0;
15191	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossDatabase, 0);
15192	–	_v = SWIG_CheckState(res);
15193	–	if (_v) {
15194	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
15195	–	_v = SWIG_CheckState(res);
15196	–	if (_v) {
15197	–	return _wrap_new_BossTask__SWIG_1(self, args);
15198	–	}
15199	–	}
15200	–	}
15201	–
15202	–	fail:
15203	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BossTask'");
15204	–	return NULL;
15205	–	}
15206	–
15207	–
15208	–	SWIGINTERN PyObject *_wrap_BossTask_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15209	–	PyObject *resultobj = 0;
15210	–	BossTask *arg1 = (BossTask *) 0 ;
15211	–	std::string *result = 0 ;
15212	–	void *argp1 = 0 ;
15213	–	int res1 = 0 ;
15214	–	PyObject * obj0 = 0 ;
15215	–
15216	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_id",&obj0)) SWIG_fail;
15217	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15218	–	if (!SWIG_IsOK(res1)) {
15219	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_id" "', argument " "1"" of type '" "BossTask const *""'");
15220	–	}
15221	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15222	–	{
15223	–	try {
15224	–	{
15225	–	std::string const &_result_ref = ((BossTask const *)arg1)->id();
15226	–	result = (std::string *) &_result_ref;
15227	–	}
15228	–	} catch (const std::exception& e) {
15229	–	SWIG_exception(SWIG_RuntimeError, e.what());
15230	–	}
15231	–	}
15232	–	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
15233	–	return resultobj;
15234	–	fail:
15235	–	return NULL;
15236	–	}
15237	–
15238	–
15239	–	SWIGINTERN PyObject *_wrap_BossTask_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15240	–	PyObject *resultobj = 0;
15241	–	BossTask *arg1 = (BossTask *) 0 ;
15242	–	std::string *result = 0 ;
15243	–	void *argp1 = 0 ;
15244	–	int res1 = 0 ;
15245	–	PyObject * obj0 = 0 ;
15246	–
15247	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_name",&obj0)) SWIG_fail;
15248	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15249	–	if (!SWIG_IsOK(res1)) {
15250	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_name" "', argument " "1"" of type '" "BossTask const *""'");
15251	–	}
15252	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15253	–	{
15254	–	try {
15255	–	{
15256	–	std::string const &_result_ref = ((BossTask const *)arg1)->name();
15257	–	result = (std::string *) &_result_ref;
15258	–	}
15259	–	} catch (const std::exception& e) {
15260	–	SWIG_exception(SWIG_RuntimeError, e.what());
15261	–	}
15262	–	}
15263	–	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
15264	–	return resultobj;
15265	–	fail:
15266	–	return NULL;
15267	–	}
15268	–
15269	–
15270	–	SWIGINTERN PyObject *_wrap_BossTask_taskMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15271	–	PyObject *resultobj = 0;
15272	–	BossTask *arg1 = (BossTask *) 0 ;
15273	–	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > result;
15274	–	void *argp1 = 0 ;
15275	–	int res1 = 0 ;
15276	–	PyObject * obj0 = 0 ;
15277	–
15278	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) SWIG_fail;
15279	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15280	–	if (!SWIG_IsOK(res1)) {
15281	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_taskMap" "', argument " "1"" of type '" "BossTask const *""'");
15282	–	}
15283	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15284	–	{
15285	–	try {
15286	–	result = ((BossTask const *)arg1)->taskMap();
15287	–	} catch (const std::exception& e) {
15288	–	SWIG_exception(SWIG_RuntimeError, e.what());
15289	–	}
15290	–	}
15291	–	resultobj = swig::from(static_cast< std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > >(result));
15292	–	return resultobj;
15293	–	fail:
15294	–	return NULL;
15295	–	}
15296	–
15297	–
15298	–	SWIGINTERN PyObject *_wrap_BossTask_job_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15299	–	PyObject *resultobj = 0;
15300	–	BossTask *arg1 = (BossTask *) 0 ;
15301	–	SwigValueWrapper<std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator > result;
15302	–	void *argp1 = 0 ;
15303	–	int res1 = 0 ;
15304	–	PyObject * obj0 = 0 ;
15305	–
15306	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) SWIG_fail;
15307	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15308	–	if (!SWIG_IsOK(res1)) {
15309	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_job_begin" "', argument " "1"" of type '" "BossTask const *""'");
15310	–	}
15311	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15312	–	{
15313	–	try {
15314	–	result = ((BossTask const *)arg1)->job_begin();
15315	–	} catch (const std::exception& e) {
15316	–	SWIG_exception(SWIG_RuntimeError, e.what());
15317	–	}
15318	–	}
15319	–	resultobj = SWIG_NewPointerObj((new BossTask::job_iterator(static_cast< const BossTask::job_iterator& >(result))), SWIGTYPE_p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
15320	–	return resultobj;
15321	–	fail:
15322	–	return NULL;
15323	–	}
15324	–
15325	–
15326	–	SWIGINTERN PyObject *_wrap_BossTask_job_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15327	–	PyObject *resultobj = 0;
15328	–	BossTask *arg1 = (BossTask *) 0 ;
15329	–	SwigValueWrapper<std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator > result;
15330	–	void *argp1 = 0 ;
15331	–	int res1 = 0 ;
15332	–	PyObject * obj0 = 0 ;
15333	–
15334	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) SWIG_fail;
15335	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15336	–	if (!SWIG_IsOK(res1)) {
15337	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_job_end" "', argument " "1"" of type '" "BossTask const *""'");
15338	–	}
15339	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15340	–	{
15341	–	try {
15342	–	result = ((BossTask const *)arg1)->job_end();
15343	–	} catch (const std::exception& e) {
15344	–	SWIG_exception(SWIG_RuntimeError, e.what());
15345	–	}
15346	–	}
15347	–	resultobj = SWIG_NewPointerObj((new BossTask::job_iterator(static_cast< const BossTask::job_iterator& >(result))), SWIGTYPE_p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
15348	–	return resultobj;
15349	–	fail:
15350	–	return NULL;
15351	–	}
15352	–
15353	–
15354	–	SWIGINTERN PyObject *_wrap_BossTask_jobsMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15355	–	PyObject *resultobj = 0;
15356	–	BossTask *arg1 = (BossTask *) 0 ;
15357	–	SwigValueWrapper<std::map<std::string,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >,std::less<std::string >,std::allocator<std::pair<std::string const,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > > > > > result;
15358	–	void *argp1 = 0 ;
15359	–	int res1 = 0 ;
15360	–	PyObject * obj0 = 0 ;
15361	–
15362	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) SWIG_fail;
15363	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15364	–	if (!SWIG_IsOK(res1)) {
15365	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_jobsMap" "', argument " "1"" of type '" "BossTask const *""'");
15366	–	}
15367	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15368	–	{
15369	–	try {
15370	–	result = ((BossTask const *)arg1)->jobsMap();
15371	–	} catch (const std::exception& e) {
15372	–	SWIG_exception(SWIG_RuntimeError, e.what());
15373	–	}
15374	–	}
15375	–	resultobj = SWIG_NewPointerObj((new std::map<std::string,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >,std::less<std::string >,std::allocator<std::pair<std::string const,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > > > >(static_cast< const std::map<std::string,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >,std::less<std::string >,std::allocator<std::pair<std::string const,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > > > >& >(result))), SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
15376	–	return resultobj;
15377	–	fail:
15378	–	return NULL;
15379	–	}
15380	–
15381	–
15382	–	SWIGINTERN PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15383	–	PyObject *resultobj = 0;
15384	–	BossTask *arg1 = (BossTask *) 0 ;
15385	–	SwigValueWrapper<std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator > arg2 ;
15386	–	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > *arg3 = 0 ;
15387	–	std::string result;
15388	–	void *argp1 = 0 ;
15389	–	int res1 = 0 ;
15390	–	void *argp2 ;
15391	–	int res2 = 0 ;
15392	–	void *argp3 = 0 ;
15393	–	int res3 = 0 ;
15394	–	PyObject * obj0 = 0 ;
15395	–	PyObject * obj1 = 0 ;
15396	–	PyObject * obj2 = 0 ;
15397	–
15398	–	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobMap",&obj0,&obj1,&obj2)) SWIG_fail;
15399	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15400	–	if (!SWIG_IsOK(res1)) {
15401	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_jobMap" "', argument " "1"" of type '" "BossTask const *""'");
15402	–	}
15403	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15404	–	{
15405	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator,  0  | 0);
15406	–	if (!SWIG_IsOK(res2)) {
15407	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_jobMap" "', argument " "2"" of type '" "std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator""'");
15408	–	}
15409	–	if (!argp2) {
15410	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_jobMap" "', argument " "2"" of type '" "std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator""'");
15411	–	} else {
15412	–	std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator * temp = reinterpret_cast< std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator * >(argp2);
15413	–	arg2 = *temp;
15414	–	if (SWIG_IsNewObj(res2)) delete temp;
15415	–	}
15416	–	}
15417	–	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t,  0 );
15418	–	if (!SWIG_IsOK(res3)) {
15419	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_jobMap" "', argument " "3"" of type '" "std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > &""'");
15420	–	}
15421	–	if (!argp3) {
15422	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_jobMap" "', argument " "3"" of type '" "std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > &""'");
15423	–	}
15424	–	arg3 = reinterpret_cast< std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > * >(argp3);
15425	–	{
15426	–	try {
15427	–	result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
15428	–	} catch (const std::exception& e) {
15429	–	SWIG_exception(SWIG_RuntimeError, e.what());
15430	–	}
15431	–	}
15432	–	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
15433	–	return resultobj;
15434	–	fail:
15435	–	return NULL;
15436	–	}
15437	–
15438	–
15439	–	SWIGINTERN PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15440	–	PyObject *resultobj = 0;
15441	–	BossTask *arg1 = (BossTask *) 0 ;
15442	–	unsigned int arg2 ;
15443	–	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > result;
15444	–	void *argp1 = 0 ;
15445	–	int res1 = 0 ;
15446	–	unsigned int val2 ;
15447	–	int ecode2 = 0 ;
15448	–	PyObject * obj0 = 0 ;
15449	–	PyObject * obj1 = 0 ;
15450	–
15451	–	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) SWIG_fail;
15452	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15453	–	if (!SWIG_IsOK(res1)) {
15454	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_jobMap" "', argument " "1"" of type '" "BossTask const *""'");
15455	–	}
15456	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15457	–	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
15458	–	if (!SWIG_IsOK(ecode2)) {
15459	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_jobMap" "', argument " "2"" of type '" "unsigned int""'");
15460	–	}
15461	–	arg2 = static_cast< unsigned int >(val2);
15462	–	{
15463	–	try {
15464	–	result = ((BossTask const *)arg1)->jobMap(arg2);
15465	–	} catch (const std::exception& e) {
15466	–	SWIG_exception(SWIG_RuntimeError, e.what());
4289		}
4290	<	}
4291	<	resultobj = swig::from(static_cast< std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > >(result));
4292	<	return resultobj;
15471	<	fail:
15472	<	return NULL;
4290	>
4291	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobMap'");
4292	>	return NULL;
4293		}
4294
4295
4296	<	SWIGINTERN PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4297	<	int argc;
4298	<	PyObject *argv[4];
4299	<	int ii;
4300	<
4301	<	if (!PyTuple_Check(args)) SWIG_fail;
4302	<	argc = PyObject_Length(args);
4303	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4304	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4305	<	}
4306	<	if (argc == 2) {
4307	<	int _v;
4308	<	void *vptr = 0;
4309	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4310	<	_v = SWIG_CheckState(res);
4311	<	if (_v) {
4312	<	{
4313	<	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
4314	<	_v = SWIG_CheckState(res);
4315	<	}
4316	<	if (_v) {
15497	<	return _wrap_BossTask_jobMap__SWIG_1(self, args);
15498	<	}
15499	<	}
15500	<	}
15501	<	if (argc == 3) {
15502	<	int _v;
15503	<	void *vptr = 0;
15504	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15505	<	_v = SWIG_CheckState(res);
15506	<	if (_v) {
15507	<	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator, 0);
15508	<	_v = SWIG_CheckState(res);
15509	<	if (_v) {
15510	<	void *vptr = 0;
15511	<	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0);
15512	<	_v = SWIG_CheckState(res);
15513	<	if (_v) {
15514	<	return _wrap_BossTask_jobMap__SWIG_0(self, args);
4296	>	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4297	>	PyObject *resultobj;
4298	>	BossTask *arg1 = (BossTask *) 0 ;
4299	>	BossJob *arg2 = (BossJob *) 0 ;
4300	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4301	>	PyObject * obj0 = 0 ;
4302	>	PyObject * obj1 = 0 ;
4303	>
4304	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4305	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4306	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4307	>	{
4308	>	try {
4309	>	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4310	>
4311	>	}catch (const BossSchedFailure & e) {
4312	>	PyErr_SetString ( SchedulerError, e.what() );
4313	>	return NULL;
4314	>	}catch (const std::exception& e) {
4315	>	PyErr_SetString ( BossError, e.what() );
4316	>	return NULL;
4317		}
15516	–	}
4318		}
4319	<	}
4320	<
4321	<	fail:
4322	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_jobMap'");
15522	<	return NULL;
15523	<	}
15524	<
15525	<
15526	<	SWIGINTERN PyObject *_wrap_BossTask_programsMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15527	<	PyObject *resultobj = 0;
15528	<	BossTask *arg1 = (BossTask *) 0 ;
15529	<	BossJob *arg2 = (BossJob *) 0 ;
15530	<	SwigValueWrapper<std::map<std::string,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >,std::less<std::string >,std::allocator<std::pair<std::string const,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > > > > > result;
15531	<	void *argp1 = 0 ;
15532	<	int res1 = 0 ;
15533	<	void *argp2 = 0 ;
15534	<	int res2 = 0 ;
15535	<	PyObject * obj0 = 0 ;
15536	<	PyObject * obj1 = 0 ;
15537	<
15538	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) SWIG_fail;
15539	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15540	<	if (!SWIG_IsOK(res1)) {
15541	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_programsMap" "', argument " "1"" of type '" "BossTask const *""'");
15542	<	}
15543	<	arg1 = reinterpret_cast< BossTask * >(argp1);
15544	<	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_BossJob, 0 |  0 );
15545	<	if (!SWIG_IsOK(res2)) {
15546	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_programsMap" "', argument " "2"" of type '" "BossJob const *""'");
15547	<	}
15548	<	arg2 = reinterpret_cast< BossJob * >(argp2);
15549	<	{
15550	<	try {
15551	<	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
15552	<	} catch (const std::exception& e) {
15553	<	SWIG_exception(SWIG_RuntimeError, e.what());
15554	<	}
15555	<	}
15556	<	resultobj = SWIG_NewPointerObj((new std::map<std::string,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >,std::less<std::string >,std::allocator<std::pair<std::string const,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > > > >(static_cast< const std::map<std::string,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >,std::less<std::string >,std::allocator<std::pair<std::string const,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > > > >& >(result))), SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
15557	<	return resultobj;
15558	<	fail:
15559	<	return NULL;
15560	<	}
15561	<
15562	<
15563	<	SWIGINTERN PyObject *_wrap_BossTask_queryJobPrograms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15564	<	PyObject *resultobj = 0;
15565	<	BossTask *arg1 = (BossTask *) 0 ;
15566	<	BossJob *arg2 = (BossJob *) 0 ;
15567	<	SwigValueWrapper<std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > > > result;
15568	<	void *argp1 = 0 ;
15569	<	int res1 = 0 ;
15570	<	void *argp2 = 0 ;
15571	<	int res2 = 0 ;
15572	<	PyObject * obj0 = 0 ;
15573	<	PyObject * obj1 = 0 ;
15574	<
15575	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) SWIG_fail;
15576	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15577	<	if (!SWIG_IsOK(res1)) {
15578	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_queryJobPrograms" "', argument " "1"" of type '" "BossTask const *""'");
15579	<	}
15580	<	arg1 = reinterpret_cast< BossTask * >(argp1);
15581	<	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_BossJob, 0 |  0 );
15582	<	if (!SWIG_IsOK(res2)) {
15583	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_queryJobPrograms" "', argument " "2"" of type '" "BossJob const *""'");
15584	<	}
15585	<	arg2 = reinterpret_cast< BossJob * >(argp2);
15586	<	{
15587	<	try {
15588	<	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
15589	<	} catch (const std::exception& e) {
15590	<	SWIG_exception(SWIG_RuntimeError, e.what());
15591	<	}
15592	<	}
15593	<	resultobj = SWIG_NewPointerObj((new std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >(static_cast< const std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >& >(result))), SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t, SWIG_POINTER_OWN |  0 );
15594	<	return resultobj;
15595	<	fail:
15596	<	return NULL;
15597	<	}
15598	<
15599	<
15600	<	SWIGINTERN PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15601	<	PyObject *resultobj = 0;
15602	<	BossTask *arg1 = (BossTask *) 0 ;
15603	<	std::string *arg2 = 0 ;
15604	<	std::string *arg3 = 0 ;
15605	<	void *argp1 = 0 ;
15606	<	int res1 = 0 ;
15607	<	int res2 = SWIG_OLDOBJ ;
15608	<	int res3 = SWIG_OLDOBJ ;
15609	<	PyObject * obj0 = 0 ;
15610	<	PyObject * obj1 = 0 ;
15611	<	PyObject * obj2 = 0 ;
15612	<
15613	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_declare",&obj0,&obj1,&obj2)) SWIG_fail;
15614	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15615	<	if (!SWIG_IsOK(res1)) {
15616	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_declare" "', argument " "1"" of type '" "BossTask *""'");
15617	<	}
15618	<	arg1 = reinterpret_cast< BossTask * >(argp1);
15619	<	{
15620	<	std::string *ptr = (std::string *)0;
15621	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
15622	<	if (!SWIG_IsOK(res2)) {
15623	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_declare" "', argument " "2"" of type '" "std::string const &""'");
15624	<	}
15625	<	if (!ptr) {
15626	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_declare" "', argument " "2"" of type '" "std::string const &""'");
15627	<	}
15628	<	arg2 = ptr;
15629	<	}
15630	<	{
15631	<	std::string *ptr = (std::string *)0;
15632	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
15633	<	if (!SWIG_IsOK(res3)) {
15634	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_declare" "', argument " "3"" of type '" "std::string const &""'");
15635	<	}
15636	<	if (!ptr) {
15637	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_declare" "', argument " "3"" of type '" "std::string const &""'");
15638	<	}
15639	<	arg3 = ptr;
15640	<	}
15641	<	{
15642	<	try {
15643	<	(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
15644	<	} catch (const std::exception& e) {
15645	<	SWIG_exception(SWIG_RuntimeError, e.what());
15646	<	}
15647	<	}
15648	<	resultobj = SWIG_Py_Void();
15649	<	if (SWIG_IsNewObj(res2)) delete arg2;
15650	<	if (SWIG_IsNewObj(res3)) delete arg3;
15651	<	return resultobj;
15652	<	fail:
15653	<	if (SWIG_IsNewObj(res2)) delete arg2;
15654	<	if (SWIG_IsNewObj(res3)) delete arg3;
15655	<	return NULL;
15656	<	}
15657	<
15658	<
15659	<	SWIGINTERN PyObject *_wrap_BossTask_declare__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15660	<	PyObject *resultobj = 0;
15661	<	BossTask *arg1 = (BossTask *) 0 ;
15662	<	std::string *arg2 = 0 ;
15663	<	void *argp1 = 0 ;
15664	<	int res1 = 0 ;
15665	<	int res2 = SWIG_OLDOBJ ;
15666	<	PyObject * obj0 = 0 ;
15667	<	PyObject * obj1 = 0 ;
15668	<
15669	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_declare",&obj0,&obj1)) SWIG_fail;
15670	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15671	<	if (!SWIG_IsOK(res1)) {
15672	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_declare" "', argument " "1"" of type '" "BossTask *""'");
15673	<	}
15674	<	arg1 = reinterpret_cast< BossTask * >(argp1);
15675	<	{
15676	<	std::string *ptr = (std::string *)0;
15677	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
15678	<	if (!SWIG_IsOK(res2)) {
15679	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_declare" "', argument " "2"" of type '" "std::string const &""'");
15680	<	}
15681	<	if (!ptr) {
15682	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_declare" "', argument " "2"" of type '" "std::string const &""'");
15683	<	}
15684	<	arg2 = ptr;
15685	<	}
15686	<	{
15687	<	try {
15688	<	(arg1)->declare((std::string const &)*arg2);
15689	<	} catch (const std::exception& e) {
15690	<	SWIG_exception(SWIG_RuntimeError, e.what());
4319	>	{
4320	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4321	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4322	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4323		}
4324	<	}
4325	<	resultobj = SWIG_Py_Void();
4326	<	if (SWIG_IsNewObj(res2)) delete arg2;
15695	<	return resultobj;
15696	<	fail:
15697	<	if (SWIG_IsNewObj(res2)) delete arg2;
15698	<	return NULL;
4324	>	return resultobj;
4325	>	fail:
4326	>	return NULL;
4327		}
4328
4329
4330	<	SWIGINTERN PyObject *_wrap_BossTask_declare__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4331	<	PyObject *resultobj = 0;
4332	<	BossTask *arg1 = (BossTask *) 0 ;
4333	<	XMLDoc *arg2 = (XMLDoc *) 0 ;
4334	<	std::string *arg3 = 0 ;
4335	<	void *argp1 = 0 ;
4336	<	int res1 = 0 ;
4337	<	void *argp2 = 0 ;
4338	<	int res2 = 0 ;
4339	<	int res3 = SWIG_OLDOBJ ;
4340	<	PyObject * obj0 = 0 ;
4341	<	PyObject * obj1 = 0 ;
4342	<	PyObject * obj2 = 0 ;
4343	<
4344	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_declare",&obj0,&obj1,&obj2)) SWIG_fail;
4345	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4346	<	if (!SWIG_IsOK(res1)) {
4347	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_declare" "', argument " "1"" of type '" "BossTask *""'");
4348	<	}
4349	<	arg1 = reinterpret_cast< BossTask * >(argp1);
4350	<	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XMLDoc, 0 |  0 );
4351	<	if (!SWIG_IsOK(res2)) {
15724	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_declare" "', argument " "2"" of type '" "XMLDoc *""'");
15725	<	}
15726	<	arg2 = reinterpret_cast< XMLDoc * >(argp2);
15727	<	{
15728	<	std::string *ptr = (std::string *)0;
15729	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
15730	<	if (!SWIG_IsOK(res3)) {
15731	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_declare" "', argument " "3"" of type '" "std::string const &""'");
15732	<	}
15733	<	if (!ptr) {
15734	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_declare" "', argument " "3"" of type '" "std::string const &""'");
15735	<	}
15736	<	arg3 = ptr;
15737	<	}
15738	<	{
15739	<	try {
15740	<	(arg1)->declare(arg2,(std::string const &)*arg3);
15741	<	} catch (const std::exception& e) {
15742	<	SWIG_exception(SWIG_RuntimeError, e.what());
4330	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4331	>	PyObject *resultobj;
4332	>	BossTask *arg1 = (BossTask *) 0 ;
4333	>	BossJob *arg2 = (BossJob *) 0 ;
4334	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4335	>	PyObject * obj0 = 0 ;
4336	>	PyObject * obj1 = 0 ;
4337	>
4338	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4339	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4340	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4341	>	{
4342	>	try {
4343	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4344	>
4345	>	}catch (const BossSchedFailure & e) {
4346	>	PyErr_SetString ( SchedulerError, e.what() );
4347	>	return NULL;
4348	>	}catch (const std::exception& e) {
4349	>	PyErr_SetString ( BossError, e.what() );
4350	>	return NULL;
4351	>	}
4352		}
4353	<	}
4354	<	resultobj = SWIG_Py_Void();
4355	<	if (SWIG_IsNewObj(res3)) delete arg3;
4356	<	return resultobj;
15748	<	fail:
15749	<	if (SWIG_IsNewObj(res3)) delete arg3;
15750	<	return NULL;
15751	<	}
15752	<
15753	<
15754	<	SWIGINTERN PyObject *_wrap_BossTask_declare__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15755	<	PyObject *resultobj = 0;
15756	<	BossTask *arg1 = (BossTask *) 0 ;
15757	<	XMLDoc *arg2 = (XMLDoc *) 0 ;
15758	<	void *argp1 = 0 ;
15759	<	int res1 = 0 ;
15760	<	void *argp2 = 0 ;
15761	<	int res2 = 0 ;
15762	<	PyObject * obj0 = 0 ;
15763	<	PyObject * obj1 = 0 ;
15764	<
15765	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_declare",&obj0,&obj1)) SWIG_fail;
15766	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15767	<	if (!SWIG_IsOK(res1)) {
15768	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_declare" "', argument " "1"" of type '" "BossTask *""'");
15769	<	}
15770	<	arg1 = reinterpret_cast< BossTask * >(argp1);
15771	<	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XMLDoc, 0 |  0 );
15772	<	if (!SWIG_IsOK(res2)) {
15773	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_declare" "', argument " "2"" of type '" "XMLDoc *""'");
15774	<	}
15775	<	arg2 = reinterpret_cast< XMLDoc * >(argp2);
15776	<	{
15777	<	try {
15778	<	(arg1)->declare(arg2);
15779	<	} catch (const std::exception& e) {
15780	<	SWIG_exception(SWIG_RuntimeError, e.what());
4353	>	{
4354	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4355	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4356	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4357		}
4358	<	}
4359	<	resultobj = SWIG_Py_Void();
4360	<	return resultobj;
15785	<	fail:
15786	<	return NULL;
4358	>	return resultobj;
4359	>	fail:
4360	>	return NULL;
4361		}
4362
4363
4364	<	SWIGINTERN PyObject *_wrap_BossTask_declare(PyObject *self, PyObject *args) {
4365	<	int argc;
4366	<	PyObject *argv[4];
4367	<	int ii;
4368	<
4369	<	if (!PyTuple_Check(args)) SWIG_fail;
4370	<	argc = PyObject_Length(args);
4371	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4372	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4373	<	}
4374	<	if (argc == 2) {
4375	<	int _v;
4376	<	void *vptr = 0;
4377	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4378	<	_v = SWIG_CheckState(res);
4379	<	if (_v) {
4380	<	void *vptr = 0;
4381	<	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLDoc, 0);
4382	<	_v = SWIG_CheckState(res);
4383	<	if (_v) {
15810	<	return _wrap_BossTask_declare__SWIG_3(self, args);
15811	<	}
15812	<	}
15813	<	}
15814	<	if (argc == 2) {
15815	<	int _v;
15816	<	void *vptr = 0;
15817	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15818	<	_v = SWIG_CheckState(res);
15819	<	if (_v) {
15820	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
15821	<	_v = SWIG_CheckState(res);
15822	<	if (_v) {
15823	<	return _wrap_BossTask_declare__SWIG_1(self, args);
15824	<	}
15825	<	}
15826	<	}
15827	<	if (argc == 3) {
15828	<	int _v;
15829	<	void *vptr = 0;
15830	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15831	<	_v = SWIG_CheckState(res);
15832	<	if (_v) {
15833	<	void *vptr = 0;
15834	<	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLDoc, 0);
15835	<	_v = SWIG_CheckState(res);
15836	<	if (_v) {
15837	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
15838	<	_v = SWIG_CheckState(res);
15839	<	if (_v) {
15840	<	return _wrap_BossTask_declare__SWIG_2(self, args);
4364	>	static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4365	>	PyObject *resultobj;
4366	>	BossTask *arg1 = (BossTask *) 0 ;
4367	>	std::string *arg2 = 0 ;
4368	>	std::string const &arg3_defvalue = "" ;
4369	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4370	>	std::string temp2 ;
4371	>	std::string temp3 ;
4372	>	PyObject * obj0 = 0 ;
4373	>	PyObject * obj1 = 0 ;
4374	>	PyObject * obj2 = 0 ;
4375	>
4376	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
4377	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4378	>	{
4379	>	if (PyString_Check(obj1)) {
4380	>	temp2 = std::string(PyString_AsString(obj1));
4381	>	arg2 = &temp2;
4382	>	}else {
4383	>	SWIG_exception(SWIG_TypeError, "string expected");
4384		}
15842	–	}
4385		}
4386	<	}
4387	<	if (argc == 3) {
4388	<	int _v;
4389	<	void *vptr = 0;
4390	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4391	<	_v = SWIG_CheckState(res);
4392	<	if (_v) {
4393	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
15852	<	_v = SWIG_CheckState(res);
15853	<	if (_v) {
15854	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
15855	<	_v = SWIG_CheckState(res);
15856	<	if (_v) {
15857	<	return _wrap_BossTask_declare__SWIG_0(self, args);
4386	>	if (obj2) {
4387	>	{
4388	>	if (PyString_Check(obj2)) {
4389	>	temp3 = std::string(PyString_AsString(obj2));
4390	>	arg3 = &temp3;
4391	>	}else {
4392	>	SWIG_exception(SWIG_TypeError, "string expected");
4393	>	}
4394		}
15859	–	}
15860	–	}
15861	–	}
15862	–
15863	–	fail:
15864	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_declare'");
15865	–	return NULL;
15866	–	}
15867	–
15868	–
15869	–	SWIGINTERN PyObject *_wrap_BossTask_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15870	–	PyObject *resultobj = 0;
15871	–	BossTask *arg1 = (BossTask *) 0 ;
15872	–	void *argp1 = 0 ;
15873	–	int res1 = 0 ;
15874	–	PyObject * obj0 = 0 ;
15875	–
15876	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_remove",&obj0)) SWIG_fail;
15877	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15878	–	if (!SWIG_IsOK(res1)) {
15879	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_remove" "', argument " "1"" of type '" "BossTask *""'");
15880	–	}
15881	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15882	–	{
15883	–	try {
15884	–	(arg1)->remove();
15885	–	} catch (const std::exception& e) {
15886	–	SWIG_exception(SWIG_RuntimeError, e.what());
15887	–	}
15888	–	}
15889	–	resultobj = SWIG_Py_Void();
15890	–	return resultobj;
15891	–	fail:
15892	–	return NULL;
15893	–	}
15894	–
15895	–
15896	–	SWIGINTERN PyObject *_wrap_BossTask_archive__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15897	–	PyObject *resultobj = 0;
15898	–	BossTask *arg1 = (BossTask *) 0 ;
15899	–	std::string *arg2 = 0 ;
15900	–	void *argp1 = 0 ;
15901	–	int res1 = 0 ;
15902	–	int res2 = SWIG_OLDOBJ ;
15903	–	PyObject * obj0 = 0 ;
15904	–	PyObject * obj1 = 0 ;
15905	–
15906	–	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_archive",&obj0,&obj1)) SWIG_fail;
15907	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15908	–	if (!SWIG_IsOK(res1)) {
15909	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_archive" "', argument " "1"" of type '" "BossTask *""'");
15910	–	}
15911	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15912	–	{
15913	–	std::string *ptr = (std::string *)0;
15914	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
15915	–	if (!SWIG_IsOK(res2)) {
15916	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_archive" "', argument " "2"" of type '" "std::string const &""'");
15917	–	}
15918	–	if (!ptr) {
15919	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_archive" "', argument " "2"" of type '" "std::string const &""'");
15920	–	}
15921	–	arg2 = ptr;
15922	–	}
15923	–	{
15924	–	try {
15925	–	(arg1)->archive((std::string const &)*arg2);
15926	–	} catch (const std::exception& e) {
15927	–	SWIG_exception(SWIG_RuntimeError, e.what());
15928	–	}
15929	–	}
15930	–	resultobj = SWIG_Py_Void();
15931	–	if (SWIG_IsNewObj(res2)) delete arg2;
15932	–	return resultobj;
15933	–	fail:
15934	–	if (SWIG_IsNewObj(res2)) delete arg2;
15935	–	return NULL;
15936	–	}
15937	–
15938	–
15939	–	SWIGINTERN PyObject *_wrap_BossTask_archive__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15940	–	PyObject *resultobj = 0;
15941	–	BossTask *arg1 = (BossTask *) 0 ;
15942	–	void *argp1 = 0 ;
15943	–	int res1 = 0 ;
15944	–	PyObject * obj0 = 0 ;
15945	–
15946	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_archive",&obj0)) SWIG_fail;
15947	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15948	–	if (!SWIG_IsOK(res1)) {
15949	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_archive" "', argument " "1"" of type '" "BossTask *""'");
15950	–	}
15951	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15952	–	{
15953	–	try {
15954	–	(arg1)->archive();
15955	–	} catch (const std::exception& e) {
15956	–	SWIG_exception(SWIG_RuntimeError, e.what());
15957	–	}
15958	–	}
15959	–	resultobj = SWIG_Py_Void();
15960	–	return resultobj;
15961	–	fail:
15962	–	return NULL;
15963	–	}
15964	–
15965	–
15966	–	SWIGINTERN PyObject *_wrap_BossTask_archive(PyObject *self, PyObject *args) {
15967	–	int argc;
15968	–	PyObject *argv[3];
15969	–	int ii;
15970	–
15971	–	if (!PyTuple_Check(args)) SWIG_fail;
15972	–	argc = PyObject_Length(args);
15973	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
15974	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
15975	–	}
15976	–	if (argc == 1) {
15977	–	int _v;
15978	–	void *vptr = 0;
15979	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15980	–	_v = SWIG_CheckState(res);
15981	–	if (_v) {
15982	–	return _wrap_BossTask_archive__SWIG_1(self, args);
15983	–	}
15984	–	}
15985	–	if (argc == 2) {
15986	–	int _v;
15987	–	void *vptr = 0;
15988	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15989	–	_v = SWIG_CheckState(res);
15990	–	if (_v) {
15991	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
15992	–	_v = SWIG_CheckState(res);
15993	–	if (_v) {
15994	–	return _wrap_BossTask_archive__SWIG_0(self, args);
15995	–	}
15996	–	}
15997	–	}
15998	–
15999	–	fail:
16000	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_archive'");
16001	–	return NULL;
16002	–	}
16003	–
16004	–
16005	–	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16006	–	PyObject *resultobj = 0;
16007	–	BossTask *arg1 = (BossTask *) 0 ;
16008	–	std::string *arg2 = 0 ;
16009	–	std::string *arg3 = 0 ;
16010	–	std::string *arg4 = 0 ;
16011	–	std::string *arg5 = 0 ;
16012	–	std::string *arg6 = 0 ;
16013	–	bool arg7 ;
16014	–	int result;
16015	–	void *argp1 = 0 ;
16016	–	int res1 = 0 ;
16017	–	int res2 = SWIG_OLDOBJ ;
16018	–	int res3 = SWIG_OLDOBJ ;
16019	–	int res4 = SWIG_OLDOBJ ;
16020	–	int res5 = SWIG_OLDOBJ ;
16021	–	int res6 = SWIG_OLDOBJ ;
16022	–	bool val7 ;
16023	–	int ecode7 = 0 ;
16024	–	PyObject * obj0 = 0 ;
16025	–	PyObject * obj1 = 0 ;
16026	–	PyObject * obj2 = 0 ;
16027	–	PyObject * obj3 = 0 ;
16028	–	PyObject * obj4 = 0 ;
16029	–	PyObject * obj5 = 0 ;
16030	–	PyObject * obj6 = 0 ;
16031	–
16032	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16033	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16034	–	if (!SWIG_IsOK(res1)) {
16035	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
16036	–	}
16037	–	arg1 = reinterpret_cast< BossTask * >(argp1);
16038	–	{
16039	–	std::string *ptr = (std::string *)0;
16040	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16041	–	if (!SWIG_IsOK(res2)) {
16042	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16043	–	}
16044	–	if (!ptr) {
16045	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16046	–	}
16047	–	arg2 = ptr;
16048	–	}
16049	–	{
16050	–	std::string *ptr = (std::string *)0;
16051	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
16052	–	if (!SWIG_IsOK(res3)) {
16053	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16054	–	}
16055	–	if (!ptr) {
16056	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16057	–	}
16058	–	arg3 = ptr;
16059	–	}
16060	–	{
16061	–	std::string *ptr = (std::string *)0;
16062	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
16063	–	if (!SWIG_IsOK(res4)) {
16064	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16065	–	}
16066	–	if (!ptr) {
16067	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16068	–	}
16069	–	arg4 = ptr;
16070	–	}
16071	–	{
16072	–	std::string *ptr = (std::string *)0;
16073	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
16074	–	if (!SWIG_IsOK(res5)) {
16075	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
16076	–	}
16077	–	if (!ptr) {
16078	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
16079	–	}
16080	–	arg5 = ptr;
16081	–	}
16082	–	{
16083	–	std::string *ptr = (std::string *)0;
16084	–	res6 = SWIG_AsPtr_std_string(obj5, &ptr);
16085	–	if (!SWIG_IsOK(res6)) {
16086	–	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BossTask_submit" "', argument " "6"" of type '" "std::string const &""'");
16087	–	}
16088	–	if (!ptr) {
16089	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "6"" of type '" "std::string const &""'");
16090	–	}
16091	–	arg6 = ptr;
16092	–	}
16093	–	ecode7 = SWIG_AsVal_bool(obj6, &val7);
16094	–	if (!SWIG_IsOK(ecode7)) {
16095	–	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BossTask_submit" "', argument " "7"" of type '" "bool""'");
16096	–	}
16097	–	arg7 = static_cast< bool >(val7);
16098	–	{
16099	–	try {
16100	–	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);
16101	–	} catch (const std::exception& e) {
16102	–	SWIG_exception(SWIG_RuntimeError, e.what());
16103	–	}
16104	–	}
16105	–	resultobj = SWIG_From_int(static_cast< int >(result));
16106	–	if (SWIG_IsNewObj(res2)) delete arg2;
16107	–	if (SWIG_IsNewObj(res3)) delete arg3;
16108	–	if (SWIG_IsNewObj(res4)) delete arg4;
16109	–	if (SWIG_IsNewObj(res5)) delete arg5;
16110	–	if (SWIG_IsNewObj(res6)) delete arg6;
16111	–	return resultobj;
16112	–	fail:
16113	–	if (SWIG_IsNewObj(res2)) delete arg2;
16114	–	if (SWIG_IsNewObj(res3)) delete arg3;
16115	–	if (SWIG_IsNewObj(res4)) delete arg4;
16116	–	if (SWIG_IsNewObj(res5)) delete arg5;
16117	–	if (SWIG_IsNewObj(res6)) delete arg6;
16118	–	return NULL;
16119	–	}
16120	–
16121	–
16122	–	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16123	–	PyObject *resultobj = 0;
16124	–	BossTask *arg1 = (BossTask *) 0 ;
16125	–	std::string *arg2 = 0 ;
16126	–	std::string *arg3 = 0 ;
16127	–	std::string *arg4 = 0 ;
16128	–	std::string *arg5 = 0 ;
16129	–	std::string *arg6 = 0 ;
16130	–	int result;
16131	–	void *argp1 = 0 ;
16132	–	int res1 = 0 ;
16133	–	int res2 = SWIG_OLDOBJ ;
16134	–	int res3 = SWIG_OLDOBJ ;
16135	–	int res4 = SWIG_OLDOBJ ;
16136	–	int res5 = SWIG_OLDOBJ ;
16137	–	int res6 = SWIG_OLDOBJ ;
16138	–	PyObject * obj0 = 0 ;
16139	–	PyObject * obj1 = 0 ;
16140	–	PyObject * obj2 = 0 ;
16141	–	PyObject * obj3 = 0 ;
16142	–	PyObject * obj4 = 0 ;
16143	–	PyObject * obj5 = 0 ;
16144	–
16145	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16146	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16147	–	if (!SWIG_IsOK(res1)) {
16148	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
16149	–	}
16150	–	arg1 = reinterpret_cast< BossTask * >(argp1);
16151	–	{
16152	–	std::string *ptr = (std::string *)0;
16153	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16154	–	if (!SWIG_IsOK(res2)) {
16155	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16156	–	}
16157	–	if (!ptr) {
16158	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16159	–	}
16160	–	arg2 = ptr;
16161	–	}
16162	–	{
16163	–	std::string *ptr = (std::string *)0;
16164	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
16165	–	if (!SWIG_IsOK(res3)) {
16166	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16167	–	}
16168	–	if (!ptr) {
16169	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16170	–	}
16171	–	arg3 = ptr;
16172	–	}
16173	–	{
16174	–	std::string *ptr = (std::string *)0;
16175	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
16176	–	if (!SWIG_IsOK(res4)) {
16177	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16178	–	}
16179	–	if (!ptr) {
16180	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16181	–	}
16182	–	arg4 = ptr;
16183	–	}
16184	–	{
16185	–	std::string *ptr = (std::string *)0;
16186	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
16187	–	if (!SWIG_IsOK(res5)) {
16188	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
16189	–	}
16190	–	if (!ptr) {
16191	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
4395		}
4396	<	arg5 = ptr;
4397	<	}
4398	<	{
4399	<	std::string *ptr = (std::string *)0;
4400	<	res6 = SWIG_AsPtr_std_string(obj5, &ptr);
4401	<	if (!SWIG_IsOK(res6)) {
4402	<	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BossTask_submit" "', argument " "6"" of type '" "std::string const &""'");
4403	<	}
4404	<	if (!ptr) {
4405	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "6"" of type '" "std::string const &""'");
4406	<	}
16204	<	arg6 = ptr;
16205	<	}
16206	<	{
16207	<	try {
16208	<	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6);
16209	<	} catch (const std::exception& e) {
16210	<	SWIG_exception(SWIG_RuntimeError, e.what());
16211	<	}
16212	<	}
16213	<	resultobj = SWIG_From_int(static_cast< int >(result));
16214	<	if (SWIG_IsNewObj(res2)) delete arg2;
16215	<	if (SWIG_IsNewObj(res3)) delete arg3;
16216	<	if (SWIG_IsNewObj(res4)) delete arg4;
16217	<	if (SWIG_IsNewObj(res5)) delete arg5;
16218	<	if (SWIG_IsNewObj(res6)) delete arg6;
16219	<	return resultobj;
16220	<	fail:
16221	<	if (SWIG_IsNewObj(res2)) delete arg2;
16222	<	if (SWIG_IsNewObj(res3)) delete arg3;
16223	<	if (SWIG_IsNewObj(res4)) delete arg4;
16224	<	if (SWIG_IsNewObj(res5)) delete arg5;
16225	<	if (SWIG_IsNewObj(res6)) delete arg6;
16226	<	return NULL;
16227	<	}
16228	<
16229	<
16230	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16231	<	PyObject *resultobj = 0;
16232	<	BossTask *arg1 = (BossTask *) 0 ;
16233	<	std::string *arg2 = 0 ;
16234	<	std::string *arg3 = 0 ;
16235	<	std::string *arg4 = 0 ;
16236	<	std::string *arg5 = 0 ;
16237	<	int result;
16238	<	void *argp1 = 0 ;
16239	<	int res1 = 0 ;
16240	<	int res2 = SWIG_OLDOBJ ;
16241	<	int res3 = SWIG_OLDOBJ ;
16242	<	int res4 = SWIG_OLDOBJ ;
16243	<	int res5 = SWIG_OLDOBJ ;
16244	<	PyObject * obj0 = 0 ;
16245	<	PyObject * obj1 = 0 ;
16246	<	PyObject * obj2 = 0 ;
16247	<	PyObject * obj3 = 0 ;
16248	<	PyObject * obj4 = 0 ;
16249	<
16250	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16251	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16252	<	if (!SWIG_IsOK(res1)) {
16253	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
16254	<	}
16255	<	arg1 = reinterpret_cast< BossTask * >(argp1);
16256	<	{
16257	<	std::string *ptr = (std::string *)0;
16258	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16259	<	if (!SWIG_IsOK(res2)) {
16260	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16261	<	}
16262	<	if (!ptr) {
16263	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16264	<	}
16265	<	arg2 = ptr;
16266	<	}
16267	<	{
16268	<	std::string *ptr = (std::string *)0;
16269	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
16270	<	if (!SWIG_IsOK(res3)) {
16271	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16272	<	}
16273	<	if (!ptr) {
16274	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16275	<	}
16276	<	arg3 = ptr;
16277	<	}
16278	<	{
16279	<	std::string *ptr = (std::string *)0;
16280	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
16281	<	if (!SWIG_IsOK(res4)) {
16282	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16283	<	}
16284	<	if (!ptr) {
16285	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16286	<	}
16287	<	arg4 = ptr;
16288	<	}
16289	<	{
16290	<	std::string *ptr = (std::string *)0;
16291	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
16292	<	if (!SWIG_IsOK(res5)) {
16293	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
16294	<	}
16295	<	if (!ptr) {
16296	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
16297	<	}
16298	<	arg5 = ptr;
16299	<	}
16300	<	{
16301	<	try {
16302	<	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
16303	<	} catch (const std::exception& e) {
16304	<	SWIG_exception(SWIG_RuntimeError, e.what());
16305	<	}
16306	<	}
16307	<	resultobj = SWIG_From_int(static_cast< int >(result));
16308	<	if (SWIG_IsNewObj(res2)) delete arg2;
16309	<	if (SWIG_IsNewObj(res3)) delete arg3;
16310	<	if (SWIG_IsNewObj(res4)) delete arg4;
16311	<	if (SWIG_IsNewObj(res5)) delete arg5;
16312	<	return resultobj;
16313	<	fail:
16314	<	if (SWIG_IsNewObj(res2)) delete arg2;
16315	<	if (SWIG_IsNewObj(res3)) delete arg3;
16316	<	if (SWIG_IsNewObj(res4)) delete arg4;
16317	<	if (SWIG_IsNewObj(res5)) delete arg5;
16318	<	return NULL;
16319	<	}
16320	<
16321	<
16322	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16323	<	PyObject *resultobj = 0;
16324	<	BossTask *arg1 = (BossTask *) 0 ;
16325	<	std::string *arg2 = 0 ;
16326	<	std::string *arg3 = 0 ;
16327	<	std::string *arg4 = 0 ;
16328	<	int result;
16329	<	void *argp1 = 0 ;
16330	<	int res1 = 0 ;
16331	<	int res2 = SWIG_OLDOBJ ;
16332	<	int res3 = SWIG_OLDOBJ ;
16333	<	int res4 = SWIG_OLDOBJ ;
16334	<	PyObject * obj0 = 0 ;
16335	<	PyObject * obj1 = 0 ;
16336	<	PyObject * obj2 = 0 ;
16337	<	PyObject * obj3 = 0 ;
16338	<
16339	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16340	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16341	<	if (!SWIG_IsOK(res1)) {
16342	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
16343	<	}
16344	<	arg1 = reinterpret_cast< BossTask * >(argp1);
16345	<	{
16346	<	std::string *ptr = (std::string *)0;
16347	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16348	<	if (!SWIG_IsOK(res2)) {
16349	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16350	<	}
16351	<	if (!ptr) {
16352	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16353	<	}
16354	<	arg2 = ptr;
16355	<	}
16356	<	{
16357	<	std::string *ptr = (std::string *)0;
16358	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
16359	<	if (!SWIG_IsOK(res3)) {
16360	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16361	<	}
16362	<	if (!ptr) {
16363	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16364	<	}
16365	<	arg3 = ptr;
16366	<	}
16367	<	{
16368	<	std::string *ptr = (std::string *)0;
16369	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
16370	<	if (!SWIG_IsOK(res4)) {
16371	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16372	<	}
16373	<	if (!ptr) {
16374	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16375	<	}
16376	<	arg4 = ptr;
16377	<	}
16378	<	{
16379	<	try {
16380	<	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
16381	<	} catch (const std::exception& e) {
16382	<	SWIG_exception(SWIG_RuntimeError, e.what());
16383	<	}
16384	<	}
16385	<	resultobj = SWIG_From_int(static_cast< int >(result));
16386	<	if (SWIG_IsNewObj(res2)) delete arg2;
16387	<	if (SWIG_IsNewObj(res3)) delete arg3;
16388	<	if (SWIG_IsNewObj(res4)) delete arg4;
16389	<	return resultobj;
16390	<	fail:
16391	<	if (SWIG_IsNewObj(res2)) delete arg2;
16392	<	if (SWIG_IsNewObj(res3)) delete arg3;
16393	<	if (SWIG_IsNewObj(res4)) delete arg4;
16394	<	return NULL;
16395	<	}
16396	<
16397	<
16398	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16399	<	PyObject *resultobj = 0;
16400	<	BossTask *arg1 = (BossTask *) 0 ;
16401	<	std::string *arg2 = 0 ;
16402	<	std::string *arg3 = 0 ;
16403	<	int result;
16404	<	void *argp1 = 0 ;
16405	<	int res1 = 0 ;
16406	<	int res2 = SWIG_OLDOBJ ;
16407	<	int res3 = SWIG_OLDOBJ ;
16408	<	PyObject * obj0 = 0 ;
16409	<	PyObject * obj1 = 0 ;
16410	<	PyObject * obj2 = 0 ;
16411	<
16412	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_submit",&obj0,&obj1,&obj2)) SWIG_fail;
16413	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16414	<	if (!SWIG_IsOK(res1)) {
16415	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
16416	<	}
16417	<	arg1 = reinterpret_cast< BossTask * >(argp1);
16418	<	{
16419	<	std::string *ptr = (std::string *)0;
16420	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16421	<	if (!SWIG_IsOK(res2)) {
16422	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16423	<	}
16424	<	if (!ptr) {
16425	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16426	<	}
16427	<	arg2 = ptr;
16428	<	}
16429	<	{
16430	<	std::string *ptr = (std::string *)0;
16431	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
16432	<	if (!SWIG_IsOK(res3)) {
16433	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16434	<	}
16435	<	if (!ptr) {
16436	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16437	<	}
16438	<	arg3 = ptr;
16439	<	}
16440	<	{
16441	<	try {
16442	<	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3);
16443	<	} catch (const std::exception& e) {
16444	<	SWIG_exception(SWIG_RuntimeError, e.what());
4396	>	{
4397	>	try {
4398	>	(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4399	>
4400	>	}catch (const BossSchedFailure & e) {
4401	>	PyErr_SetString ( SchedulerError, e.what() );
4402	>	return NULL;
4403	>	}catch (const std::exception& e) {
4404	>	PyErr_SetString ( BossError, e.what() );
4405	>	return NULL;
4406	>	}
4407		}
4408	<	}
4409	<	resultobj = SWIG_From_int(static_cast< int >(result));
4410	<	if (SWIG_IsNewObj(res2)) delete arg2;
4411	<	if (SWIG_IsNewObj(res3)) delete arg3;
16450	<	return resultobj;
16451	<	fail:
16452	<	if (SWIG_IsNewObj(res2)) delete arg2;
16453	<	if (SWIG_IsNewObj(res3)) delete arg3;
16454	<	return NULL;
4408	>	Py_INCREF(Py_None); resultobj = Py_None;
4409	>	return resultobj;
4410	>	fail:
4411	>	return NULL;
4412		}
4413
4414
4415	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4416	<	PyObject *resultobj = 0;
4417	<	BossTask *arg1 = (BossTask *) 0 ;
4418	<	std::string *arg2 = 0 ;
4419	<	int result;
4420	<	void *argp1 = 0 ;
4421	<	int res1 = 0 ;
4422	<	int res2 = SWIG_OLDOBJ ;
4423	<	PyObject * obj0 = 0 ;
4424	<	PyObject * obj1 = 0 ;
4425	<
4426	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_submit",&obj0,&obj1)) SWIG_fail;
4427	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4428	<	if (!SWIG_IsOK(res1)) {
4429	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
4430	<	}
4431	<	arg1 = reinterpret_cast< BossTask * >(argp1);
4432	<	{
4433	<	std::string *ptr = (std::string *)0;
4434	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
4435	<	if (!SWIG_IsOK(res2)) {
4436	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
4437	<	}
16481	<	if (!ptr) {
16482	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16483	<	}
16484	<	arg2 = ptr;
16485	<	}
16486	<	{
16487	<	try {
16488	<	result = (int)(arg1)->submit((std::string const &)*arg2);
16489	<	} catch (const std::exception& e) {
16490	<	SWIG_exception(SWIG_RuntimeError, e.what());
4415	>	static PyObject *_wrap_BossTask_declare__SWIG_1(PyObject *self, PyObject *args) {
4416	>	PyObject *resultobj;
4417	>	BossTask *arg1 = (BossTask *) 0 ;
4418	>	XMLDoc *arg2 = (XMLDoc *) 0 ;
4419	>	std::string const &arg3_defvalue = "" ;
4420	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4421	>	std::string temp3 ;
4422	>	PyObject * obj0 = 0 ;
4423	>	PyObject * obj1 = 0 ;
4424	>	PyObject * obj2 = 0 ;
4425	>
4426	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
4427	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4428	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_XMLDoc,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4429	>	if (obj2) {
4430	>	{
4431	>	if (PyString_Check(obj2)) {
4432	>	temp3 = std::string(PyString_AsString(obj2));
4433	>	arg3 = &temp3;
4434	>	}else {
4435	>	SWIG_exception(SWIG_TypeError, "string expected");
4436	>	}
4437	>	}
4438		}
4439	<	}
4440	<	resultobj = SWIG_From_int(static_cast< int >(result));
4441	<	if (SWIG_IsNewObj(res2)) delete arg2;
4442	<	return resultobj;
4443	<	fail:
4444	<	if (SWIG_IsNewObj(res2)) delete arg2;
4445	<	return NULL;
4446	<	}
4447	<
4448	<
4449	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16503	<	PyObject *resultobj = 0;
16504	<	BossTask *arg1 = (BossTask *) 0 ;
16505	<	int result;
16506	<	void *argp1 = 0 ;
16507	<	int res1 = 0 ;
16508	<	PyObject * obj0 = 0 ;
16509	<
16510	<	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_submit",&obj0)) SWIG_fail;
16511	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16512	<	if (!SWIG_IsOK(res1)) {
16513	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
16514	<	}
16515	<	arg1 = reinterpret_cast< BossTask * >(argp1);
16516	<	{
16517	<	try {
16518	<	result = (int)(arg1)->submit();
16519	<	} catch (const std::exception& e) {
16520	<	SWIG_exception(SWIG_RuntimeError, e.what());
4439	>	{
4440	>	try {
4441	>	(arg1)->declare(arg2,(std::string const &)*arg3);
4442	>
4443	>	}catch (const BossSchedFailure & e) {
4444	>	PyErr_SetString ( SchedulerError, e.what() );
4445	>	return NULL;
4446	>	}catch (const std::exception& e) {
4447	>	PyErr_SetString ( BossError, e.what() );
4448	>	return NULL;
4449	>	}
4450		}
4451	<	}
4452	<	resultobj = SWIG_From_int(static_cast< int >(result));
4453	<	return resultobj;
4454	<	fail:
16526	<	return NULL;
4451	>	Py_INCREF(Py_None); resultobj = Py_None;
4452	>	return resultobj;
4453	>	fail:
4454	>	return NULL;
4455		}
4456
4457
4458	<	SWIGINTERN PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4459	<	int argc;
4460	<	PyObject *argv[8];
4461	<	int ii;
4462	<
4463	<	if (!PyTuple_Check(args)) SWIG_fail;
4464	<	argc = PyObject_Length(args);
4465	<	for (ii = 0; (ii < argc) && (ii < 7); ii++) {
16538	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
16539	<	}
16540	<	if (argc == 1) {
16541	<	int _v;
16542	<	void *vptr = 0;
16543	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16544	<	_v = SWIG_CheckState(res);
16545	<	if (_v) {
16546	<	return _wrap_BossTask_submit__SWIG_6(self, args);
16547	<	}
16548	<	}
16549	<	if (argc == 2) {
16550	<	int _v;
16551	<	void *vptr = 0;
16552	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16553	<	_v = SWIG_CheckState(res);
16554	<	if (_v) {
16555	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
16556	<	_v = SWIG_CheckState(res);
16557	<	if (_v) {
16558	<	return _wrap_BossTask_submit__SWIG_5(self, args);
16559	<	}
16560	<	}
16561	<	}
16562	<	if (argc == 3) {
16563	<	int _v;
16564	<	void *vptr = 0;
16565	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16566	<	_v = SWIG_CheckState(res);
16567	<	if (_v) {
16568	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
16569	<	_v = SWIG_CheckState(res);
16570	<	if (_v) {
16571	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
16572	<	_v = SWIG_CheckState(res);
16573	<	if (_v) {
16574	<	return _wrap_BossTask_submit__SWIG_4(self, args);
16575	<	}
16576	<	}
4458	>	static PyObject *_wrap_BossTask_declare(PyObject *self, PyObject *args) {
4459	>	int argc;
4460	>	PyObject *argv[4];
4461	>	int ii;
4462	>
4463	>	argc = PyObject_Length(args);
4464	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4465	>	argv[ii] = PyTuple_GetItem(args,ii);
4466		}
4467	<	}
4468	<	if (argc == 4) {
4469	<	int _v;
4470	<	void *vptr = 0;
4471	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4472	<	_v = SWIG_CheckState(res);
4473	<	if (_v) {
4474	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4475	<	_v = SWIG_CheckState(res);
4476	<	if (_v) {
16588	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
16589	<	_v = SWIG_CheckState(res);
16590	<	if (_v) {
16591	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
16592	<	_v = SWIG_CheckState(res);
16593	<	if (_v) {
16594	<	return _wrap_BossTask_submit__SWIG_3(self, args);
16595	<	}
4467	>	if ((argc >= 2) && (argc <= 3)) {
4468	>	int _v;
4469	>	{
4470	>	void *ptr;
4471	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4472	>	_v = 0;
4473	>	PyErr_Clear();
4474	>	}else {
4475	>	_v = 1;
4476	>	}
4477		}
16597	–	}
16598	–	}
16599	–	}
16600	–	if (argc == 5) {
16601	–	int _v;
16602	–	void *vptr = 0;
16603	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16604	–	_v = SWIG_CheckState(res);
16605	–	if (_v) {
16606	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
16607	–	_v = SWIG_CheckState(res);
16608	–	if (_v) {
16609	–	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
16610	–	_v = SWIG_CheckState(res);
4478		if (_v) {
4479	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
4480	<	_v = SWIG_CheckState(res);
4481	<	if (_v) {
4482	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
4483	<	_v = SWIG_CheckState(res);
4479	>	{
4480	>	void *ptr;
4481	>	if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_XMLDoc, 0) == -1) {
4482	>	_v = 0;
4483	>	PyErr_Clear();
4484	>	}else {
4485	>	_v = 1;
4486	>	}
4487	>	}
4488		if (_v) {
4489	<	return _wrap_BossTask_submit__SWIG_2(self, args);
4489	>	if (argc <= 2) {
4490	>	return _wrap_BossTask_declare__SWIG_1(self,args);
4491	>	}
4492	>	{
4493	>	_v = PyString_Check(argv[2]) ? 1 : 0;
4494	>	}
4495	>	if (_v) {
4496	>	return _wrap_BossTask_declare__SWIG_1(self,args);
4497	>	}
4498		}
16620	–	}
4499		}
16622	–	}
4500		}
4501	<	}
4502	<	if (argc == 6) {
4503	<	int _v;
4504	<	void *vptr = 0;
4505	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4506	<	_v = SWIG_CheckState(res);
4507	<	if (_v) {
4508	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4509	<	_v = SWIG_CheckState(res);
16633	<	if (_v) {
16634	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
16635	<	_v = SWIG_CheckState(res);
16636	<	if (_v) {
16637	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
16638	<	_v = SWIG_CheckState(res);
16639	<	if (_v) {
16640	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
16641	<	_v = SWIG_CheckState(res);
16642	<	if (_v) {
16643	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
16644	<	_v = SWIG_CheckState(res);
16645	<	if (_v) {
16646	<	return _wrap_BossTask_submit__SWIG_1(self, args);
16647	<	}
4501	>	if ((argc >= 2) && (argc <= 3)) {
4502	>	int _v;
4503	>	{
4504	>	void *ptr;
4505	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4506	>	_v = 0;
4507	>	PyErr_Clear();
4508	>	}else {
4509	>	_v = 1;
4510		}
16649	–	}
4511		}
16651	–	}
16652	–	}
16653	–	}
16654	–	if (argc == 7) {
16655	–	int _v;
16656	–	void *vptr = 0;
16657	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16658	–	_v = SWIG_CheckState(res);
16659	–	if (_v) {
16660	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
16661	–	_v = SWIG_CheckState(res);
16662	–	if (_v) {
16663	–	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
16664	–	_v = SWIG_CheckState(res);
4512		if (_v) {
4513	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
4514	<	_v = SWIG_CheckState(res);
4515	<	if (_v) {
16669	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
16670	<	_v = SWIG_CheckState(res);
4513	>	{
4514	>	_v = PyString_Check(argv[1]) ? 1 : 0;
4515	>	}
4516		if (_v) {
4517	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
4518	<	_v = SWIG_CheckState(res);
4519	<	if (_v) {
4517	>	if (argc <= 2) {
4518	>	return _wrap_BossTask_declare__SWIG_0(self,args);
4519	>	}
4520		{
4521	<	int res = SWIG_AsVal_bool(argv[6], NULL);
16677	<	_v = SWIG_CheckState(res);
4521	>	_v = PyString_Check(argv[2]) ? 1 : 0;
4522		}
4523		if (_v) {
4524	<	return _wrap_BossTask_submit__SWIG_0(self, args);
4524	>	return _wrap_BossTask_declare__SWIG_0(self,args);
4525		}
16682	–	}
4526		}
16684	–	}
4527		}
16686	–	}
16687	–	}
16688	–	}
16689	–
16690	–	fail:
16691	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_submit'");
16692	–	return NULL;
16693	–	}
16694	–
16695	–
16696	–	SWIGINTERN PyObject *_wrap_BossTask_reSubmit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16697	–	PyObject *resultobj = 0;
16698	–	BossTask *arg1 = (BossTask *) 0 ;
16699	–	std::string *arg2 = 0 ;
16700	–	bool arg3 ;
16701	–	int result;
16702	–	void *argp1 = 0 ;
16703	–	int res1 = 0 ;
16704	–	int res2 = SWIG_OLDOBJ ;
16705	–	bool val3 ;
16706	–	int ecode3 = 0 ;
16707	–	PyObject * obj0 = 0 ;
16708	–	PyObject * obj1 = 0 ;
16709	–	PyObject * obj2 = 0 ;
16710	–
16711	–	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_reSubmit",&obj0,&obj1,&obj2)) SWIG_fail;
16712	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16713	–	if (!SWIG_IsOK(res1)) {
16714	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_reSubmit" "', argument " "1"" of type '" "BossTask *""'");
16715	–	}
16716	–	arg1 = reinterpret_cast< BossTask * >(argp1);
16717	–	{
16718	–	std::string *ptr = (std::string *)0;
16719	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16720	–	if (!SWIG_IsOK(res2)) {
16721	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_reSubmit" "', argument " "2"" of type '" "std::string const &""'");
4528		}
4529	<	if (!ptr) {
4530	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_reSubmit" "', argument " "2"" of type '" "std::string const &""'");
4531	<	}
16726	<	arg2 = ptr;
16727	<	}
16728	<	ecode3 = SWIG_AsVal_bool(obj2, &val3);
16729	<	if (!SWIG_IsOK(ecode3)) {
16730	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_reSubmit" "', argument " "3"" of type '" "bool""'");
16731	<	}
16732	<	arg3 = static_cast< bool >(val3);
16733	<	{
16734	<	try {
16735	<	result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
16736	<	} catch (const std::exception& e) {
16737	<	SWIG_exception(SWIG_RuntimeError, e.what());
16738	<	}
16739	<	}
16740	<	resultobj = SWIG_From_int(static_cast< int >(result));
16741	<	if (SWIG_IsNewObj(res2)) delete arg2;
16742	<	return resultobj;
16743	<	fail:
16744	<	if (SWIG_IsNewObj(res2)) delete arg2;
16745	<	return NULL;
4529	>
4530	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_declare'");
4531	>	return NULL;
4532		}
4533
4534
4535	<	SWIGINTERN PyObject *_wrap_BossTask_reSubmit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4536	<	PyObject *resultobj = 0;
4537	<	BossTask *arg1 = (BossTask *) 0 ;
4538	<	std::string *arg2 = 0 ;
4539	<	int result;
4540	<	void *argp1 = 0 ;
4541	<	int res1 = 0 ;
4542	<	int res2 = SWIG_OLDOBJ ;
4543	<	PyObject * obj0 = 0 ;
4544	<	PyObject * obj1 = 0 ;
4545	<
4546	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_reSubmit",&obj0,&obj1)) SWIG_fail;
4547	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4548	<	if (!SWIG_IsOK(res1)) {
4549	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_reSubmit" "', argument " "1"" of type '" "BossTask *""'");
4550	<	}
4551	<	arg1 = reinterpret_cast< BossTask * >(argp1);
4552	<	{
16767	<	std::string *ptr = (std::string *)0;
16768	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16769	<	if (!SWIG_IsOK(res2)) {
16770	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_reSubmit" "', argument " "2"" of type '" "std::string const &""'");
16771	<	}
16772	<	if (!ptr) {
16773	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_reSubmit" "', argument " "2"" of type '" "std::string const &""'");
16774	<	}
16775	<	arg2 = ptr;
16776	<	}
16777	<	{
16778	<	try {
16779	<	result = (int)(arg1)->reSubmit((std::string const &)*arg2);
16780	<	} catch (const std::exception& e) {
16781	<	SWIG_exception(SWIG_RuntimeError, e.what());
4535	>	static PyObject *_wrap_BossTask_remove(PyObject *self, PyObject *args) {
4536	>	PyObject *resultobj;
4537	>	BossTask *arg1 = (BossTask *) 0 ;
4538	>	PyObject * obj0 = 0 ;
4539	>
4540	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_remove",&obj0)) goto fail;
4541	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4542	>	{
4543	>	try {
4544	>	(arg1)->remove();
4545	>
4546	>	}catch (const BossSchedFailure & e) {
4547	>	PyErr_SetString ( SchedulerError, e.what() );
4548	>	return NULL;
4549	>	}catch (const std::exception& e) {
4550	>	PyErr_SetString ( BossError, e.what() );
4551	>	return NULL;
4552	>	}
4553		}
4554	<	}
4555	<	resultobj = SWIG_From_int(static_cast< int >(result));
4556	<	if (SWIG_IsNewObj(res2)) delete arg2;
4557	<	return resultobj;
16787	<	fail:
16788	<	if (SWIG_IsNewObj(res2)) delete arg2;
16789	<	return NULL;
4554	>	Py_INCREF(Py_None); resultobj = Py_None;
4555	>	return resultobj;
4556	>	fail:
4557	>	return NULL;
4558		}
4559
4560
4561	<	SWIGINTERN PyObject *_wrap_BossTask_reSubmit(PyObject *self, PyObject *args) {
4562	<	int argc;
4563	<	PyObject *argv[4];
4564	<	int ii;
4565	<
4566	<	if (!PyTuple_Check(args)) SWIG_fail;
4567	<	argc = PyObject_Length(args);
4568	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4569	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4570	<	}
4571	<	if (argc == 2) {
4572	<	int _v;
16805	<	void *vptr = 0;
16806	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16807	<	_v = SWIG_CheckState(res);
16808	<	if (_v) {
16809	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
16810	<	_v = SWIG_CheckState(res);
16811	<	if (_v) {
16812	<	return _wrap_BossTask_reSubmit__SWIG_1(self, args);
16813	<	}
16814	<	}
16815	<	}
16816	<	if (argc == 3) {
16817	<	int _v;
16818	<	void *vptr = 0;
16819	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16820	<	_v = SWIG_CheckState(res);
16821	<	if (_v) {
16822	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
16823	<	_v = SWIG_CheckState(res);
16824	<	if (_v) {
4561	>	static PyObject *_wrap_BossTask_archive(PyObject *self, PyObject *args) {
4562	>	PyObject *resultobj;
4563	>	BossTask *arg1 = (BossTask *) 0 ;
4564	>	std::string const &arg2_defvalue = "all" ;
4565	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4566	>	std::string temp2 ;
4567	>	PyObject * obj0 = 0 ;
4568	>	PyObject * obj1 = 0 ;
4569	>
4570	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossTask_archive",&obj0,&obj1)) goto fail;
4571	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4572	>	if (obj1) {
4573		{
4574	<	int res = SWIG_AsVal_bool(argv[2], NULL);
4575	<	_v = SWIG_CheckState(res);
4576	<	}
4577	<	if (_v) {
4578	<	return _wrap_BossTask_reSubmit__SWIG_0(self, args);
4574	>	if (PyString_Check(obj1)) {
4575	>	temp2 = std::string(PyString_AsString(obj1));
4576	>	arg2 = &temp2;
4577	>	}else {
4578	>	SWIG_exception(SWIG_TypeError, "string expected");
4579	>	}
4580		}
16832	–	}
16833	–	}
16834	–	}
16835	–
16836	–	fail:
16837	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_reSubmit'");
16838	–	return NULL;
16839	–	}
16840	–
16841	–
16842	–	SWIGINTERN PyObject *_wrap_BossTask_kill__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16843	–	PyObject *resultobj = 0;
16844	–	BossTask *arg1 = (BossTask *) 0 ;
16845	–	std::string *arg2 = 0 ;
16846	–	bool arg3 ;
16847	–	int result;
16848	–	void *argp1 = 0 ;
16849	–	int res1 = 0 ;
16850	–	int res2 = SWIG_OLDOBJ ;
16851	–	bool val3 ;
16852	–	int ecode3 = 0 ;
16853	–	PyObject * obj0 = 0 ;
16854	–	PyObject * obj1 = 0 ;
16855	–	PyObject * obj2 = 0 ;
16856	–
16857	–	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_kill",&obj0,&obj1,&obj2)) SWIG_fail;
16858	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16859	–	if (!SWIG_IsOK(res1)) {
16860	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_kill" "', argument " "1"" of type '" "BossTask *""'");
16861	–	}
16862	–	arg1 = reinterpret_cast< BossTask * >(argp1);
16863	–	{
16864	–	std::string *ptr = (std::string *)0;
16865	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16866	–	if (!SWIG_IsOK(res2)) {
16867	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_kill" "', argument " "2"" of type '" "std::string const &""'");
4581		}
4582	<	if (!ptr) {
4583	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_kill" "', argument " "2"" of type '" "std::string const &""'");
4584	<	}
4585	<	arg2 = ptr;
4586	<	}
4587	<	ecode3 = SWIG_AsVal_bool(obj2, &val3);
4588	<	if (!SWIG_IsOK(ecode3)) {
4589	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_kill" "', argument " "3"" of type '" "bool""'");
4590	<	}
4591	<	arg3 = static_cast< bool >(val3);
4592	<	{
16880	<	try {
16881	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
16882	<	} catch (const std::exception& e) {
16883	<	SWIG_exception(SWIG_RuntimeError, e.what());
16884	<	}
16885	<	}
16886	<	resultobj = SWIG_From_int(static_cast< int >(result));
16887	<	if (SWIG_IsNewObj(res2)) delete arg2;
16888	<	return resultobj;
16889	<	fail:
16890	<	if (SWIG_IsNewObj(res2)) delete arg2;
16891	<	return NULL;
16892	<	}
16893	<
16894	<
16895	<	SWIGINTERN PyObject *_wrap_BossTask_kill__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16896	<	PyObject *resultobj = 0;
16897	<	BossTask *arg1 = (BossTask *) 0 ;
16898	<	std::string *arg2 = 0 ;
16899	<	int result;
16900	<	void *argp1 = 0 ;
16901	<	int res1 = 0 ;
16902	<	int res2 = SWIG_OLDOBJ ;
16903	<	PyObject * obj0 = 0 ;
16904	<	PyObject * obj1 = 0 ;
16905	<
16906	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_kill",&obj0,&obj1)) SWIG_fail;
16907	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16908	<	if (!SWIG_IsOK(res1)) {
16909	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_kill" "', argument " "1"" of type '" "BossTask *""'");
16910	<	}
16911	<	arg1 = reinterpret_cast< BossTask * >(argp1);
16912	<	{
16913	<	std::string *ptr = (std::string *)0;
16914	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16915	<	if (!SWIG_IsOK(res2)) {
16916	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_kill" "', argument " "2"" of type '" "std::string const &""'");
16917	<	}
16918	<	if (!ptr) {
16919	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_kill" "', argument " "2"" of type '" "std::string const &""'");
16920	<	}
16921	<	arg2 = ptr;
16922	<	}
16923	<	{
16924	<	try {
16925	<	result = (int)(arg1)->kill((std::string const &)*arg2);
16926	<	} catch (const std::exception& e) {
16927	<	SWIG_exception(SWIG_RuntimeError, e.what());
4582	>	{
4583	>	try {
4584	>	(arg1)->archive((std::string const &)*arg2);
4585	>
4586	>	}catch (const BossSchedFailure & e) {
4587	>	PyErr_SetString ( SchedulerError, e.what() );
4588	>	return NULL;
4589	>	}catch (const std::exception& e) {
4590	>	PyErr_SetString ( BossError, e.what() );
4591	>	return NULL;
4592	>	}
4593		}
4594	<	}
4595	<	resultobj = SWIG_From_int(static_cast< int >(result));
4596	<	if (SWIG_IsNewObj(res2)) delete arg2;
4597	<	return resultobj;
16933	<	fail:
16934	<	if (SWIG_IsNewObj(res2)) delete arg2;
16935	<	return NULL;
4594	>	Py_INCREF(Py_None); resultobj = Py_None;
4595	>	return resultobj;
4596	>	fail:
4597	>	return NULL;
4598		}
4599
4600
4601	<	SWIGINTERN PyObject *_wrap_BossTask_kill(PyObject *self, PyObject *args) {
4602	<	int argc;
4603	<	PyObject *argv[4];
4604	<	int ii;
4605	<
4606	<	if (!PyTuple_Check(args)) SWIG_fail;
4607	<	argc = PyObject_Length(args);
4608	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4609	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4610	<	}
4611	<	if (argc == 2) {
4612	<	int _v;
4613	<	void *vptr = 0;
4614	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4615	<	_v = SWIG_CheckState(res);
4616	<	if (_v) {
4617	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4618	<	_v = SWIG_CheckState(res);
4619	<	if (_v) {
4620	<	return _wrap_BossTask_kill__SWIG_1(self, args);
4621	<	}
4622	<	}
4623	<	}
4624	<	if (argc == 3) {
4625	<	int _v;
4626	<	void *vptr = 0;
4627	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4628	<	_v = SWIG_CheckState(res);
4629	<	if (_v) {
4630	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4631	<	_v = SWIG_CheckState(res);
16970	<	if (_v) {
4601	>	static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4602	>	PyObject *resultobj;
4603	>	BossTask *arg1 = (BossTask *) 0 ;
4604	>	std::string const &arg2_defvalue = "all" ;
4605	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4606	>	std::string const &arg3_defvalue = "" ;
4607	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4608	>	std::string const &arg4_defvalue = "" ;
4609	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4610	>	std::string const &arg5_defvalue = "" ;
4611	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
4612	>	std::string const &arg6_defvalue = "" ;
4613	>	std::string *arg6 = (std::string *) &arg6_defvalue ;
4614	>	bool arg7 = (bool) false ;
4615	>	int result;
4616	>	std::string temp2 ;
4617	>	std::string temp3 ;
4618	>	std::string temp4 ;
4619	>	std::string temp5 ;
4620	>	std::string temp6 ;
4621	>	PyObject * obj0 = 0 ;
4622	>	PyObject * obj1 = 0 ;
4623	>	PyObject * obj2 = 0 ;
4624	>	PyObject * obj3 = 0 ;
4625	>	PyObject * obj4 = 0 ;
4626	>	PyObject * obj5 = 0 ;
4627	>	PyObject * obj6 = 0 ;
4628	>
4629	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4630	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4631	>	if (obj1) {
4632		{
4633	<	int res = SWIG_AsVal_bool(argv[2], NULL);
4634	<	_v = SWIG_CheckState(res);
4635	<	}
4636	<	if (_v) {
4637	<	return _wrap_BossTask_kill__SWIG_0(self, args);
4633	>	if (PyString_Check(obj1)) {
4634	>	temp2 = std::string(PyString_AsString(obj1));
4635	>	arg2 = &temp2;
4636	>	}else {
4637	>	SWIG_exception(SWIG_TypeError, "string expected");
4638	>	}
4639		}
16978	–	}
16979	–	}
16980	–	}
16981	–
16982	–	fail:
16983	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_kill'");
16984	–	return NULL;
16985	–	}
16986	–
16987	–
16988	–	SWIGINTERN PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16989	–	PyObject *resultobj = 0;
16990	–	BossTask *arg1 = (BossTask *) 0 ;
16991	–	std::string *arg2 = 0 ;
16992	–	std::string *arg3 = 0 ;
16993	–	bool arg4 ;
16994	–	bool arg5 ;
16995	–	int result;
16996	–	void *argp1 = 0 ;
16997	–	int res1 = 0 ;
16998	–	int res2 = SWIG_OLDOBJ ;
16999	–	int res3 = SWIG_OLDOBJ ;
17000	–	bool val4 ;
17001	–	int ecode4 = 0 ;
17002	–	bool val5 ;
17003	–	int ecode5 = 0 ;
17004	–	PyObject * obj0 = 0 ;
17005	–	PyObject * obj1 = 0 ;
17006	–	PyObject * obj2 = 0 ;
17007	–	PyObject * obj3 = 0 ;
17008	–	PyObject * obj4 = 0 ;
17009	–
17010	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17011	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17012	–	if (!SWIG_IsOK(res1)) {
17013	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getOutput" "', argument " "1"" of type '" "BossTask *""'");
17014	–	}
17015	–	arg1 = reinterpret_cast< BossTask * >(argp1);
17016	–	{
17017	–	std::string *ptr = (std::string *)0;
17018	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17019	–	if (!SWIG_IsOK(res2)) {
17020	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17021	–	}
17022	–	if (!ptr) {
17023	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17024	–	}
17025	–	arg2 = ptr;
17026	–	}
17027	–	{
17028	–	std::string *ptr = (std::string *)0;
17029	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17030	–	if (!SWIG_IsOK(res3)) {
17031	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
17032	–	}
17033	–	if (!ptr) {
17034	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
4640		}
4641	<	arg3 = ptr;
4642	<	}
4643	<	ecode4 = SWIG_AsVal_bool(obj3, &val4);
4644	<	if (!SWIG_IsOK(ecode4)) {
4645	<	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_getOutput" "', argument " "4"" of type '" "bool""'");
4646	<	}
4647	<	arg4 = static_cast< bool >(val4);
4648	<	ecode5 = SWIG_AsVal_bool(obj4, &val5);
17044	<	if (!SWIG_IsOK(ecode5)) {
17045	<	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BossTask_getOutput" "', argument " "5"" of type '" "bool""'");
17046	<	}
17047	<	arg5 = static_cast< bool >(val5);
17048	<	{
17049	<	try {
17050	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
17051	<	} catch (const std::exception& e) {
17052	<	SWIG_exception(SWIG_RuntimeError, e.what());
17053	<	}
17054	<	}
17055	<	resultobj = SWIG_From_int(static_cast< int >(result));
17056	<	if (SWIG_IsNewObj(res2)) delete arg2;
17057	<	if (SWIG_IsNewObj(res3)) delete arg3;
17058	<	return resultobj;
17059	<	fail:
17060	<	if (SWIG_IsNewObj(res2)) delete arg2;
17061	<	if (SWIG_IsNewObj(res3)) delete arg3;
17062	<	return NULL;
17063	<	}
17064	<
17065	<
17066	<	SWIGINTERN PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17067	<	PyObject *resultobj = 0;
17068	<	BossTask *arg1 = (BossTask *) 0 ;
17069	<	std::string *arg2 = 0 ;
17070	<	std::string *arg3 = 0 ;
17071	<	bool arg4 ;
17072	<	int result;
17073	<	void *argp1 = 0 ;
17074	<	int res1 = 0 ;
17075	<	int res2 = SWIG_OLDOBJ ;
17076	<	int res3 = SWIG_OLDOBJ ;
17077	<	bool val4 ;
17078	<	int ecode4 = 0 ;
17079	<	PyObject * obj0 = 0 ;
17080	<	PyObject * obj1 = 0 ;
17081	<	PyObject * obj2 = 0 ;
17082	<	PyObject * obj3 = 0 ;
17083	<
17084	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17085	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17086	<	if (!SWIG_IsOK(res1)) {
17087	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getOutput" "', argument " "1"" of type '" "BossTask *""'");
17088	<	}
17089	<	arg1 = reinterpret_cast< BossTask * >(argp1);
17090	<	{
17091	<	std::string *ptr = (std::string *)0;
17092	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17093	<	if (!SWIG_IsOK(res2)) {
17094	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17095	<	}
17096	<	if (!ptr) {
17097	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17098	<	}
17099	<	arg2 = ptr;
17100	<	}
17101	<	{
17102	<	std::string *ptr = (std::string *)0;
17103	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17104	<	if (!SWIG_IsOK(res3)) {
17105	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
17106	<	}
17107	<	if (!ptr) {
17108	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
17109	<	}
17110	<	arg3 = ptr;
17111	<	}
17112	<	ecode4 = SWIG_AsVal_bool(obj3, &val4);
17113	<	if (!SWIG_IsOK(ecode4)) {
17114	<	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_getOutput" "', argument " "4"" of type '" "bool""'");
17115	<	}
17116	<	arg4 = static_cast< bool >(val4);
17117	<	{
17118	<	try {
17119	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4);
17120	<	} catch (const std::exception& e) {
17121	<	SWIG_exception(SWIG_RuntimeError, e.what());
17122	<	}
17123	<	}
17124	<	resultobj = SWIG_From_int(static_cast< int >(result));
17125	<	if (SWIG_IsNewObj(res2)) delete arg2;
17126	<	if (SWIG_IsNewObj(res3)) delete arg3;
17127	<	return resultobj;
17128	<	fail:
17129	<	if (SWIG_IsNewObj(res2)) delete arg2;
17130	<	if (SWIG_IsNewObj(res3)) delete arg3;
17131	<	return NULL;
17132	<	}
17133	<
17134	<
17135	<	SWIGINTERN PyObject *_wrap_BossTask_getOutput__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17136	<	PyObject *resultobj = 0;
17137	<	BossTask *arg1 = (BossTask *) 0 ;
17138	<	std::string *arg2 = 0 ;
17139	<	std::string *arg3 = 0 ;
17140	<	int result;
17141	<	void *argp1 = 0 ;
17142	<	int res1 = 0 ;
17143	<	int res2 = SWIG_OLDOBJ ;
17144	<	int res3 = SWIG_OLDOBJ ;
17145	<	PyObject * obj0 = 0 ;
17146	<	PyObject * obj1 = 0 ;
17147	<	PyObject * obj2 = 0 ;
17148	<
17149	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_getOutput",&obj0,&obj1,&obj2)) SWIG_fail;
17150	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17151	<	if (!SWIG_IsOK(res1)) {
17152	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getOutput" "', argument " "1"" of type '" "BossTask *""'");
17153	<	}
17154	<	arg1 = reinterpret_cast< BossTask * >(argp1);
17155	<	{
17156	<	std::string *ptr = (std::string *)0;
17157	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17158	<	if (!SWIG_IsOK(res2)) {
17159	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17160	<	}
17161	<	if (!ptr) {
17162	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17163	<	}
17164	<	arg2 = ptr;
17165	<	}
17166	<	{
17167	<	std::string *ptr = (std::string *)0;
17168	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17169	<	if (!SWIG_IsOK(res3)) {
17170	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
17171	<	}
17172	<	if (!ptr) {
17173	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
17174	<	}
17175	<	arg3 = ptr;
17176	<	}
17177	<	{
17178	<	try {
17179	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3);
17180	<	} catch (const std::exception& e) {
17181	<	SWIG_exception(SWIG_RuntimeError, e.what());
17182	<	}
17183	<	}
17184	<	resultobj = SWIG_From_int(static_cast< int >(result));
17185	<	if (SWIG_IsNewObj(res2)) delete arg2;
17186	<	if (SWIG_IsNewObj(res3)) delete arg3;
17187	<	return resultobj;
17188	<	fail:
17189	<	if (SWIG_IsNewObj(res2)) delete arg2;
17190	<	if (SWIG_IsNewObj(res3)) delete arg3;
17191	<	return NULL;
17192	<	}
17193	<
17194	<
17195	<	SWIGINTERN PyObject *_wrap_BossTask_getOutput__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17196	<	PyObject *resultobj = 0;
17197	<	BossTask *arg1 = (BossTask *) 0 ;
17198	<	std::string *arg2 = 0 ;
17199	<	int result;
17200	<	void *argp1 = 0 ;
17201	<	int res1 = 0 ;
17202	<	int res2 = SWIG_OLDOBJ ;
17203	<	PyObject * obj0 = 0 ;
17204	<	PyObject * obj1 = 0 ;
17205	<
17206	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_getOutput",&obj0,&obj1)) SWIG_fail;
17207	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17208	<	if (!SWIG_IsOK(res1)) {
17209	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getOutput" "', argument " "1"" of type '" "BossTask *""'");
17210	<	}
17211	<	arg1 = reinterpret_cast< BossTask * >(argp1);
17212	<	{
17213	<	std::string *ptr = (std::string *)0;
17214	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17215	<	if (!SWIG_IsOK(res2)) {
17216	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17217	<	}
17218	<	if (!ptr) {
17219	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17220	<	}
17221	<	arg2 = ptr;
17222	<	}
17223	<	{
17224	<	try {
17225	<	result = (int)(arg1)->getOutput((std::string const &)*arg2);
17226	<	} catch (const std::exception& e) {
17227	<	SWIG_exception(SWIG_RuntimeError, e.what());
17228	<	}
17229	<	}
17230	<	resultobj = SWIG_From_int(static_cast< int >(result));
17231	<	if (SWIG_IsNewObj(res2)) delete arg2;
17232	<	return resultobj;
17233	<	fail:
17234	<	if (SWIG_IsNewObj(res2)) delete arg2;
17235	<	return NULL;
17236	<	}
17237	<
17238	<
17239	<	SWIGINTERN PyObject *_wrap_BossTask_getOutput__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240	<	PyObject *resultobj = 0;
17241	<	BossTask *arg1 = (BossTask *) 0 ;
17242	<	int result;
17243	<	void *argp1 = 0 ;
17244	<	int res1 = 0 ;
17245	<	PyObject * obj0 = 0 ;
17246	<
17247	<	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_getOutput",&obj0)) SWIG_fail;
17248	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17249	<	if (!SWIG_IsOK(res1)) {
17250	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getOutput" "', argument " "1"" of type '" "BossTask *""'");
17251	<	}
17252	<	arg1 = reinterpret_cast< BossTask * >(argp1);
17253	<	{
17254	<	try {
17255	<	result = (int)(arg1)->getOutput();
17256	<	} catch (const std::exception& e) {
17257	<	SWIG_exception(SWIG_RuntimeError, e.what());
17258	<	}
17259	<	}
17260	<	resultobj = SWIG_From_int(static_cast< int >(result));
17261	<	return resultobj;
17262	<	fail:
17263	<	return NULL;
17264	<	}
17265	<
17266	<
17267	<	SWIGINTERN PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
17268	<	int argc;
17269	<	PyObject *argv[6];
17270	<	int ii;
17271	<
17272	<	if (!PyTuple_Check(args)) SWIG_fail;
17273	<	argc = PyObject_Length(args);
17274	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
17275	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
17276	<	}
17277	<	if (argc == 1) {
17278	<	int _v;
17279	<	void *vptr = 0;
17280	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17281	<	_v = SWIG_CheckState(res);
17282	<	if (_v) {
17283	<	return _wrap_BossTask_getOutput__SWIG_4(self, args);
17284	<	}
17285	<	}
17286	<	if (argc == 2) {
17287	<	int _v;
17288	<	void *vptr = 0;
17289	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17290	<	_v = SWIG_CheckState(res);
17291	<	if (_v) {
17292	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17293	<	_v = SWIG_CheckState(res);
17294	<	if (_v) {
17295	<	return _wrap_BossTask_getOutput__SWIG_3(self, args);
17296	<	}
17297	<	}
17298	<	}
17299	<	if (argc == 3) {
17300	<	int _v;
17301	<	void *vptr = 0;
17302	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17303	<	_v = SWIG_CheckState(res);
17304	<	if (_v) {
17305	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17306	<	_v = SWIG_CheckState(res);
17307	<	if (_v) {
17308	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
17309	<	_v = SWIG_CheckState(res);
17310	<	if (_v) {
17311	<	return _wrap_BossTask_getOutput__SWIG_2(self, args);
4641	>	if (obj2) {
4642	>	{
4643	>	if (PyString_Check(obj2)) {
4644	>	temp3 = std::string(PyString_AsString(obj2));
4645	>	arg3 = &temp3;
4646	>	}else {
4647	>	SWIG_exception(SWIG_TypeError, "string expected");
4648	>	}
4649		}
17313	–	}
4650		}
4651	<	}
4652	<	if (argc == 4) {
4653	<	int _v;
4654	<	void *vptr = 0;
4655	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4656	<	_v = SWIG_CheckState(res);
4657	<	if (_v) {
4658	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17323	<	_v = SWIG_CheckState(res);
17324	<	if (_v) {
17325	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
17326	<	_v = SWIG_CheckState(res);
17327	<	if (_v) {
17328	<	{
17329	<	int res = SWIG_AsVal_bool(argv[3], NULL);
17330	<	_v = SWIG_CheckState(res);
17331	<	}
17332	<	if (_v) {
17333	<	return _wrap_BossTask_getOutput__SWIG_1(self, args);
17334	<	}
4651	>	if (obj3) {
4652	>	{
4653	>	if (PyString_Check(obj3)) {
4654	>	temp4 = std::string(PyString_AsString(obj3));
4655	>	arg4 = &temp4;
4656	>	}else {
4657	>	SWIG_exception(SWIG_TypeError, "string expected");
4658	>	}
4659		}
17336	–	}
4660		}
4661	<	}
4662	<	if (argc == 5) {
4663	<	int _v;
4664	<	void *vptr = 0;
4665	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4666	<	_v = SWIG_CheckState(res);
4667	<	if (_v) {
17345	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17346	<	_v = SWIG_CheckState(res);
17347	<	if (_v) {
17348	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
17349	<	_v = SWIG_CheckState(res);
17350	<	if (_v) {
17351	<	{
17352	<	int res = SWIG_AsVal_bool(argv[3], NULL);
17353	<	_v = SWIG_CheckState(res);
17354	<	}
17355	<	if (_v) {
17356	<	{
17357	<	int res = SWIG_AsVal_bool(argv[4], NULL);
17358	<	_v = SWIG_CheckState(res);
17359	<	}
17360	<	if (_v) {
17361	<	return _wrap_BossTask_getOutput__SWIG_0(self, args);
4661	>	if (obj4) {
4662	>	{
4663	>	if (PyString_Check(obj4)) {
4664	>	temp5 = std::string(PyString_AsString(obj4));
4665	>	arg5 = &temp5;
4666	>	}else {
4667	>	SWIG_exception(SWIG_TypeError, "string expected");
4668		}
17363	–	}
4669		}
17365	–	}
4670		}
4671	<	}
4672	<
4673	<	fail:
4674	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_getOutput'");
4675	<	return NULL;
4676	<	}
4677	<
4678	<
4679	<	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17376	<	PyObject *resultobj = 0;
17377	<	BossTask *arg1 = (BossTask *) 0 ;
17378	<	std::string *arg2 = 0 ;
17379	<	bool arg3 ;
17380	<	bool arg4 ;
17381	<	int result;
17382	<	void *argp1 = 0 ;
17383	<	int res1 = 0 ;
17384	<	int res2 = SWIG_OLDOBJ ;
17385	<	bool val3 ;
17386	<	int ecode3 = 0 ;
17387	<	bool val4 ;
17388	<	int ecode4 = 0 ;
17389	<	PyObject * obj0 = 0 ;
17390	<	PyObject * obj1 = 0 ;
17391	<	PyObject * obj2 = 0 ;
17392	<	PyObject * obj3 = 0 ;
17393	<
17394	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossTask_getAllOutput",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17395	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17396	<	if (!SWIG_IsOK(res1)) {
17397	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getAllOutput" "', argument " "1"" of type '" "BossTask *""'");
17398	<	}
17399	<	arg1 = reinterpret_cast< BossTask * >(argp1);
17400	<	{
17401	<	std::string *ptr = (std::string *)0;
17402	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17403	<	if (!SWIG_IsOK(res2)) {
17404	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
4671	>	if (obj5) {
4672	>	{
4673	>	if (PyString_Check(obj5)) {
4674	>	temp6 = std::string(PyString_AsString(obj5));
4675	>	arg6 = &temp6;
4676	>	}else {
4677	>	SWIG_exception(SWIG_TypeError, "string expected");
4678	>	}
4679	>	}
4680		}
4681	<	if (!ptr) {
4682	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
4681	>	if (obj6) {
4682	>	arg7 = PyInt_AsLong(obj6) ? true : false;
4683	>	if (PyErr_Occurred()) SWIG_fail;
4684		}
4685	<	arg2 = ptr;
4686	<	}
4687	<	ecode3 = SWIG_AsVal_bool(obj2, &val3);
4688	<	if (!SWIG_IsOK(ecode3)) {
4689	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_getAllOutput" "', argument " "3"" of type '" "bool""'");
4690	<	}
4691	<	arg3 = static_cast< bool >(val3);
4692	<	ecode4 = SWIG_AsVal_bool(obj3, &val4);
4693	<	if (!SWIG_IsOK(ecode4)) {
4694	<	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_getAllOutput" "', argument " "4"" of type '" "bool""'");
4695	<	}
17420	<	arg4 = static_cast< bool >(val4);
17421	<	{
17422	<	try {
17423	<	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3,arg4);
17424	<	} catch (const std::exception& e) {
17425	<	SWIG_exception(SWIG_RuntimeError, e.what());
4685	>	{
4686	>	try {
4687	>	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);
4688	>
4689	>	}catch (const BossSchedFailure & e) {
4690	>	PyErr_SetString ( SchedulerError, e.what() );
4691	>	return NULL;
4692	>	}catch (const std::exception& e) {
4693	>	PyErr_SetString ( BossError, e.what() );
4694	>	return NULL;
4695	>	}
4696		}
4697	<	}
4698	<	resultobj = SWIG_From_int(static_cast< int >(result));
4699	<	if (SWIG_IsNewObj(res2)) delete arg2;
4700	<	return resultobj;
17431	<	fail:
17432	<	if (SWIG_IsNewObj(res2)) delete arg2;
17433	<	return NULL;
4697	>	resultobj = PyInt_FromLong((long)result);
4698	>	return resultobj;
4699	>	fail:
4700	>	return NULL;
4701		}
4702
4703
4704	<	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4705	<	PyObject *resultobj = 0;
4706	<	BossTask *arg1 = (BossTask *) 0 ;
4707	<	std::string *arg2 = 0 ;
4708	<	bool arg3 ;
4709	<	int result;
4710	<	void *argp1 = 0 ;
4711	<	int res1 = 0 ;
4712	<	int res2 = SWIG_OLDOBJ ;
4713	<	bool val3 ;
4714	<	int ecode3 = 0 ;
4715	<	PyObject * obj0 = 0 ;
4716	<	PyObject * obj1 = 0 ;
4717	<	PyObject * obj2 = 0 ;
4718	<
4719	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2)) SWIG_fail;
4720	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4721	<	if (!SWIG_IsOK(res1)) {
4722	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getAllOutput" "', argument " "1"" of type '" "BossTask *""'");
4723	<	}
17457	<	arg1 = reinterpret_cast< BossTask * >(argp1);
17458	<	{
17459	<	std::string *ptr = (std::string *)0;
17460	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17461	<	if (!SWIG_IsOK(res2)) {
17462	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
4704	>	static PyObject *_wrap_BossTask_reSubmit(PyObject *self, PyObject *args) {
4705	>	PyObject *resultobj;
4706	>	BossTask *arg1 = (BossTask *) 0 ;
4707	>	std::string *arg2 = 0 ;
4708	>	bool arg3 = (bool) false ;
4709	>	int result;
4710	>	std::string temp2 ;
4711	>	PyObject * obj0 = 0 ;
4712	>	PyObject * obj1 = 0 ;
4713	>	PyObject * obj2 = 0 ;
4714	>
4715	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_reSubmit",&obj0,&obj1,&obj2)) goto fail;
4716	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4717	>	{
4718	>	if (PyString_Check(obj1)) {
4719	>	temp2 = std::string(PyString_AsString(obj1));
4720	>	arg2 = &temp2;
4721	>	}else {
4722	>	SWIG_exception(SWIG_TypeError, "string expected");
4723	>	}
4724		}
4725	<	if (!ptr) {
4726	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
4725	>	if (obj2) {
4726	>	arg3 = PyInt_AsLong(obj2) ? true : false;
4727	>	if (PyErr_Occurred()) SWIG_fail;
4728		}
4729	<	arg2 = ptr;
4730	<	}
4731	<	ecode3 = SWIG_AsVal_bool(obj2, &val3);
4732	<	if (!SWIG_IsOK(ecode3)) {
4733	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_getAllOutput" "', argument " "3"" of type '" "bool""'");
4734	<	}
4735	<	arg3 = static_cast< bool >(val3);
4736	<	{
4737	<	try {
4738	<	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3);
4739	<	} catch (const std::exception& e) {
17478	<	SWIG_exception(SWIG_RuntimeError, e.what());
4729	>	{
4730	>	try {
4731	>	result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4732	>
4733	>	}catch (const BossSchedFailure & e) {
4734	>	PyErr_SetString ( SchedulerError, e.what() );
4735	>	return NULL;
4736	>	}catch (const std::exception& e) {
4737	>	PyErr_SetString ( BossError, e.what() );
4738	>	return NULL;
4739	>	}
4740		}
4741	<	}
4742	<	resultobj = SWIG_From_int(static_cast< int >(result));
4743	<	if (SWIG_IsNewObj(res2)) delete arg2;
4744	<	return resultobj;
17484	<	fail:
17485	<	if (SWIG_IsNewObj(res2)) delete arg2;
17486	<	return NULL;
4741	>	resultobj = PyInt_FromLong((long)result);
4742	>	return resultobj;
4743	>	fail:
4744	>	return NULL;
4745		}
4746
4747
4748	<	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4749	<	PyObject *resultobj = 0;
4750	<	BossTask *arg1 = (BossTask *) 0 ;
4751	<	std::string *arg2 = 0 ;
4752	<	int result;
4753	<	void *argp1 = 0 ;
4754	<	int res1 = 0 ;
4755	<	int res2 = SWIG_OLDOBJ ;
4756	<	PyObject * obj0 = 0 ;
4757	<	PyObject * obj1 = 0 ;
4758	<
4759	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_getAllOutput",&obj0,&obj1)) SWIG_fail;
4760	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4761	<	if (!SWIG_IsOK(res1)) {
4762	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getAllOutput" "', argument " "1"" of type '" "BossTask *""'");
4763	<	}
4764	<	arg1 = reinterpret_cast< BossTask * >(argp1);
4765	<	{
4766	<	std::string *ptr = (std::string *)0;
4767	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17510	<	if (!SWIG_IsOK(res2)) {
17511	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
4748	>	static PyObject *_wrap_BossTask_kill(PyObject *self, PyObject *args) {
4749	>	PyObject *resultobj;
4750	>	BossTask *arg1 = (BossTask *) 0 ;
4751	>	std::string *arg2 = 0 ;
4752	>	bool arg3 = (bool) false ;
4753	>	int result;
4754	>	std::string temp2 ;
4755	>	PyObject * obj0 = 0 ;
4756	>	PyObject * obj1 = 0 ;
4757	>	PyObject * obj2 = 0 ;
4758	>
4759	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4760	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4761	>	{
4762	>	if (PyString_Check(obj1)) {
4763	>	temp2 = std::string(PyString_AsString(obj1));
4764	>	arg2 = &temp2;
4765	>	}else {
4766	>	SWIG_exception(SWIG_TypeError, "string expected");
4767	>	}
4768		}
4769	<	if (!ptr) {
4770	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
4769	>	if (obj2) {
4770	>	arg3 = PyInt_AsLong(obj2) ? true : false;
4771	>	if (PyErr_Occurred()) SWIG_fail;
4772		}
4773	<	arg2 = ptr;
4774	<	}
4775	<	{
4776	<	try {
4777	<	result = (int)(arg1)->getAllOutput((std::string const &)*arg2);
4778	<	} catch (const std::exception& e) {
4779	<	SWIG_exception(SWIG_RuntimeError, e.what());
4780	<	}
4781	<	}
4782	<	resultobj = SWIG_From_int(static_cast< int >(result));
4783	<	if (SWIG_IsNewObj(res2)) delete arg2;
17527	<	return resultobj;
17528	<	fail:
17529	<	if (SWIG_IsNewObj(res2)) delete arg2;
17530	<	return NULL;
17531	<	}
17532	<
17533	<
17534	<	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17535	<	PyObject *resultobj = 0;
17536	<	BossTask *arg1 = (BossTask *) 0 ;
17537	<	int result;
17538	<	void *argp1 = 0 ;
17539	<	int res1 = 0 ;
17540	<	PyObject * obj0 = 0 ;
17541	<
17542	<	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_getAllOutput",&obj0)) SWIG_fail;
17543	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17544	<	if (!SWIG_IsOK(res1)) {
17545	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getAllOutput" "', argument " "1"" of type '" "BossTask *""'");
17546	<	}
17547	<	arg1 = reinterpret_cast< BossTask * >(argp1);
17548	<	{
17549	<	try {
17550	<	result = (int)(arg1)->getAllOutput();
17551	<	} catch (const std::exception& e) {
17552	<	SWIG_exception(SWIG_RuntimeError, e.what());
4773	>	{
4774	>	try {
4775	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4776	>
4777	>	}catch (const BossSchedFailure & e) {
4778	>	PyErr_SetString ( SchedulerError, e.what() );
4779	>	return NULL;
4780	>	}catch (const std::exception& e) {
4781	>	PyErr_SetString ( BossError, e.what() );
4782	>	return NULL;
4783	>	}
4784		}
4785	<	}
4786	<	resultobj = SWIG_From_int(static_cast< int >(result));
4787	<	return resultobj;
4788	<	fail:
17558	<	return NULL;
4785	>	resultobj = PyInt_FromLong((long)result);
4786	>	return resultobj;
4787	>	fail:
4788	>	return NULL;
4789		}
4790
4791
4792	<	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput(PyObject *self, PyObject *args) {
4793	<	int argc;
4794	<	PyObject *argv[5];
4795	<	int ii;
4796	<
4797	<	if (!PyTuple_Check(args)) SWIG_fail;
4798	<	argc = PyObject_Length(args);
4799	<	for (ii = 0; (ii < argc) && (ii < 4); ii++) {
4800	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4801	<	}
4802	<	if (argc == 1) {
4803	<	int _v;
4804	<	void *vptr = 0;
4805	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4806	<	_v = SWIG_CheckState(res);
4807	<	if (_v) {
4808	<	return _wrap_BossTask_getAllOutput__SWIG_3(self, args);
4809	<	}
4810	<	}
4811	<	if (argc == 2) {
4812	<	int _v;
17583	<	void *vptr = 0;
17584	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17585	<	_v = SWIG_CheckState(res);
17586	<	if (_v) {
17587	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17588	<	_v = SWIG_CheckState(res);
17589	<	if (_v) {
17590	<	return _wrap_BossTask_getAllOutput__SWIG_2(self, args);
17591	<	}
17592	<	}
17593	<	}
17594	<	if (argc == 3) {
17595	<	int _v;
17596	<	void *vptr = 0;
17597	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17598	<	_v = SWIG_CheckState(res);
17599	<	if (_v) {
17600	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17601	<	_v = SWIG_CheckState(res);
17602	<	if (_v) {
4792	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4793	>	PyObject *resultobj;
4794	>	BossTask *arg1 = (BossTask *) 0 ;
4795	>	std::string const &arg2_defvalue = "all" ;
4796	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4797	>	std::string const &arg3_defvalue = "" ;
4798	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4799	>	bool arg4 = (bool) false ;
4800	>	bool arg5 = (bool) false ;
4801	>	int result;
4802	>	std::string temp2 ;
4803	>	std::string temp3 ;
4804	>	PyObject * obj0 = 0 ;
4805	>	PyObject * obj1 = 0 ;
4806	>	PyObject * obj2 = 0 ;
4807	>	PyObject * obj3 = 0 ;
4808	>	PyObject * obj4 = 0 ;
4809	>
4810	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4811	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4812	>	if (obj1) {
4813		{
4814	<	int res = SWIG_AsVal_bool(argv[2], NULL);
4815	<	_v = SWIG_CheckState(res);
4816	<	}
4817	<	if (_v) {
4818	<	return _wrap_BossTask_getAllOutput__SWIG_1(self, args);
4814	>	if (PyString_Check(obj1)) {
4815	>	temp2 = std::string(PyString_AsString(obj1));
4816	>	arg2 = &temp2;
4817	>	}else {
4818	>	SWIG_exception(SWIG_TypeError, "string expected");
4819	>	}
4820		}
17610	–	}
4821		}
4822	<	}
17613	<	if (argc == 4) {
17614	<	int _v;
17615	<	void *vptr = 0;
17616	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17617	<	_v = SWIG_CheckState(res);
17618	<	if (_v) {
17619	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17620	<	_v = SWIG_CheckState(res);
17621	<	if (_v) {
4822	>	if (obj2) {
4823		{
4824	<	int res = SWIG_AsVal_bool(argv[2], NULL);
4825	<	_v = SWIG_CheckState(res);
4826	<	}
4827	<	if (_v) {
4828	<	{
4829	<	int res = SWIG_AsVal_bool(argv[3], NULL);
17629	<	_v = SWIG_CheckState(res);
17630	<	}
17631	<	if (_v) {
17632	<	return _wrap_BossTask_getAllOutput__SWIG_0(self, args);
17633	<	}
4824	>	if (PyString_Check(obj2)) {
4825	>	temp3 = std::string(PyString_AsString(obj2));
4826	>	arg3 = &temp3;
4827	>	}else {
4828	>	SWIG_exception(SWIG_TypeError, "string expected");
4829	>	}
4830		}
17635	–	}
17636	–	}
17637	–	}
17638	–
17639	–	fail:
17640	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_getAllOutput'");
17641	–	return NULL;
17642	–	}
17643	–
17644	–
17645	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17646	–	PyObject *resultobj = 0;
17647	–	BossTask *arg1 = (BossTask *) 0 ;
17648	–	int arg2 ;
17649	–	std::string *arg3 = 0 ;
17650	–	std::string *arg4 = 0 ;
17651	–	std::string arg5 ;
17652	–	std::string arg6 ;
17653	–	std::string arg7 ;
17654	–	std::string arg8 ;
17655	–	bool arg9 ;
17656	–	int result;
17657	–	void *argp1 = 0 ;
17658	–	int res1 = 0 ;
17659	–	int val2 ;
17660	–	int ecode2 = 0 ;
17661	–	int res3 = SWIG_OLDOBJ ;
17662	–	int res4 = SWIG_OLDOBJ ;
17663	–	bool val9 ;
17664	–	int ecode9 = 0 ;
17665	–	PyObject * obj0 = 0 ;
17666	–	PyObject * obj1 = 0 ;
17667	–	PyObject * obj2 = 0 ;
17668	–	PyObject * obj3 = 0 ;
17669	–	PyObject * obj4 = 0 ;
17670	–	PyObject * obj5 = 0 ;
17671	–	PyObject * obj6 = 0 ;
17672	–	PyObject * obj7 = 0 ;
17673	–	PyObject * obj8 = 0 ;
17674	–
17675	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
17676	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17677	–	if (!SWIG_IsOK(res1)) {
17678	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
17679	–	}
17680	–	arg1 = reinterpret_cast< BossTask * >(argp1);
17681	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
17682	–	if (!SWIG_IsOK(ecode2)) {
17683	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
17684	–	}
17685	–	arg2 = static_cast< int >(val2);
17686	–	{
17687	–	std::string *ptr = (std::string *)0;
17688	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17689	–	if (!SWIG_IsOK(res3)) {
17690	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17691	–	}
17692	–	if (!ptr) {
17693	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17694	–	}
17695	–	arg3 = ptr;
17696	–	}
17697	–	{
17698	–	std::string *ptr = (std::string *)0;
17699	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
17700	–	if (!SWIG_IsOK(res4)) {
17701	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17702	–	}
17703	–	if (!ptr) {
17704	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17705	–	}
17706	–	arg4 = ptr;
17707	–	}
17708	–	{
17709	–	std::string *ptr = (std::string *)0;
17710	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
17711	–	if (!SWIG_IsOK(res) || !ptr) {
17712	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
17713	–	}
17714	–	arg5 = *ptr;
17715	–	if (SWIG_IsNewObj(res)) delete ptr;
17716	–	}
17717	–	{
17718	–	std::string *ptr = (std::string *)0;
17719	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
17720	–	if (!SWIG_IsOK(res) || !ptr) {
17721	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "6"" of type '" "std::string""'");
17722	–	}
17723	–	arg6 = *ptr;
17724	–	if (SWIG_IsNewObj(res)) delete ptr;
17725	–	}
17726	–	{
17727	–	std::string *ptr = (std::string *)0;
17728	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
17729	–	if (!SWIG_IsOK(res) || !ptr) {
17730	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "7"" of type '" "std::string""'");
17731	–	}
17732	–	arg7 = *ptr;
17733	–	if (SWIG_IsNewObj(res)) delete ptr;
17734	–	}
17735	–	{
17736	–	std::string *ptr = (std::string *)0;
17737	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
17738	–	if (!SWIG_IsOK(res) || !ptr) {
17739	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "8"" of type '" "std::string""'");
17740	–	}
17741	–	arg8 = *ptr;
17742	–	if (SWIG_IsNewObj(res)) delete ptr;
17743	–	}
17744	–	ecode9 = SWIG_AsVal_bool(obj8, &val9);
17745	–	if (!SWIG_IsOK(ecode9)) {
17746	–	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BossTask_query" "', argument " "9"" of type '" "bool""'");
17747	–	}
17748	–	arg9 = static_cast< bool >(val9);
17749	–	{
17750	–	try {
17751	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
17752	–	} catch (const std::exception& e) {
17753	–	SWIG_exception(SWIG_RuntimeError, e.what());
17754	–	}
17755	–	}
17756	–	resultobj = SWIG_From_int(static_cast< int >(result));
17757	–	if (SWIG_IsNewObj(res3)) delete arg3;
17758	–	if (SWIG_IsNewObj(res4)) delete arg4;
17759	–	return resultobj;
17760	–	fail:
17761	–	if (SWIG_IsNewObj(res3)) delete arg3;
17762	–	if (SWIG_IsNewObj(res4)) delete arg4;
17763	–	return NULL;
17764	–	}
17765	–
17766	–
17767	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17768	–	PyObject *resultobj = 0;
17769	–	BossTask *arg1 = (BossTask *) 0 ;
17770	–	int arg2 ;
17771	–	std::string *arg3 = 0 ;
17772	–	std::string *arg4 = 0 ;
17773	–	std::string arg5 ;
17774	–	std::string arg6 ;
17775	–	std::string arg7 ;
17776	–	std::string arg8 ;
17777	–	int result;
17778	–	void *argp1 = 0 ;
17779	–	int res1 = 0 ;
17780	–	int val2 ;
17781	–	int ecode2 = 0 ;
17782	–	int res3 = SWIG_OLDOBJ ;
17783	–	int res4 = SWIG_OLDOBJ ;
17784	–	PyObject * obj0 = 0 ;
17785	–	PyObject * obj1 = 0 ;
17786	–	PyObject * obj2 = 0 ;
17787	–	PyObject * obj3 = 0 ;
17788	–	PyObject * obj4 = 0 ;
17789	–	PyObject * obj5 = 0 ;
17790	–	PyObject * obj6 = 0 ;
17791	–	PyObject * obj7 = 0 ;
17792	–
17793	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
17794	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17795	–	if (!SWIG_IsOK(res1)) {
17796	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
17797	–	}
17798	–	arg1 = reinterpret_cast< BossTask * >(argp1);
17799	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
17800	–	if (!SWIG_IsOK(ecode2)) {
17801	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
17802	–	}
17803	–	arg2 = static_cast< int >(val2);
17804	–	{
17805	–	std::string *ptr = (std::string *)0;
17806	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17807	–	if (!SWIG_IsOK(res3)) {
17808	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17809	–	}
17810	–	if (!ptr) {
17811	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17812	–	}
17813	–	arg3 = ptr;
17814	–	}
17815	–	{
17816	–	std::string *ptr = (std::string *)0;
17817	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
17818	–	if (!SWIG_IsOK(res4)) {
17819	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17820	–	}
17821	–	if (!ptr) {
17822	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17823	–	}
17824	–	arg4 = ptr;
17825	–	}
17826	–	{
17827	–	std::string *ptr = (std::string *)0;
17828	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
17829	–	if (!SWIG_IsOK(res) || !ptr) {
17830	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
17831	–	}
17832	–	arg5 = *ptr;
17833	–	if (SWIG_IsNewObj(res)) delete ptr;
17834	–	}
17835	–	{
17836	–	std::string *ptr = (std::string *)0;
17837	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
17838	–	if (!SWIG_IsOK(res) || !ptr) {
17839	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "6"" of type '" "std::string""'");
17840	–	}
17841	–	arg6 = *ptr;
17842	–	if (SWIG_IsNewObj(res)) delete ptr;
17843	–	}
17844	–	{
17845	–	std::string *ptr = (std::string *)0;
17846	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
17847	–	if (!SWIG_IsOK(res) || !ptr) {
17848	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "7"" of type '" "std::string""'");
17849	–	}
17850	–	arg7 = *ptr;
17851	–	if (SWIG_IsNewObj(res)) delete ptr;
17852	–	}
17853	–	{
17854	–	std::string *ptr = (std::string *)0;
17855	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
17856	–	if (!SWIG_IsOK(res) || !ptr) {
17857	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "8"" of type '" "std::string""'");
17858	–	}
17859	–	arg8 = *ptr;
17860	–	if (SWIG_IsNewObj(res)) delete ptr;
17861	–	}
17862	–	{
17863	–	try {
17864	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
17865	–	} catch (const std::exception& e) {
17866	–	SWIG_exception(SWIG_RuntimeError, e.what());
17867	–	}
17868	–	}
17869	–	resultobj = SWIG_From_int(static_cast< int >(result));
17870	–	if (SWIG_IsNewObj(res3)) delete arg3;
17871	–	if (SWIG_IsNewObj(res4)) delete arg4;
17872	–	return resultobj;
17873	–	fail:
17874	–	if (SWIG_IsNewObj(res3)) delete arg3;
17875	–	if (SWIG_IsNewObj(res4)) delete arg4;
17876	–	return NULL;
17877	–	}
17878	–
17879	–
17880	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17881	–	PyObject *resultobj = 0;
17882	–	BossTask *arg1 = (BossTask *) 0 ;
17883	–	int arg2 ;
17884	–	std::string *arg3 = 0 ;
17885	–	std::string *arg4 = 0 ;
17886	–	std::string arg5 ;
17887	–	std::string arg6 ;
17888	–	std::string arg7 ;
17889	–	int result;
17890	–	void *argp1 = 0 ;
17891	–	int res1 = 0 ;
17892	–	int val2 ;
17893	–	int ecode2 = 0 ;
17894	–	int res3 = SWIG_OLDOBJ ;
17895	–	int res4 = SWIG_OLDOBJ ;
17896	–	PyObject * obj0 = 0 ;
17897	–	PyObject * obj1 = 0 ;
17898	–	PyObject * obj2 = 0 ;
17899	–	PyObject * obj3 = 0 ;
17900	–	PyObject * obj4 = 0 ;
17901	–	PyObject * obj5 = 0 ;
17902	–	PyObject * obj6 = 0 ;
17903	–
17904	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
17905	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17906	–	if (!SWIG_IsOK(res1)) {
17907	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
17908	–	}
17909	–	arg1 = reinterpret_cast< BossTask * >(argp1);
17910	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
17911	–	if (!SWIG_IsOK(ecode2)) {
17912	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
17913	–	}
17914	–	arg2 = static_cast< int >(val2);
17915	–	{
17916	–	std::string *ptr = (std::string *)0;
17917	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17918	–	if (!SWIG_IsOK(res3)) {
17919	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17920	–	}
17921	–	if (!ptr) {
17922	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17923	–	}
17924	–	arg3 = ptr;
17925	–	}
17926	–	{
17927	–	std::string *ptr = (std::string *)0;
17928	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
17929	–	if (!SWIG_IsOK(res4)) {
17930	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17931	–	}
17932	–	if (!ptr) {
17933	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17934	–	}
17935	–	arg4 = ptr;
17936	–	}
17937	–	{
17938	–	std::string *ptr = (std::string *)0;
17939	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
17940	–	if (!SWIG_IsOK(res) || !ptr) {
17941	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
17942	–	}
17943	–	arg5 = *ptr;
17944	–	if (SWIG_IsNewObj(res)) delete ptr;
17945	–	}
17946	–	{
17947	–	std::string *ptr = (std::string *)0;
17948	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
17949	–	if (!SWIG_IsOK(res) || !ptr) {
17950	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "6"" of type '" "std::string""'");
17951	–	}
17952	–	arg6 = *ptr;
17953	–	if (SWIG_IsNewObj(res)) delete ptr;
17954	–	}
17955	–	{
17956	–	std::string *ptr = (std::string *)0;
17957	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
17958	–	if (!SWIG_IsOK(res) || !ptr) {
17959	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "7"" of type '" "std::string""'");
17960	–	}
17961	–	arg7 = *ptr;
17962	–	if (SWIG_IsNewObj(res)) delete ptr;
17963	–	}
17964	–	{
17965	–	try {
17966	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7);
17967	–	} catch (const std::exception& e) {
17968	–	SWIG_exception(SWIG_RuntimeError, e.what());
17969	–	}
17970	–	}
17971	–	resultobj = SWIG_From_int(static_cast< int >(result));
17972	–	if (SWIG_IsNewObj(res3)) delete arg3;
17973	–	if (SWIG_IsNewObj(res4)) delete arg4;
17974	–	return resultobj;
17975	–	fail:
17976	–	if (SWIG_IsNewObj(res3)) delete arg3;
17977	–	if (SWIG_IsNewObj(res4)) delete arg4;
17978	–	return NULL;
17979	–	}
17980	–
17981	–
17982	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17983	–	PyObject *resultobj = 0;
17984	–	BossTask *arg1 = (BossTask *) 0 ;
17985	–	int arg2 ;
17986	–	std::string *arg3 = 0 ;
17987	–	std::string *arg4 = 0 ;
17988	–	std::string arg5 ;
17989	–	std::string arg6 ;
17990	–	int result;
17991	–	void *argp1 = 0 ;
17992	–	int res1 = 0 ;
17993	–	int val2 ;
17994	–	int ecode2 = 0 ;
17995	–	int res3 = SWIG_OLDOBJ ;
17996	–	int res4 = SWIG_OLDOBJ ;
17997	–	PyObject * obj0 = 0 ;
17998	–	PyObject * obj1 = 0 ;
17999	–	PyObject * obj2 = 0 ;
18000	–	PyObject * obj3 = 0 ;
18001	–	PyObject * obj4 = 0 ;
18002	–	PyObject * obj5 = 0 ;
18003	–
18004	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18005	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18006	–	if (!SWIG_IsOK(res1)) {
18007	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
18008	–	}
18009	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18010	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
18011	–	if (!SWIG_IsOK(ecode2)) {
18012	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
18013	–	}
18014	–	arg2 = static_cast< int >(val2);
18015	–	{
18016	–	std::string *ptr = (std::string *)0;
18017	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
18018	–	if (!SWIG_IsOK(res3)) {
18019	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18020	–	}
18021	–	if (!ptr) {
18022	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18023	–	}
18024	–	arg3 = ptr;
18025	–	}
18026	–	{
18027	–	std::string *ptr = (std::string *)0;
18028	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
18029	–	if (!SWIG_IsOK(res4)) {
18030	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18031	–	}
18032	–	if (!ptr) {
18033	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18034	–	}
18035	–	arg4 = ptr;
18036	–	}
18037	–	{
18038	–	std::string *ptr = (std::string *)0;
18039	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
18040	–	if (!SWIG_IsOK(res) || !ptr) {
18041	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
18042	–	}
18043	–	arg5 = *ptr;
18044	–	if (SWIG_IsNewObj(res)) delete ptr;
18045	–	}
18046	–	{
18047	–	std::string *ptr = (std::string *)0;
18048	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
18049	–	if (!SWIG_IsOK(res) || !ptr) {
18050	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "6"" of type '" "std::string""'");
18051	–	}
18052	–	arg6 = *ptr;
18053	–	if (SWIG_IsNewObj(res)) delete ptr;
18054	–	}
18055	–	{
18056	–	try {
18057	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6);
18058	–	} catch (const std::exception& e) {
18059	–	SWIG_exception(SWIG_RuntimeError, e.what());
18060	–	}
18061	–	}
18062	–	resultobj = SWIG_From_int(static_cast< int >(result));
18063	–	if (SWIG_IsNewObj(res3)) delete arg3;
18064	–	if (SWIG_IsNewObj(res4)) delete arg4;
18065	–	return resultobj;
18066	–	fail:
18067	–	if (SWIG_IsNewObj(res3)) delete arg3;
18068	–	if (SWIG_IsNewObj(res4)) delete arg4;
18069	–	return NULL;
18070	–	}
18071	–
18072	–
18073	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18074	–	PyObject *resultobj = 0;
18075	–	BossTask *arg1 = (BossTask *) 0 ;
18076	–	int arg2 ;
18077	–	std::string *arg3 = 0 ;
18078	–	std::string *arg4 = 0 ;
18079	–	std::string arg5 ;
18080	–	int result;
18081	–	void *argp1 = 0 ;
18082	–	int res1 = 0 ;
18083	–	int val2 ;
18084	–	int ecode2 = 0 ;
18085	–	int res3 = SWIG_OLDOBJ ;
18086	–	int res4 = SWIG_OLDOBJ ;
18087	–	PyObject * obj0 = 0 ;
18088	–	PyObject * obj1 = 0 ;
18089	–	PyObject * obj2 = 0 ;
18090	–	PyObject * obj3 = 0 ;
18091	–	PyObject * obj4 = 0 ;
18092	–
18093	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18094	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18095	–	if (!SWIG_IsOK(res1)) {
18096	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
18097	–	}
18098	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18099	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
18100	–	if (!SWIG_IsOK(ecode2)) {
18101	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
18102	–	}
18103	–	arg2 = static_cast< int >(val2);
18104	–	{
18105	–	std::string *ptr = (std::string *)0;
18106	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
18107	–	if (!SWIG_IsOK(res3)) {
18108	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18109	–	}
18110	–	if (!ptr) {
18111	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18112	–	}
18113	–	arg3 = ptr;
18114	–	}
18115	–	{
18116	–	std::string *ptr = (std::string *)0;
18117	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
18118	–	if (!SWIG_IsOK(res4)) {
18119	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18120	–	}
18121	–	if (!ptr) {
18122	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18123	–	}
18124	–	arg4 = ptr;
18125	–	}
18126	–	{
18127	–	std::string *ptr = (std::string *)0;
18128	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
18129	–	if (!SWIG_IsOK(res) || !ptr) {
18130	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
18131	–	}
18132	–	arg5 = *ptr;
18133	–	if (SWIG_IsNewObj(res)) delete ptr;
18134	–	}
18135	–	{
18136	–	try {
18137	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
18138	–	} catch (const std::exception& e) {
18139	–	SWIG_exception(SWIG_RuntimeError, e.what());
18140	–	}
18141	–	}
18142	–	resultobj = SWIG_From_int(static_cast< int >(result));
18143	–	if (SWIG_IsNewObj(res3)) delete arg3;
18144	–	if (SWIG_IsNewObj(res4)) delete arg4;
18145	–	return resultobj;
18146	–	fail:
18147	–	if (SWIG_IsNewObj(res3)) delete arg3;
18148	–	if (SWIG_IsNewObj(res4)) delete arg4;
18149	–	return NULL;
18150	–	}
18151	–
18152	–
18153	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18154	–	PyObject *resultobj = 0;
18155	–	BossTask *arg1 = (BossTask *) 0 ;
18156	–	int arg2 ;
18157	–	std::string *arg3 = 0 ;
18158	–	std::string *arg4 = 0 ;
18159	–	int result;
18160	–	void *argp1 = 0 ;
18161	–	int res1 = 0 ;
18162	–	int val2 ;
18163	–	int ecode2 = 0 ;
18164	–	int res3 = SWIG_OLDOBJ ;
18165	–	int res4 = SWIG_OLDOBJ ;
18166	–	PyObject * obj0 = 0 ;
18167	–	PyObject * obj1 = 0 ;
18168	–	PyObject * obj2 = 0 ;
18169	–	PyObject * obj3 = 0 ;
18170	–
18171	–	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18172	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18173	–	if (!SWIG_IsOK(res1)) {
18174	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
18175	–	}
18176	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18177	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
18178	–	if (!SWIG_IsOK(ecode2)) {
18179	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
18180	–	}
18181	–	arg2 = static_cast< int >(val2);
18182	–	{
18183	–	std::string *ptr = (std::string *)0;
18184	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
18185	–	if (!SWIG_IsOK(res3)) {
18186	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18187	–	}
18188	–	if (!ptr) {
18189	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18190	–	}
18191	–	arg3 = ptr;
18192	–	}
18193	–	{
18194	–	std::string *ptr = (std::string *)0;
18195	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
18196	–	if (!SWIG_IsOK(res4)) {
18197	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18198	–	}
18199	–	if (!ptr) {
18200	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18201	–	}
18202	–	arg4 = ptr;
18203	–	}
18204	–	{
18205	–	try {
18206	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
18207	–	} catch (const std::exception& e) {
18208	–	SWIG_exception(SWIG_RuntimeError, e.what());
18209	–	}
18210	–	}
18211	–	resultobj = SWIG_From_int(static_cast< int >(result));
18212	–	if (SWIG_IsNewObj(res3)) delete arg3;
18213	–	if (SWIG_IsNewObj(res4)) delete arg4;
18214	–	return resultobj;
18215	–	fail:
18216	–	if (SWIG_IsNewObj(res3)) delete arg3;
18217	–	if (SWIG_IsNewObj(res4)) delete arg4;
18218	–	return NULL;
18219	–	}
18220	–
18221	–
18222	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18223	–	PyObject *resultobj = 0;
18224	–	BossTask *arg1 = (BossTask *) 0 ;
18225	–	int arg2 ;
18226	–	std::string *arg3 = 0 ;
18227	–	int result;
18228	–	void *argp1 = 0 ;
18229	–	int res1 = 0 ;
18230	–	int val2 ;
18231	–	int ecode2 = 0 ;
18232	–	int res3 = SWIG_OLDOBJ ;
18233	–	PyObject * obj0 = 0 ;
18234	–	PyObject * obj1 = 0 ;
18235	–	PyObject * obj2 = 0 ;
18236	–
18237	–	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_query",&obj0,&obj1,&obj2)) SWIG_fail;
18238	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18239	–	if (!SWIG_IsOK(res1)) {
18240	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
18241	–	}
18242	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18243	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
18244	–	if (!SWIG_IsOK(ecode2)) {
18245	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
18246	–	}
18247	–	arg2 = static_cast< int >(val2);
18248	–	{
18249	–	std::string *ptr = (std::string *)0;
18250	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
18251	–	if (!SWIG_IsOK(res3)) {
18252	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
4831		}
4832	<	if (!ptr) {
4833	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
4832	>	if (obj3) {
4833	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4834	>	if (PyErr_Occurred()) SWIG_fail;
4835		}
4836	<	arg3 = ptr;
4837	<	}
4838	<	{
18260	<	try {
18261	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3);
18262	<	} catch (const std::exception& e) {
18263	<	SWIG_exception(SWIG_RuntimeError, e.what());
4836	>	if (obj4) {
4837	>	arg5 = PyInt_AsLong(obj4) ? true : false;
4838	>	if (PyErr_Occurred()) SWIG_fail;
4839		}
4840	<	}
4841	<	resultobj = SWIG_From_int(static_cast< int >(result));
4842	<	if (SWIG_IsNewObj(res3)) delete arg3;
4843	<	return resultobj;
4844	<	fail:
4845	<	if (SWIG_IsNewObj(res3)) delete arg3;
4846	<	return NULL;
4847	<	}
4848	<
4849	<
4850	<	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18276	<	PyObject *resultobj = 0;
18277	<	BossTask *arg1 = (BossTask *) 0 ;
18278	<	int arg2 ;
18279	<	int result;
18280	<	void *argp1 = 0 ;
18281	<	int res1 = 0 ;
18282	<	int val2 ;
18283	<	int ecode2 = 0 ;
18284	<	PyObject * obj0 = 0 ;
18285	<	PyObject * obj1 = 0 ;
18286	<
18287	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_query",&obj0,&obj1)) SWIG_fail;
18288	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18289	<	if (!SWIG_IsOK(res1)) {
18290	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
18291	<	}
18292	<	arg1 = reinterpret_cast< BossTask * >(argp1);
18293	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
18294	<	if (!SWIG_IsOK(ecode2)) {
18295	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
18296	<	}
18297	<	arg2 = static_cast< int >(val2);
18298	<	{
18299	<	try {
18300	<	result = (int)(arg1)->query(arg2);
18301	<	} catch (const std::exception& e) {
18302	<	SWIG_exception(SWIG_RuntimeError, e.what());
18303	<	}
18304	<	}
18305	<	resultobj = SWIG_From_int(static_cast< int >(result));
18306	<	return resultobj;
18307	<	fail:
18308	<	return NULL;
18309	<	}
18310	<
18311	<
18312	<	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18313	<	PyObject *resultobj = 0;
18314	<	BossTask *arg1 = (BossTask *) 0 ;
18315	<	int result;
18316	<	void *argp1 = 0 ;
18317	<	int res1 = 0 ;
18318	<	PyObject * obj0 = 0 ;
18319	<
18320	<	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_query",&obj0)) SWIG_fail;
18321	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18322	<	if (!SWIG_IsOK(res1)) {
18323	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
18324	<	}
18325	<	arg1 = reinterpret_cast< BossTask * >(argp1);
18326	<	{
18327	<	try {
18328	<	result = (int)(arg1)->query();
18329	<	} catch (const std::exception& e) {
18330	<	SWIG_exception(SWIG_RuntimeError, e.what());
4840	>	{
4841	>	try {
4842	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4843	>
4844	>	}catch (const BossSchedFailure & e) {
4845	>	PyErr_SetString ( SchedulerError, e.what() );
4846	>	return NULL;
4847	>	}catch (const std::exception& e) {
4848	>	PyErr_SetString ( BossError, e.what() );
4849	>	return NULL;
4850	>	}
4851		}
4852	<	}
4853	<	resultobj = SWIG_From_int(static_cast< int >(result));
4854	<	return resultobj;
4855	<	fail:
18336	<	return NULL;
4852	>	resultobj = PyInt_FromLong((long)result);
4853	>	return resultobj;
4854	>	fail:
4855	>	return NULL;
4856		}
4857
4858
4859	<	SWIGINTERN PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
4860	<	int argc;
4861	<	PyObject *argv[10];
4862	<	int ii;
4863	<
4864	<	if (!PyTuple_Check(args)) SWIG_fail;
4865	<	argc = PyObject_Length(args);
4866	<	for (ii = 0; (ii < argc) && (ii < 9); ii++) {
4867	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4868	<	}
4869	<	if (argc == 1) {
4870	<	int _v;
4871	<	void *vptr = 0;
4872	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4873	<	_v = SWIG_CheckState(res);
4874	<	if (_v) {
4875	<	return _wrap_BossTask_query__SWIG_8(self, args);
4876	<	}
4877	<	}
4878	<	if (argc == 2) {
4879	<	int _v;
4880	<	void *vptr = 0;
4881	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4882	<	_v = SWIG_CheckState(res);
4883	<	if (_v) {
4884	<	{
4885	<	int res = SWIG_AsVal_int(argv[1], NULL);
4886	<	_v = SWIG_CheckState(res);
4887	<	}
4888	<	if (_v) {
4889	<	return _wrap_BossTask_query__SWIG_7(self, args);
4890	<	}
18372	<	}
18373	<	}
18374	<	if (argc == 3) {
18375	<	int _v;
18376	<	void *vptr = 0;
18377	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18378	<	_v = SWIG_CheckState(res);
18379	<	if (_v) {
18380	<	{
18381	<	int res = SWIG_AsVal_int(argv[1], NULL);
18382	<	_v = SWIG_CheckState(res);
18383	<	}
18384	<	if (_v) {
18385	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
18386	<	_v = SWIG_CheckState(res);
18387	<	if (_v) {
18388	<	return _wrap_BossTask_query__SWIG_6(self, args);
18389	<	}
18390	<	}
18391	<	}
18392	<	}
18393	<	if (argc == 4) {
18394	<	int _v;
18395	<	void *vptr = 0;
18396	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18397	<	_v = SWIG_CheckState(res);
18398	<	if (_v) {
18399	<	{
18400	<	int res = SWIG_AsVal_int(argv[1], NULL);
18401	<	_v = SWIG_CheckState(res);
18402	<	}
18403	<	if (_v) {
18404	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
18405	<	_v = SWIG_CheckState(res);
18406	<	if (_v) {
18407	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
18408	<	_v = SWIG_CheckState(res);
18409	<	if (_v) {
18410	<	return _wrap_BossTask_query__SWIG_5(self, args);
18411	<	}
18412	<	}
18413	<	}
18414	<	}
18415	<	}
18416	<	if (argc == 5) {
18417	<	int _v;
18418	<	void *vptr = 0;
18419	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18420	<	_v = SWIG_CheckState(res);
18421	<	if (_v) {
18422	<	{
18423	<	int res = SWIG_AsVal_int(argv[1], NULL);
18424	<	_v = SWIG_CheckState(res);
18425	<	}
18426	<	if (_v) {
18427	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
18428	<	_v = SWIG_CheckState(res);
18429	<	if (_v) {
18430	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
18431	<	_v = SWIG_CheckState(res);
18432	<	if (_v) {
18433	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
18434	<	_v = SWIG_CheckState(res);
18435	<	if (_v) {
18436	<	return _wrap_BossTask_query__SWIG_4(self, args);
4859	>	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4860	>	PyObject *resultobj;
4861	>	BossTask *arg1 = (BossTask *) 0 ;
4862	>	int arg2 = (int) SCHEDULED ;
4863	>	std::string const &arg3_defvalue = "all" ;
4864	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4865	>	std::string const &arg4_defvalue = "" ;
4866	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4867	>	std::string arg5 = (std::string) "" ;
4868	>	std::string arg6 = (std::string) "" ;
4869	>	std::string arg7 = (std::string) "" ;
4870	>	std::string arg8 = (std::string) "" ;
4871	>	int result;
4872	>	std::string temp3 ;
4873	>	std::string temp4 ;
4874	>	PyObject * obj0 = 0 ;
4875	>	PyObject * obj2 = 0 ;
4876	>	PyObject * obj3 = 0 ;
4877	>	PyObject * obj4 = 0 ;
4878	>	PyObject * obj5 = 0 ;
4879	>	PyObject * obj6 = 0 ;
4880	>	PyObject * obj7 = 0 ;
4881	>
4882	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4883	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4884	>	if (obj2) {
4885	>	{
4886	>	if (PyString_Check(obj2)) {
4887	>	temp3 = std::string(PyString_AsString(obj2));
4888	>	arg3 = &temp3;
4889	>	}else {
4890	>	SWIG_exception(SWIG_TypeError, "string expected");
4891		}
18438	–	}
4892		}
18440	–	}
4893		}
4894	<	}
4895	<	if (argc == 6) {
4896	<	int _v;
4897	<	void *vptr = 0;
4898	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4899	<	_v = SWIG_CheckState(res);
4900	<	if (_v) {
18449	<	{
18450	<	int res = SWIG_AsVal_int(argv[1], NULL);
18451	<	_v = SWIG_CheckState(res);
18452	<	}
18453	<	if (_v) {
18454	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
18455	<	_v = SWIG_CheckState(res);
18456	<	if (_v) {
18457	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
18458	<	_v = SWIG_CheckState(res);
18459	<	if (_v) {
18460	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
18461	<	_v = SWIG_CheckState(res);
18462	<	if (_v) {
18463	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
18464	<	_v = SWIG_CheckState(res);
18465	<	if (_v) {
18466	<	return _wrap_BossTask_query__SWIG_3(self, args);
18467	<	}
4894	>	if (obj3) {
4895	>	{
4896	>	if (PyString_Check(obj3)) {
4897	>	temp4 = std::string(PyString_AsString(obj3));
4898	>	arg4 = &temp4;
4899	>	}else {
4900	>	SWIG_exception(SWIG_TypeError, "string expected");
4901		}
18469	–	}
4902		}
18471	–	}
4903		}
4904	<	}
4905	<	if (argc == 7) {
4906	<	int _v;
4907	<	void *vptr = 0;
4908	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4909	<	_v = SWIG_CheckState(res);
18479	<	if (_v) {
18480	<	{
18481	<	int res = SWIG_AsVal_int(argv[1], NULL);
18482	<	_v = SWIG_CheckState(res);
18483	<	}
18484	<	if (_v) {
18485	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
18486	<	_v = SWIG_CheckState(res);
18487	<	if (_v) {
18488	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
18489	<	_v = SWIG_CheckState(res);
18490	<	if (_v) {
18491	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
18492	<	_v = SWIG_CheckState(res);
18493	<	if (_v) {
18494	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
18495	<	_v = SWIG_CheckState(res);
18496	<	if (_v) {
18497	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
18498	<	_v = SWIG_CheckState(res);
18499	<	if (_v) {
18500	<	return _wrap_BossTask_query__SWIG_2(self, args);
18501	<	}
18502	<	}
18503	<	}
18504	<	}
4904	>	if (obj4) {
4905	>	{
4906	>	if (PyString_Check(obj4))
4907	>	arg5 = std::string(PyString_AsString(obj4));
4908	>	else
4909	>	SWIG_exception(SWIG_TypeError, "string expected");
4910		}
18506	–	}
4911		}
4912	<	}
4913	<	if (argc == 8) {
4914	<	int _v;
4915	<	void *vptr = 0;
4916	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4917	<	_v = SWIG_CheckState(res);
18514	<	if (_v) {
18515	<	{
18516	<	int res = SWIG_AsVal_int(argv[1], NULL);
18517	<	_v = SWIG_CheckState(res);
18518	<	}
18519	<	if (_v) {
18520	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
18521	<	_v = SWIG_CheckState(res);
18522	<	if (_v) {
18523	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
18524	<	_v = SWIG_CheckState(res);
18525	<	if (_v) {
18526	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
18527	<	_v = SWIG_CheckState(res);
18528	<	if (_v) {
18529	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
18530	<	_v = SWIG_CheckState(res);
18531	<	if (_v) {
18532	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
18533	<	_v = SWIG_CheckState(res);
18534	<	if (_v) {
18535	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
18536	<	_v = SWIG_CheckState(res);
18537	<	if (_v) {
18538	<	return _wrap_BossTask_query__SWIG_1(self, args);
18539	<	}
18540	<	}
18541	<	}
18542	<	}
18543	<	}
4912	>	if (obj5) {
4913	>	{
4914	>	if (PyString_Check(obj5))
4915	>	arg6 = std::string(PyString_AsString(obj5));
4916	>	else
4917	>	SWIG_exception(SWIG_TypeError, "string expected");
4918		}
18545	–	}
4919		}
4920	<	}
4921	<	if (argc == 9) {
4922	<	int _v;
4923	<	void *vptr = 0;
4924	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4925	<	_v = SWIG_CheckState(res);
18553	<	if (_v) {
18554	<	{
18555	<	int res = SWIG_AsVal_int(argv[1], NULL);
18556	<	_v = SWIG_CheckState(res);
18557	<	}
18558	<	if (_v) {
18559	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
18560	<	_v = SWIG_CheckState(res);
18561	<	if (_v) {
18562	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
18563	<	_v = SWIG_CheckState(res);
18564	<	if (_v) {
18565	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
18566	<	_v = SWIG_CheckState(res);
18567	<	if (_v) {
18568	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
18569	<	_v = SWIG_CheckState(res);
18570	<	if (_v) {
18571	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
18572	<	_v = SWIG_CheckState(res);
18573	<	if (_v) {
18574	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
18575	<	_v = SWIG_CheckState(res);
18576	<	if (_v) {
18577	<	{
18578	<	int res = SWIG_AsVal_bool(argv[8], NULL);
18579	<	_v = SWIG_CheckState(res);
18580	<	}
18581	<	if (_v) {
18582	<	return _wrap_BossTask_query__SWIG_0(self, args);
18583	<	}
18584	<	}
18585	<	}
18586	<	}
18587	<	}
18588	<	}
4920	>	if (obj6) {
4921	>	{
4922	>	if (PyString_Check(obj6))
4923	>	arg7 = std::string(PyString_AsString(obj6));
4924	>	else
4925	>	SWIG_exception(SWIG_TypeError, "string expected");
4926		}
18590	–	}
18591	–	}
18592	–	}
18593	–
18594	–	fail:
18595	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_query'");
18596	–	return NULL;
18597	–	}
18598	–
18599	–
18600	–	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18601	–	PyObject *resultobj = 0;
18602	–	BossTask *arg1 = (BossTask *) 0 ;
18603	–	std::ostream *arg2 = 0 ;
18604	–	jobStates *arg3 = 0 ;
18605	–	printOption *arg4 = 0 ;
18606	–	std::string arg5 ;
18607	–	void *argp1 = 0 ;
18608	–	int res1 = 0 ;
18609	–	void *argp2 = 0 ;
18610	–	int res2 = 0 ;
18611	–	int val3 ;
18612	–	int ecode3 ;
18613	–	jobStates temp3 ;
18614	–	int val4 ;
18615	–	int ecode4 ;
18616	–	printOption temp4 ;
18617	–	PyObject * obj0 = 0 ;
18618	–	PyObject * obj1 = 0 ;
18619	–	PyObject * obj2 = 0 ;
18620	–	PyObject * obj3 = 0 ;
18621	–	PyObject * obj4 = 0 ;
18622	–
18623	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossTask_query_out",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18624	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18625	–	if (!SWIG_IsOK(res1)) {
18626	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query_out" "', argument " "1"" of type '" "BossTask const *""'");
18627	–	}
18628	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18629	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream,  0 );
18630	–	if (!SWIG_IsOK(res2)) {
18631	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18632	–	}
18633	–	if (!argp2) {
18634	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18635	–	}
18636	–	arg2 = reinterpret_cast< std::ostream * >(argp2);
18637	–	ecode3 = SWIG_AsVal_int (obj2, &val3);
18638	–	if (!SWIG_IsOK(ecode3)) {
18639	–	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_query_out" "', argument " "3"" of type '" "jobStates const &""'");
18640	–	} else {
18641	–	temp3 = static_cast< jobStates >(val3);
18642	–	arg3 = &temp3;
18643	–	}
18644	–	ecode4 = SWIG_AsVal_int (obj3, &val4);
18645	–	if (!SWIG_IsOK(ecode4)) {
18646	–	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_query_out" "', argument " "4"" of type '" "printOption const &""'");
18647	–	} else {
18648	–	temp4 = static_cast< printOption >(val4);
18649	–	arg4 = &temp4;
18650	–	}
18651	–	{
18652	–	std::string *ptr = (std::string *)0;
18653	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
18654	–	if (!SWIG_IsOK(res) || !ptr) {
18655	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query_out" "', argument " "5"" of type '" "std::string""'");
18656	–	}
18657	–	arg5 = *ptr;
18658	–	if (SWIG_IsNewObj(res)) delete ptr;
18659	–	}
18660	–	{
18661	–	try {
18662	–	((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
18663	–	} catch (const std::exception& e) {
18664	–	SWIG_exception(SWIG_RuntimeError, e.what());
4927		}
4928	<	}
4929	<	resultobj = SWIG_Py_Void();
4930	<	return resultobj;
4931	<	fail:
4932	<	return NULL;
4933	<	}
4934	<
18673	<
18674	<	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18675	<	PyObject *resultobj = 0;
18676	<	BossTask *arg1 = (BossTask *) 0 ;
18677	<	std::ostream *arg2 = 0 ;
18678	<	jobStates *arg3 = 0 ;
18679	<	printOption *arg4 = 0 ;
18680	<	void *argp1 = 0 ;
18681	<	int res1 = 0 ;
18682	<	void *argp2 = 0 ;
18683	<	int res2 = 0 ;
18684	<	int val3 ;
18685	<	int ecode3 ;
18686	<	jobStates temp3 ;
18687	<	int val4 ;
18688	<	int ecode4 ;
18689	<	printOption temp4 ;
18690	<	PyObject * obj0 = 0 ;
18691	<	PyObject * obj1 = 0 ;
18692	<	PyObject * obj2 = 0 ;
18693	<	PyObject * obj3 = 0 ;
18694	<
18695	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossTask_query_out",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18696	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18697	<	if (!SWIG_IsOK(res1)) {
18698	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query_out" "', argument " "1"" of type '" "BossTask const *""'");
18699	<	}
18700	<	arg1 = reinterpret_cast< BossTask * >(argp1);
18701	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream,  0 );
18702	<	if (!SWIG_IsOK(res2)) {
18703	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18704	<	}
18705	<	if (!argp2) {
18706	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18707	<	}
18708	<	arg2 = reinterpret_cast< std::ostream * >(argp2);
18709	<	ecode3 = SWIG_AsVal_int (obj2, &val3);
18710	<	if (!SWIG_IsOK(ecode3)) {
18711	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_query_out" "', argument " "3"" of type '" "jobStates const &""'");
18712	<	} else {
18713	<	temp3 = static_cast< jobStates >(val3);
18714	<	arg3 = &temp3;
18715	<	}
18716	<	ecode4 = SWIG_AsVal_int (obj3, &val4);
18717	<	if (!SWIG_IsOK(ecode4)) {
18718	<	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_query_out" "', argument " "4"" of type '" "printOption const &""'");
18719	<	} else {
18720	<	temp4 = static_cast< printOption >(val4);
18721	<	arg4 = &temp4;
18722	<	}
18723	<	{
18724	<	try {
18725	<	((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4);
18726	<	} catch (const std::exception& e) {
18727	<	SWIG_exception(SWIG_RuntimeError, e.what());
18728	<	}
18729	<	}
18730	<	resultobj = SWIG_Py_Void();
18731	<	return resultobj;
18732	<	fail:
18733	<	return NULL;
18734	<	}
18735	<
18736	<
18737	<	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18738	<	PyObject *resultobj = 0;
18739	<	BossTask *arg1 = (BossTask *) 0 ;
18740	<	std::ostream *arg2 = 0 ;
18741	<	jobStates *arg3 = 0 ;
18742	<	void *argp1 = 0 ;
18743	<	int res1 = 0 ;
18744	<	void *argp2 = 0 ;
18745	<	int res2 = 0 ;
18746	<	int val3 ;
18747	<	int ecode3 ;
18748	<	jobStates temp3 ;
18749	<	PyObject * obj0 = 0 ;
18750	<	PyObject * obj1 = 0 ;
18751	<	PyObject * obj2 = 0 ;
18752	<
18753	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_query_out",&obj0,&obj1,&obj2)) SWIG_fail;
18754	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18755	<	if (!SWIG_IsOK(res1)) {
18756	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query_out" "', argument " "1"" of type '" "BossTask const *""'");
18757	<	}
18758	<	arg1 = reinterpret_cast< BossTask * >(argp1);
18759	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream,  0 );
18760	<	if (!SWIG_IsOK(res2)) {
18761	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18762	<	}
18763	<	if (!argp2) {
18764	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18765	<	}
18766	<	arg2 = reinterpret_cast< std::ostream * >(argp2);
18767	<	ecode3 = SWIG_AsVal_int (obj2, &val3);
18768	<	if (!SWIG_IsOK(ecode3)) {
18769	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_query_out" "', argument " "3"" of type '" "jobStates const &""'");
18770	<	} else {
18771	<	temp3 = static_cast< jobStates >(val3);
18772	<	arg3 = &temp3;
18773	<	}
18774	<	{
18775	<	try {
18776	<	((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3);
18777	<	} catch (const std::exception& e) {
18778	<	SWIG_exception(SWIG_RuntimeError, e.what());
18779	<	}
18780	<	}
18781	<	resultobj = SWIG_Py_Void();
18782	<	return resultobj;
18783	<	fail:
18784	<	return NULL;
18785	<	}
18786	<
18787	<
18788	<	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18789	<	PyObject *resultobj = 0;
18790	<	BossTask *arg1 = (BossTask *) 0 ;
18791	<	std::ostream *arg2 = 0 ;
18792	<	void *argp1 = 0 ;
18793	<	int res1 = 0 ;
18794	<	void *argp2 = 0 ;
18795	<	int res2 = 0 ;
18796	<	PyObject * obj0 = 0 ;
18797	<	PyObject * obj1 = 0 ;
18798	<
18799	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_query_out",&obj0,&obj1)) SWIG_fail;
18800	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18801	<	if (!SWIG_IsOK(res1)) {
18802	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query_out" "', argument " "1"" of type '" "BossTask const *""'");
18803	<	}
18804	<	arg1 = reinterpret_cast< BossTask * >(argp1);
18805	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream,  0 );
18806	<	if (!SWIG_IsOK(res2)) {
18807	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18808	<	}
18809	<	if (!argp2) {
18810	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18811	<	}
18812	<	arg2 = reinterpret_cast< std::ostream * >(argp2);
18813	<	{
18814	<	try {
18815	<	((BossTask const *)arg1)->query_out(*arg2);
18816	<	} catch (const std::exception& e) {
18817	<	SWIG_exception(SWIG_RuntimeError, e.what());
4928	>	if (obj7) {
4929	>	{
4930	>	if (PyString_Check(obj7))
4931	>	arg8 = std::string(PyString_AsString(obj7));
4932	>	else
4933	>	SWIG_exception(SWIG_TypeError, "string expected");
4934	>	}
4935		}
4936	<	}
4937	<	resultobj = SWIG_Py_Void();
4938	<	return resultobj;
4939	<	fail:
4940	<	return NULL;
4941	<	}
4942	<
4943	<
4944	<	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4945	<	PyObject *resultobj = 0;
4946	<	BossTask *arg1 = (BossTask *) 0 ;
18830	<	void *argp1 = 0 ;
18831	<	int res1 = 0 ;
18832	<	PyObject * obj0 = 0 ;
18833	<
18834	<	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_query_out",&obj0)) SWIG_fail;
18835	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18836	<	if (!SWIG_IsOK(res1)) {
18837	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query_out" "', argument " "1"" of type '" "BossTask const *""'");
18838	<	}
18839	<	arg1 = reinterpret_cast< BossTask * >(argp1);
18840	<	{
18841	<	try {
18842	<	((BossTask const *)arg1)->query_out();
18843	<	} catch (const std::exception& e) {
18844	<	SWIG_exception(SWIG_RuntimeError, e.what());
4936	>	{
4937	>	try {
4938	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4939	>
4940	>	}catch (const BossSchedFailure & e) {
4941	>	PyErr_SetString ( SchedulerError, e.what() );
4942	>	return NULL;
4943	>	}catch (const std::exception& e) {
4944	>	PyErr_SetString ( BossError, e.what() );
4945	>	return NULL;
4946	>	}
4947		}
4948	<	}
4949	<	resultobj = SWIG_Py_Void();
4950	<	return resultobj;
4951	<	fail:
18850	<	return NULL;
4948	>	resultobj = PyInt_FromLong((long)result);
4949	>	return resultobj;
4950	>	fail:
4951	>	return NULL;
4952		}
4953
4954
4955	<	SWIGINTERN PyObject *_wrap_BossTask_query_out(PyObject *self, PyObject *args) {
4956	<	int argc;
4957	<	PyObject *argv[6];
4958	<	int ii;
4959	<
4960	<	if (!PyTuple_Check(args)) SWIG_fail;
4961	<	argc = PyObject_Length(args);
4962	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
4963	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4964	<	}
4965	<	if (argc == 1) {
4966	<	int _v;
4967	<	void *vptr = 0;
4968	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4969	<	_v = SWIG_CheckState(res);
4970	<	if (_v) {
4971	<	return _wrap_BossTask_query_out__SWIG_4(self, args);
4972	<	}
4973	<	}
4974	<	if (argc == 2) {
4975	<	int _v;
4976	<	void *vptr = 0;
4977	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4978	<	_v = SWIG_CheckState(res);
4979	<	if (_v) {
4980	<	void *vptr = 0;
4981	<	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, 0);
4982	<	_v = SWIG_CheckState(res);
18882	<	if (_v) {
18883	<	return _wrap_BossTask_query_out__SWIG_3(self, args);
18884	<	}
18885	<	}
18886	<	}
18887	<	if (argc == 3) {
18888	<	int _v;
18889	<	void *vptr = 0;
18890	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18891	<	_v = SWIG_CheckState(res);
18892	<	if (_v) {
18893	<	void *vptr = 0;
18894	<	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, 0);
18895	<	_v = SWIG_CheckState(res);
18896	<	if (_v) {
4955	>	static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
4956	>	PyObject *resultobj;
4957	>	BossTask *arg1 = (BossTask *) 0 ;
4958	>	int arg2 = (int) SCHEDULED ;
4959	>	std::string const &arg3_defvalue = "all" ;
4960	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4961	>	std::string const &arg4_defvalue = "" ;
4962	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4963	>	std::string arg5 = (std::string) "" ;
4964	>	std::string arg6 = (std::string) "" ;
4965	>	std::string arg7 = (std::string) "" ;
4966	>	std::string arg8 = (std::string) "" ;
4967	>	bool arg9 = (bool) false ;
4968	>	int result;
4969	>	std::string temp3 ;
4970	>	std::string temp4 ;
4971	>	PyObject * obj0 = 0 ;
4972	>	PyObject * obj2 = 0 ;
4973	>	PyObject * obj3 = 0 ;
4974	>	PyObject * obj4 = 0 ;
4975	>	PyObject * obj5 = 0 ;
4976	>	PyObject * obj6 = 0 ;
4977	>	PyObject * obj7 = 0 ;
4978	>	PyObject * obj8 = 0 ;
4979	>
4980	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4981	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4982	>	if (obj2) {
4983		{
4984	<	int res = SWIG_AsVal_int(argv[2], NULL);
4985	<	_v = SWIG_CheckState(res);
4986	<	}
4987	<	if (_v) {
4988	<	return _wrap_BossTask_query_out__SWIG_2(self, args);
4984	>	if (PyString_Check(obj2)) {
4985	>	temp3 = std::string(PyString_AsString(obj2));
4986	>	arg3 = &temp3;
4987	>	}else {
4988	>	SWIG_exception(SWIG_TypeError, "string expected");
4989	>	}
4990		}
18904	–	}
4991		}
4992	<	}
18907	<	if (argc == 4) {
18908	<	int _v;
18909	<	void *vptr = 0;
18910	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18911	<	_v = SWIG_CheckState(res);
18912	<	if (_v) {
18913	<	void *vptr = 0;
18914	<	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, 0);
18915	<	_v = SWIG_CheckState(res);
18916	<	if (_v) {
4992	>	if (obj3) {
4993		{
4994	<	int res = SWIG_AsVal_int(argv[2], NULL);
4995	<	_v = SWIG_CheckState(res);
4994	>	if (PyString_Check(obj3)) {
4995	>	temp4 = std::string(PyString_AsString(obj3));
4996	>	arg4 = &temp4;
4997	>	}else {
4998	>	SWIG_exception(SWIG_TypeError, "string expected");
4999	>	}
5000		}
5001	<	if (_v) {
5002	<	{
5003	<	int res = SWIG_AsVal_int(argv[3], NULL);
5004	<	_v = SWIG_CheckState(res);
5005	<	}
5006	<	if (_v) {
5007	<	return _wrap_BossTask_query_out__SWIG_1(self, args);
18928	<	}
5001	>	}
5002	>	if (obj4) {
5003	>	{
5004	>	if (PyString_Check(obj4))
5005	>	arg5 = std::string(PyString_AsString(obj4));
5006	>	else
5007	>	SWIG_exception(SWIG_TypeError, "string expected");
5008		}
18930	–	}
5009		}
5010	<	}
18933	<	if (argc == 5) {
18934	<	int _v;
18935	<	void *vptr = 0;
18936	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18937	<	_v = SWIG_CheckState(res);
18938	<	if (_v) {
18939	<	void *vptr = 0;
18940	<	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, 0);
18941	<	_v = SWIG_CheckState(res);
18942	<	if (_v) {
5010	>	if (obj5) {
5011		{
5012	<	int res = SWIG_AsVal_int(argv[2], NULL);
5013	<	_v = SWIG_CheckState(res);
5012	>	if (PyString_Check(obj5))
5013	>	arg6 = std::string(PyString_AsString(obj5));
5014	>	else
5015	>	SWIG_exception(SWIG_TypeError, "string expected");
5016		}
5017	<	if (_v) {
5018	<	{
5019	<	int res = SWIG_AsVal_int(argv[3], NULL);
5020	<	_v = SWIG_CheckState(res);
5021	<	}
5022	<	if (_v) {
5023	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
18954	<	_v = SWIG_CheckState(res);
18955	<	if (_v) {
18956	<	return _wrap_BossTask_query_out__SWIG_0(self, args);
18957	<	}
18958	<	}
5017	>	}
5018	>	if (obj6) {
5019	>	{
5020	>	if (PyString_Check(obj6))
5021	>	arg7 = std::string(PyString_AsString(obj6));
5022	>	else
5023	>	SWIG_exception(SWIG_TypeError, "string expected");
5024		}
18960	–	}
5025		}
5026	<	}
5027	<
5028	<	fail:
5029	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_query_out'");
5030	<	return NULL;
5031	<	}
5032	<
18969	<
18970	<	SWIGINTERN PyObject *_wrap_BossTask_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18971	<	PyObject *resultobj = 0;
18972	<	BossTask *arg1 = (BossTask *) 0 ;
18973	<	void *argp1 = 0 ;
18974	<	int res1 = 0 ;
18975	<	PyObject * obj0 = 0 ;
18976	<
18977	<	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_clear",&obj0)) SWIG_fail;
18978	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18979	<	if (!SWIG_IsOK(res1)) {
18980	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_clear" "', argument " "1"" of type '" "BossTask *""'");
18981	<	}
18982	<	arg1 = reinterpret_cast< BossTask * >(argp1);
18983	<	{
18984	<	try {
18985	<	(arg1)->clear();
18986	<	} catch (const std::exception& e) {
18987	<	SWIG_exception(SWIG_RuntimeError, e.what());
5026	>	if (obj7) {
5027	>	{
5028	>	if (PyString_Check(obj7))
5029	>	arg8 = std::string(PyString_AsString(obj7));
5030	>	else
5031	>	SWIG_exception(SWIG_TypeError, "string expected");
5032	>	}
5033		}
5034	<	}
5035	<	resultobj = SWIG_Py_Void();
5036	<	return resultobj;
18992	<	fail:
18993	<	return NULL;
18994	<	}
18995	<
18996	<
18997	<	SWIGINTERN PyObject *_wrap_BossTask_appendToPyDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18998	<	PyObject *resultobj = 0;
18999	<	BossTask *arg1 = (BossTask *) 0 ;
19000	<	PyObject *arg2 = (PyObject *) 0 ;
19001	<	BossAttributeContainer *arg3 = 0 ;
19002	<	PyObject *result = 0 ;
19003	<	void *argp1 = 0 ;
19004	<	int res1 = 0 ;
19005	<	void *argp3 = 0 ;
19006	<	int res3 = 0 ;
19007	<	PyObject * obj0 = 0 ;
19008	<	PyObject * obj1 = 0 ;
19009	<	PyObject * obj2 = 0 ;
19010	<
19011	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) SWIG_fail;
19012	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
19013	<	if (!SWIG_IsOK(res1)) {
19014	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_appendToPyDict" "', argument " "1"" of type '" "BossTask const *""'");
19015	<	}
19016	<	arg1 = reinterpret_cast< BossTask * >(argp1);
19017	<	arg2 = obj1;
19018	<	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_BossAttributeContainer,  0  | 0);
19019	<	if (!SWIG_IsOK(res3)) {
19020	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_appendToPyDict" "', argument " "3"" of type '" "BossAttributeContainer const &""'");
19021	<	}
19022	<	if (!argp3) {
19023	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_appendToPyDict" "', argument " "3"" of type '" "BossAttributeContainer const &""'");
19024	<	}
19025	<	arg3 = reinterpret_cast< BossAttributeContainer * >(argp3);
19026	<	{
19027	<	try {
19028	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
19029	<	} catch (const std::exception& e) {
19030	<	SWIG_exception(SWIG_RuntimeError, e.what());
5034	>	if (obj8) {
5035	>	arg9 = PyInt_AsLong(obj8) ? true : false;
5036	>	if (PyErr_Occurred()) SWIG_fail;
5037		}
5038	<	}
5039	<	resultobj = result;
5040	<	return resultobj;
5041	<	fail:
5042	<	return NULL;
5043	<	}
5044	<
5045	<
5046	<	SWIGINTERN PyObject *_wrap_BossTask_jobDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5047	<	PyObject *resultobj = 0;
5048	<	BossTask *arg1 = (BossTask *) 0 ;
19043	<	std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator *arg2 = 0 ;
19044	<	PyObject *result = 0 ;
19045	<	void *argp1 = 0 ;
19046	<	int res1 = 0 ;
19047	<	void *argp2 = 0 ;
19048	<	int res2 = 0 ;
19049	<	PyObject * obj0 = 0 ;
19050	<	PyObject * obj1 = 0 ;
19051	<
19052	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) SWIG_fail;
19053	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
19054	<	if (!SWIG_IsOK(res1)) {
19055	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_jobDict" "', argument " "1"" of type '" "BossTask const *""'");
19056	<	}
19057	<	arg1 = reinterpret_cast< BossTask * >(argp1);
19058	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator,  0 );
19059	<	if (!SWIG_IsOK(res2)) {
19060	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_jobDict" "', argument " "2"" of type '" "std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator &""'");
19061	<	}
19062	<	if (!argp2) {
19063	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_jobDict" "', argument " "2"" of type '" "std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator &""'");
19064	<	}
19065	<	arg2 = reinterpret_cast< std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator * >(argp2);
19066	<	{
19067	<	try {
19068	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
19069	<	} catch (const std::exception& e) {
19070	<	SWIG_exception(SWIG_RuntimeError, e.what());
5038	>	{
5039	>	try {
5040	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
5041	>
5042	>	}catch (const BossSchedFailure & e) {
5043	>	PyErr_SetString ( SchedulerError, e.what() );
5044	>	return NULL;
5045	>	}catch (const std::exception& e) {
5046	>	PyErr_SetString ( BossError, e.what() );
5047	>	return NULL;
5048	>	}
5049		}
5050	<	}
5051	<	resultobj = result;
5052	<	return resultobj;
5053	<	fail:
19076	<	return NULL;
5050	>	resultobj = PyInt_FromLong((long)result);
5051	>	return resultobj;
5052	>	fail:
5053	>	return NULL;
5054		}
5055
5056
5057	<	SWIGINTERN PyObject *_wrap_BossTask_jobsDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5058	<	PyObject *resultobj = 0;
5059	<	BossTask *arg1 = (BossTask *) 0 ;
5060	<	PyObject *result = 0 ;
5061	<	void *argp1 = 0 ;
5062	<	int res1 = 0 ;
5063	<	PyObject * obj0 = 0 ;
5064	<
5065	<	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) SWIG_fail;
5066	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
5067	<	if (!SWIG_IsOK(res1)) {
5068	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_jobsDict" "', argument " "1"" of type '" "BossTask const *""'");
5069	<	}
5070	<	arg1 = reinterpret_cast< BossTask * >(argp1);
5071	<	{
5072	<	try {
5073	<	result = (PyObject *)BossTask_jobsDict((BossTask const *)arg1);
5074	<	} catch (const std::exception& e) {
5075	<	SWIG_exception(SWIG_RuntimeError, e.what());
5057	>	static PyObject *_wrap_BossTask_query_out(PyObject *self, PyObject *args) {
5058	>	PyObject *resultobj;
5059	>	BossTask *arg1 = (BossTask *) 0 ;
5060	>	std::ostream &arg2_defvalue = std::cout ;
5061	>	std::ostream *arg2 = (std::ostream *) &arg2_defvalue ;
5062	>	jobStates const &arg3_defvalue = SCHEDULED ;
5063	>	jobStates *arg3 = (jobStates *) &arg3_defvalue ;
5064	>	printOption const &arg4_defvalue = NORMAL ;
5065	>	printOption *arg4 = (printOption *) &arg4_defvalue ;
5066	>	std::string arg5 = (std::string) "" ;
5067	>	PyObject * obj0 = 0 ;
5068	>	PyObject * obj1 = 0 ;
5069	>	PyObject * obj2 = 0 ;
5070	>	PyObject * obj3 = 0 ;
5071	>	PyObject * obj4 = 0 ;
5072	>
5073	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_query_out",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5074	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5075	>	if (obj1) {
5076	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5077	>	if (arg2 == NULL) {
5078	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5079	>	}
5080		}
5081	<	}
5082	<	resultobj = result;
5083	<	return resultobj;
5084	<	fail:
5085	<	return NULL;
19105	<	}
19106	<
19107	<
19108	<	SWIGINTERN PyObject *_wrap_BossTask_progDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19109	<	PyObject *resultobj = 0;
19110	<	BossTask *arg1 = (BossTask *) 0 ;
19111	<	std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >::const_iterator *arg2 = 0 ;
19112	<	PyObject *result = 0 ;
19113	<	void *argp1 = 0 ;
19114	<	int res1 = 0 ;
19115	<	void *argp2 = 0 ;
19116	<	int res2 = 0 ;
19117	<	PyObject * obj0 = 0 ;
19118	<	PyObject * obj1 = 0 ;
19119	<
19120	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) SWIG_fail;
19121	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
19122	<	if (!SWIG_IsOK(res1)) {
19123	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_progDict" "', argument " "1"" of type '" "BossTask const *""'");
19124	<	}
19125	<	arg1 = reinterpret_cast< BossTask * >(argp1);
19126	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t__const_iterator,  0 );
19127	<	if (!SWIG_IsOK(res2)) {
19128	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_progDict" "', argument " "2"" of type '" "std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >::const_iterator &""'");
19129	<	}
19130	<	if (!argp2) {
19131	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_progDict" "', argument " "2"" of type '" "std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >::const_iterator &""'");
19132	<	}
19133	<	arg2 = reinterpret_cast< std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >::const_iterator * >(argp2);
19134	<	{
19135	<	try {
19136	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
19137	<	} catch (const std::exception& e) {
19138	<	SWIG_exception(SWIG_RuntimeError, e.what());
5081	>	if (obj2) {
5082	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5083	>	if (arg3 == NULL) {
5084	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5085	>	}
5086		}
5087	<	}
5088	<	resultobj = result;
5089	<	return resultobj;
5090	<	fail:
5091	<	return NULL;
19145	<	}
19146	<
19147	<
19148	<	SWIGINTERN PyObject *_wrap_BossTask_jobPrograms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19149	<	PyObject *resultobj = 0;
19150	<	BossTask *arg1 = (BossTask *) 0 ;
19151	<	std::string *arg2 = 0 ;
19152	<	PyObject *result = 0 ;
19153	<	void *argp1 = 0 ;
19154	<	int res1 = 0 ;
19155	<	int res2 = SWIG_OLDOBJ ;
19156	<	PyObject * obj0 = 0 ;
19157	<	PyObject * obj1 = 0 ;
19158	<
19159	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) SWIG_fail;
19160	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
19161	<	if (!SWIG_IsOK(res1)) {
19162	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_jobPrograms" "', argument " "1"" of type '" "BossTask const *""'");
19163	<	}
19164	<	arg1 = reinterpret_cast< BossTask * >(argp1);
19165	<	{
19166	<	std::string *ptr = (std::string *)0;
19167	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19168	<	if (!SWIG_IsOK(res2)) {
19169	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_jobPrograms" "', argument " "2"" of type '" "std::string const &""'");
5087	>	if (obj3) {
5088	>	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5089	>	if (arg4 == NULL) {
5090	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5091	>	}
5092		}
5093	<	if (!ptr) {
5094	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_jobPrograms" "', argument " "2"" of type '" "std::string const &""'");
5093	>	if (obj4) {
5094	>	{
5095	>	if (PyString_Check(obj4))
5096	>	arg5 = std::string(PyString_AsString(obj4));
5097	>	else
5098	>	SWIG_exception(SWIG_TypeError, "string expected");
5099	>	}
5100		}
5101	<	arg2 = ptr;
5102	<	}
5103	<	{
5104	<	try {
5105	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5106	<	} catch (const std::exception& e) {
5107	<	SWIG_exception(SWIG_RuntimeError, e.what());
5101	>	{
5102	>	try {
5103	>	((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5104	>
5105	>	}catch (const BossSchedFailure & e) {
5106	>	PyErr_SetString ( SchedulerError, e.what() );
5107	>	return NULL;
5108	>	}catch (const std::exception& e) {
5109	>	PyErr_SetString ( BossError, e.what() );
5110	>	return NULL;
5111	>	}
5112		}
5113	<	}
5114	<	resultobj = result;
5115	<	if (SWIG_IsNewObj(res2)) delete arg2;
5116	<	return resultobj;
19186	<	fail:
19187	<	if (SWIG_IsNewObj(res2)) delete arg2;
19188	<	return NULL;
5113	>	Py_INCREF(Py_None); resultobj = Py_None;
5114	>	return resultobj;
5115	>	fail:
5116	>	return NULL;
5117		}
5118
5119
5120	<	SWIGINTERN PyObject *BossTask_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121	<	PyObject *obj;
5122	<	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
5123	<	SWIG_TypeNewClientData(SWIGTYPE_p_BossTask, SWIG_NewClientData(obj));
5124	<	return SWIG_Py_Void();
5125	<	}
5126	<
5127	<	SWIGINTERN PyObject *_wrap_prompt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5128	<	PyObject *resultobj = 0;
5129	<	std::string *arg1 = 0 ;
5130	<	bool result;
5131	<	int res1 = SWIG_OLDOBJ ;
5132	<	PyObject * obj0 = 0 ;
5133	<
5134	<	if (!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) SWIG_fail;
5135	<	{
5136	<	std::string *ptr = (std::string *)0;
5137	<	res1 = SWIG_AsPtr_std_string(obj0, &ptr);
19210	<	if (!SWIG_IsOK(res1)) {
19211	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prompt" "', argument " "1"" of type '" "std::string const &""'");
19212	<	}
19213	<	if (!ptr) {
19214	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "prompt" "', argument " "1"" of type '" "std::string const &""'");
19215	<	}
19216	<	arg1 = ptr;
19217	<	}
19218	<	{
19219	<	try {
19220	<	result = (bool)prompt((std::string const &)*arg1);
19221	<	} catch (const std::exception& e) {
19222	<	SWIG_exception(SWIG_RuntimeError, e.what());
5120	>	static PyObject *_wrap_BossTask_clear(PyObject *self, PyObject *args) {
5121	>	PyObject *resultobj;
5122	>	BossTask *arg1 = (BossTask *) 0 ;
5123	>	PyObject * obj0 = 0 ;
5124	>
5125	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_clear",&obj0)) goto fail;
5126	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5127	>	{
5128	>	try {
5129	>	(arg1)->clear();
5130	>
5131	>	}catch (const BossSchedFailure & e) {
5132	>	PyErr_SetString ( SchedulerError, e.what() );
5133	>	return NULL;
5134	>	}catch (const std::exception& e) {
5135	>	PyErr_SetString ( BossError, e.what() );
5136	>	return NULL;
5137	>	}
5138		}
5139	<	}
5140	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
5141	<	if (SWIG_IsNewObj(res1)) delete arg1;
5142	<	return resultobj;
19228	<	fail:
19229	<	if (SWIG_IsNewObj(res1)) delete arg1;
19230	<	return NULL;
5139	>	Py_INCREF(Py_None); resultobj = Py_None;
5140	>	return resultobj;
5141	>	fail:
5142	>	return NULL;
5143		}
5144
5145
5146	<	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5147	<	PyObject *resultobj = 0;
5148	<	std::string arg1 ;
5149	<	bool arg2 ;
5150	<	BossAdministratorSession *result = 0 ;
5151	<	bool val2 ;
5152	<	int ecode2 = 0 ;
5153	<	PyObject * obj0 = 0 ;
5154	<	PyObject * obj1 = 0 ;
5155	<
5156	<	if (!PyArg_ParseTuple(args,(char *)"OO:new_BossAdministratorSession",&obj0,&obj1)) SWIG_fail;
5157	<	{
5158	<	std::string *ptr = (std::string *)0;
5159	<	int res = SWIG_AsPtr_std_string(obj0, &ptr);
5160	<	if (!SWIG_IsOK(res) || !ptr) {
5161	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BossAdministratorSession" "', argument " "1"" of type '" "std::string""'");
5146	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5147	>	PyObject *resultobj;
5148	>	BossTask *arg1 = (BossTask *) 0 ;
5149	>	PyObject *arg2 = (PyObject *) 0 ;
5150	>	BossAttributeContainer *arg3 = 0 ;
5151	>	PyObject *result;
5152	>	PyObject * obj0 = 0 ;
5153	>	PyObject * obj1 = 0 ;
5154	>	PyObject * obj2 = 0 ;
5155	>
5156	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5157	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5158	>	arg2 = obj1;
5159	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5160	>	if (arg3 == NULL) {
5161	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5162		}
5163	<	arg1 = *ptr;
5164	<	if (SWIG_IsNewObj(res)) delete ptr;
5165	<	}
5166	<	ecode2 = SWIG_AsVal_bool(obj1, &val2);
5167	<	if (!SWIG_IsOK(ecode2)) {
5168	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BossAdministratorSession" "', argument " "2"" of type '" "bool""'");
5169	<	}
5170	<	arg2 = static_cast< bool >(val2);
5171	<	{
5172	<	try {
5173	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
19262	<	} catch (const std::exception& e) {
19263	<	SWIG_exception(SWIG_RuntimeError, e.what());
5163	>	{
5164	>	try {
5165	>	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5166	>
5167	>	}catch (const BossSchedFailure & e) {
5168	>	PyErr_SetString ( SchedulerError, e.what() );
5169	>	return NULL;
5170	>	}catch (const std::exception& e) {
5171	>	PyErr_SetString ( BossError, e.what() );
5172	>	return NULL;
5173	>	}
5174		}
5175	<	}
5176	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_NEW |  0 );
5177	<	return resultobj;
5178	<	fail:
19269	<	return NULL;
5175	>	resultobj = result;
5176	>	return resultobj;
5177	>	fail:
5178	>	return NULL;
5179		}
5180
5181
5182	<	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183	<	PyObject *resultobj = 0;
5184	<	std::string arg1 ;
5185	<	BossAdministratorSession *result = 0 ;
5186	<	PyObject * obj0 = 0 ;
5187	<
5188	<	if (!PyArg_ParseTuple(args,(char *)"O:new_BossAdministratorSession",&obj0)) SWIG_fail;
5189	<	{
5190	<	std::string *ptr = (std::string *)0;
5191	<	int res = SWIG_AsPtr_std_string(obj0, &ptr);
5192	<	if (!SWIG_IsOK(res) || !ptr) {
5193	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BossAdministratorSession" "', argument " "1"" of type '" "std::string""'");
5194	<	}
19286	<	arg1 = *ptr;
19287	<	if (SWIG_IsNewObj(res)) delete ptr;
19288	<	}
19289	<	{
19290	<	try {
19291	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1);
19292	<	} catch (const std::exception& e) {
19293	<	SWIG_exception(SWIG_RuntimeError, e.what());
5182	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5183	>	PyObject *resultobj;
5184	>	BossTask *arg1 = (BossTask *) 0 ;
5185	>	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5186	>	PyObject *result;
5187	>	PyObject * obj0 = 0 ;
5188	>	PyObject * obj1 = 0 ;
5189	>
5190	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5191	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5192	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5193	>	if (arg2 == NULL) {
5194	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5195		}
5196	<	}
5197	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_NEW |  0 );
5198	<	return resultobj;
5199	<	fail:
5200	<	return NULL;
5201	<	}
5202	<
5203	<
5204	<	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5205	<	PyObject *resultobj = 0;
5206	<	BossAdministratorSession *result = 0 ;
19306	<
19307	<	if (!PyArg_ParseTuple(args,(char *)":new_BossAdministratorSession")) SWIG_fail;
19308	<	{
19309	<	try {
19310	<	result = (BossAdministratorSession *)new BossAdministratorSession();
19311	<	} catch (const std::exception& e) {
19312	<	SWIG_exception(SWIG_RuntimeError, e.what());
5196	>	{
5197	>	try {
5198	>	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5199	>
5200	>	}catch (const BossSchedFailure & e) {
5201	>	PyErr_SetString ( SchedulerError, e.what() );
5202	>	return NULL;
5203	>	}catch (const std::exception& e) {
5204	>	PyErr_SetString ( BossError, e.what() );
5205	>	return NULL;
5206	>	}
5207		}
5208	<	}
5209	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_NEW |  0 );
5210	<	return resultobj;
5211	<	fail:
19318	<	return NULL;
5208	>	resultobj = result;
5209	>	return resultobj;
5210	>	fail:
5211	>	return NULL;
5212		}
5213
5214
5215	<	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5216	<	int argc;
5217	<	PyObject *argv[3];
5218	<	int ii;
5219	<
5220	<	if (!PyTuple_Check(args)) SWIG_fail;
5221	<	argc = PyObject_Length(args);
5222	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5223	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5224	<	}
5225	<	if (argc == 0) {
5226	<	return _wrap_new_BossAdministratorSession__SWIG_2(self, args);
5227	<	}
5228	<	if (argc == 1) {
5229	<	int _v;
5230	<	int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
5231	<	_v = SWIG_CheckState(res);
5232	<	if (_v) {
5233	<	return _wrap_new_BossAdministratorSession__SWIG_1(self, args);
19341	<	}
19342	<	}
19343	<	if (argc == 2) {
19344	<	int _v;
19345	<	int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
19346	<	_v = SWIG_CheckState(res);
19347	<	if (_v) {
19348	<	{
19349	<	int res = SWIG_AsVal_bool(argv[1], NULL);
19350	<	_v = SWIG_CheckState(res);
19351	<	}
19352	<	if (_v) {
19353	<	return _wrap_new_BossAdministratorSession__SWIG_0(self, args);
19354	<	}
5215	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5216	>	PyObject *resultobj;
5217	>	BossTask *arg1 = (BossTask *) 0 ;
5218	>	PyObject *result;
5219	>	PyObject * obj0 = 0 ;
5220	>
5221	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5222	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5223	>	{
5224	>	try {
5225	>	result = (PyObject *)BossTask_jobsDict(arg1);
5226	>
5227	>	}catch (const BossSchedFailure & e) {
5228	>	PyErr_SetString ( SchedulerError, e.what() );
5229	>	return NULL;
5230	>	}catch (const std::exception& e) {
5231	>	PyErr_SetString ( BossError, e.what() );
5232	>	return NULL;
5233	>	}
5234		}
5235	<	}
5236	<
5237	<	fail:
5238	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BossAdministratorSession'");
19360	<	return NULL;
5235	>	resultobj = result;
5236	>	return resultobj;
5237	>	fail:
5238	>	return NULL;
5239		}
5240
5241
5242	<	SWIGINTERN PyObject *_wrap_delete_BossAdministratorSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5243	<	PyObject *resultobj = 0;
5244	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5245	<	void *argp1 = 0 ;
5246	<	int res1 = 0 ;
5247	<	PyObject * obj0 = 0 ;
5248	<
5249	<	if (!PyArg_ParseTuple(args,(char *)"O:delete_BossAdministratorSession",&obj0)) SWIG_fail;
5250	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_DISOWN |  0 );
5251	<	if (!SWIG_IsOK(res1)) {
5252	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BossAdministratorSession" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5253	<	}
5254	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19377	<	{
19378	<	try {
19379	<	delete arg1;
19380	<
19381	<	} catch (const std::exception& e) {
19382	<	SWIG_exception(SWIG_RuntimeError, e.what());
5242	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5243	>	PyObject *resultobj;
5244	>	BossTask *arg1 = (BossTask *) 0 ;
5245	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5246	>	PyObject *result;
5247	>	PyObject * obj0 = 0 ;
5248	>	PyObject * obj1 = 0 ;
5249	>
5250	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5251	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5252	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5253	>	if (arg2 == NULL) {
5254	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5255		}
5256	<	}
5257	<	resultobj = SWIG_Py_Void();
5258	<	return resultobj;
5259	<	fail:
5260	<	return NULL;
5261	<	}
5262	<
5263	<
5264	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5265	<	PyObject *resultobj = 0;
5266	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19395	<	int result;
19396	<	void *argp1 = 0 ;
19397	<	int res1 = 0 ;
19398	<	PyObject * obj0 = 0 ;
19399	<
19400	<	if (!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) SWIG_fail;
19401	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19402	<	if (!SWIG_IsOK(res1)) {
19403	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_configureDB" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19404	<	}
19405	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19406	<	{
19407	<	try {
19408	<	result = (int)(arg1)->configureDB();
19409	<	} catch (const std::exception& e) {
19410	<	SWIG_exception(SWIG_RuntimeError, e.what());
5256	>	{
5257	>	try {
5258	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5259	>
5260	>	}catch (const BossSchedFailure & e) {
5261	>	PyErr_SetString ( SchedulerError, e.what() );
5262	>	return NULL;
5263	>	}catch (const std::exception& e) {
5264	>	PyErr_SetString ( BossError, e.what() );
5265	>	return NULL;
5266	>	}
5267		}
5268	<	}
5269	<	resultobj = SWIG_From_int(static_cast< int >(result));
5270	<	return resultobj;
5271	<	fail:
19416	<	return NULL;
5268	>	resultobj = result;
5269	>	return resultobj;
5270	>	fail:
5271	>	return NULL;
5272		}
5273
5274
5275	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5276	<	PyObject *resultobj = 0;
5277	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5278	<	std::string *arg2 = 0 ;
5279	<	int result;
5280	<	void *argp1 = 0 ;
5281	<	int res1 = 0 ;
5282	<	int res2 = SWIG_OLDOBJ ;
5283	<	PyObject * obj0 = 0 ;
5284	<	PyObject * obj1 = 0 ;
5285	<
5286	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureRTMonDB",&obj0,&obj1)) SWIG_fail;
5287	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5288	<	if (!SWIG_IsOK(res1)) {
5289	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_configureRTMonDB" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5290	<	}
5291	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5292	<	{
19438	<	std::string *ptr = (std::string *)0;
19439	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19440	<	if (!SWIG_IsOK(res2)) {
19441	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_configureRTMonDB" "', argument " "2"" of type '" "std::string const &""'");
19442	<	}
19443	<	if (!ptr) {
19444	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_configureRTMonDB" "', argument " "2"" of type '" "std::string const &""'");
5275	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5276	>	PyObject *resultobj;
5277	>	BossTask *arg1 = (BossTask *) 0 ;
5278	>	std::string *arg2 = 0 ;
5279	>	PyObject *result;
5280	>	std::string temp2 ;
5281	>	PyObject * obj0 = 0 ;
5282	>	PyObject * obj1 = 0 ;
5283	>
5284	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5285	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5286	>	{
5287	>	if (PyString_Check(obj1)) {
5288	>	temp2 = std::string(PyString_AsString(obj1));
5289	>	arg2 = &temp2;
5290	>	}else {
5291	>	SWIG_exception(SWIG_TypeError, "string expected");
5292	>	}
5293		}
5294	<	arg2 = ptr;
5295	<	}
5296	<	{
5297	<	try {
5298	<	result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5299	<	} catch (const std::exception& e) {
5300	<	SWIG_exception(SWIG_RuntimeError, e.what());
5294	>	{
5295	>	try {
5296	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5297	>
5298	>	}catch (const BossSchedFailure & e) {
5299	>	PyErr_SetString ( SchedulerError, e.what() );
5300	>	return NULL;
5301	>	}catch (const std::exception& e) {
5302	>	PyErr_SetString ( BossError, e.what() );
5303	>	return NULL;
5304	>	}
5305		}
5306	<	}
5307	<	resultobj = SWIG_From_int(static_cast< int >(result));
5308	<	if (SWIG_IsNewObj(res2)) delete arg2;
5309	<	return resultobj;
19458	<	fail:
19459	<	if (SWIG_IsNewObj(res2)) delete arg2;
19460	<	return NULL;
5306	>	resultobj = result;
5307	>	return resultobj;
5308	>	fail:
5309	>	return NULL;
5310		}
5311
5312
5313	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_deleteCHTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5314	<	PyObject *resultobj = 0;
5315	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5316	<	std::string *arg2 = 0 ;
5317	<	int result;
5318	<	void *argp1 = 0 ;
5319	<	int res1 = 0 ;
5320	<	int res2 = SWIG_OLDOBJ ;
5321	<	PyObject * obj0 = 0 ;
5322	<	PyObject * obj1 = 0 ;
5323	<
5324	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteCHTool",&obj0,&obj1)) SWIG_fail;
5325	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5326	<	if (!SWIG_IsOK(res1)) {
5327	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_deleteCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5328	<	}
5329	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5330	<	{
5331	<	std::string *ptr = (std::string *)0;
5332	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5333	<	if (!SWIG_IsOK(res2)) {
5334	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_deleteCHTool" "', argument " "2"" of type '" "std::string const &""'");
5313	>	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5314	>	PyObject *obj;
5315	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5316	>	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5317	>	Py_INCREF(obj);
5318	>	return Py_BuildValue((char *)"");
5319	>	}
5320	>	static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5321	>	PyObject *resultobj;
5322	>	std::string arg1 = (std::string) "" ;
5323	>	std::string arg2 = (std::string) "2" ;
5324	>	std::string arg3 = (std::string) "" ;
5325	>	std::string arg4 = (std::string) "" ;
5326	>	bool arg5 = (bool) false ;
5327	>	BossAdministratorSession *result;
5328	>	PyObject * obj0 = 0 ;
5329	>	PyObject * obj1 = 0 ;
5330	>	PyObject * obj2 = 0 ;
5331	>	PyObject * obj3 = 0 ;
5332	>	PyObject * obj4 = 0 ;
5333	>
5334	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5335	>	if (obj0) {
5336	>	{
5337	>	if (PyString_Check(obj0))
5338	>	arg1 = std::string(PyString_AsString(obj0));
5339	>	else
5340	>	SWIG_exception(SWIG_TypeError, "string expected");
5341	>	}
5342		}
5343	<	if (!ptr) {
5344	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteCHTool" "', argument " "2"" of type '" "std::string const &""'");
5343	>	if (obj1) {
5344	>	{
5345	>	if (PyString_Check(obj1))
5346	>	arg2 = std::string(PyString_AsString(obj1));
5347	>	else
5348	>	SWIG_exception(SWIG_TypeError, "string expected");
5349	>	}
5350		}
5351	<	arg2 = ptr;
5352	<	}
5353	<	{
5354	<	try {
5355	<	result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5356	<	} catch (const std::exception& e) {
5357	<	SWIG_exception(SWIG_RuntimeError, e.what());
5351	>	if (obj2) {
5352	>	{
5353	>	if (PyString_Check(obj2))
5354	>	arg3 = std::string(PyString_AsString(obj2));
5355	>	else
5356	>	SWIG_exception(SWIG_TypeError, "string expected");
5357	>	}
5358		}
5359	<	}
5360	<	resultobj = SWIG_From_int(static_cast< int >(result));
5361	<	if (SWIG_IsNewObj(res2)) delete arg2;
5362	<	return resultobj;
5363	<	fail:
5364	<	if (SWIG_IsNewObj(res2)) delete arg2;
5365	<	return NULL;
19505	<	}
19506	<
19507	<
19508	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_deleteProgramType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19509	<	PyObject *resultobj = 0;
19510	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19511	<	std::string *arg2 = 0 ;
19512	<	int result;
19513	<	void *argp1 = 0 ;
19514	<	int res1 = 0 ;
19515	<	int res2 = SWIG_OLDOBJ ;
19516	<	PyObject * obj0 = 0 ;
19517	<	PyObject * obj1 = 0 ;
19518	<
19519	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteProgramType",&obj0,&obj1)) SWIG_fail;
19520	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19521	<	if (!SWIG_IsOK(res1)) {
19522	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_deleteProgramType" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19523	<	}
19524	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19525	<	{
19526	<	std::string *ptr = (std::string *)0;
19527	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19528	<	if (!SWIG_IsOK(res2)) {
19529	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_deleteProgramType" "', argument " "2"" of type '" "std::string const &""'");
5359	>	if (obj3) {
5360	>	{
5361	>	if (PyString_Check(obj3))
5362	>	arg4 = std::string(PyString_AsString(obj3));
5363	>	else
5364	>	SWIG_exception(SWIG_TypeError, "string expected");
5365	>	}
5366		}
5367	<	if (!ptr) {
5368	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteProgramType" "', argument " "2"" of type '" "std::string const &""'");
5367	>	if (obj4) {
5368	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5369	>	if (PyErr_Occurred()) SWIG_fail;
5370		}
5371	<	arg2 = ptr;
5372	<	}
5373	<	{
5374	<	try {
5375	<	result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5376	<	} catch (const std::exception& e) {
5377	<	SWIG_exception(SWIG_RuntimeError, e.what());
5371	>	{
5372	>	try {
5373	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5374	>
5375	>	}catch (const BossSchedFailure & e) {
5376	>	PyErr_SetString ( SchedulerError, e.what() );
5377	>	return NULL;
5378	>	}catch (const std::exception& e) {
5379	>	PyErr_SetString ( BossError, e.what() );
5380	>	return NULL;
5381	>	}
5382		}
5383	<	}
5384	<	resultobj = SWIG_From_int(static_cast< int >(result));
5385	<	if (SWIG_IsNewObj(res2)) delete arg2;
5386	<	return resultobj;
19546	<	fail:
19547	<	if (SWIG_IsNewObj(res2)) delete arg2;
19548	<	return NULL;
5383	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
5384	>	return resultobj;
5385	>	fail:
5386	>	return NULL;
5387		}
5388
5389
5390	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_deleteRTMon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5391	<	PyObject *resultobj = 0;
5392	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5393	<	std::string *arg2 = 0 ;
5394	<	int result;
5395	<	void *argp1 = 0 ;
5396	<	int res1 = 0 ;
5397	<	int res2 = SWIG_OLDOBJ ;
5398	<	PyObject * obj0 = 0 ;
5399	<	PyObject * obj1 = 0 ;
5400	<
5401	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteRTMon",&obj0,&obj1)) SWIG_fail;
5402	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5403	<	if (!SWIG_IsOK(res1)) {
5404	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_deleteRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5405	<	}
5406	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5407	<	{
19570	<	std::string *ptr = (std::string *)0;
19571	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19572	<	if (!SWIG_IsOK(res2)) {
19573	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_deleteRTMon" "', argument " "2"" of type '" "std::string const &""'");
19574	<	}
19575	<	if (!ptr) {
19576	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteRTMon" "', argument " "2"" of type '" "std::string const &""'");
19577	<	}
19578	<	arg2 = ptr;
19579	<	}
19580	<	{
19581	<	try {
19582	<	result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
19583	<	} catch (const std::exception& e) {
19584	<	SWIG_exception(SWIG_RuntimeError, e.what());
5390	>	static PyObject *_wrap_delete_BossAdministratorSession(PyObject *self, PyObject *args) {
5391	>	PyObject *resultobj;
5392	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5393	>	PyObject * obj0 = 0 ;
5394	>
5395	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossAdministratorSession",&obj0)) goto fail;
5396	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5397	>	{
5398	>	try {
5399	>	delete arg1;
5400	>
5401	>	}catch (const BossSchedFailure & e) {
5402	>	PyErr_SetString ( SchedulerError, e.what() );
5403	>	return NULL;
5404	>	}catch (const std::exception& e) {
5405	>	PyErr_SetString ( BossError, e.what() );
5406	>	return NULL;
5407	>	}
5408		}
5409	<	}
5410	<	resultobj = SWIG_From_int(static_cast< int >(result));
5411	<	if (SWIG_IsNewObj(res2)) delete arg2;
5412	<	return resultobj;
19590	<	fail:
19591	<	if (SWIG_IsNewObj(res2)) delete arg2;
19592	<	return NULL;
5409	>	Py_INCREF(Py_None); resultobj = Py_None;
5410	>	return resultobj;
5411	>	fail:
5412	>	return NULL;
5413		}
5414
5415
5416	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_deleteScheduler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417	<	PyObject *resultobj = 0;
5418	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5419	<	std::string *arg2 = 0 ;
5420	<	int result;
5421	<	void *argp1 = 0 ;
5422	<	int res1 = 0 ;
5423	<	int res2 = SWIG_OLDOBJ ;
5424	<	PyObject * obj0 = 0 ;
5425	<	PyObject * obj1 = 0 ;
5426	<
5427	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteScheduler",&obj0,&obj1)) SWIG_fail;
5428	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5429	<	if (!SWIG_IsOK(res1)) {
5430	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_deleteScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5431	<	}
5432	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5433	<	{
5434	<	std::string *ptr = (std::string *)0;
19615	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19616	<	if (!SWIG_IsOK(res2)) {
19617	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_deleteScheduler" "', argument " "2"" of type '" "std::string const &""'");
19618	<	}
19619	<	if (!ptr) {
19620	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteScheduler" "', argument " "2"" of type '" "std::string const &""'");
19621	<	}
19622	<	arg2 = ptr;
19623	<	}
19624	<	{
19625	<	try {
19626	<	result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
19627	<	} catch (const std::exception& e) {
19628	<	SWIG_exception(SWIG_RuntimeError, e.what());
5416	>	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
5417	>	PyObject *resultobj;
5418	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5419	>	int result;
5420	>	PyObject * obj0 = 0 ;
5421	>
5422	>	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
5423	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5424	>	{
5425	>	try {
5426	>	result = (int)(arg1)->configureDB();
5427	>
5428	>	}catch (const BossSchedFailure & e) {
5429	>	PyErr_SetString ( SchedulerError, e.what() );
5430	>	return NULL;
5431	>	}catch (const std::exception& e) {
5432	>	PyErr_SetString ( BossError, e.what() );
5433	>	return NULL;
5434	>	}
5435		}
5436	<	}
5437	<	resultobj = SWIG_From_int(static_cast< int >(result));
5438	<	if (SWIG_IsNewObj(res2)) delete arg2;
5439	<	return resultobj;
19634	<	fail:
19635	<	if (SWIG_IsNewObj(res2)) delete arg2;
19636	<	return NULL;
5436	>	resultobj = PyInt_FromLong((long)result);
5437	>	return resultobj;
5438	>	fail:
5439	>	return NULL;
5440		}
5441
5442
5443	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5444	<	PyObject *resultobj = 0;
5445	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5446	<	std::string *arg2 = 0 ;
5447	<	std::string arg3 ;
5448	<	std::string arg4 ;
5449	<	bool arg5 ;
5450	<	bool arg6 ;
5451	<	int result;
5452	<	void *argp1 = 0 ;
5453	<	int res1 = 0 ;
5454	<	int res2 = SWIG_OLDOBJ ;
5455	<	bool val5 ;
5456	<	int ecode5 = 0 ;
5457	<	bool val6 ;
5458	<	int ecode6 = 0 ;
5459	<	PyObject * obj0 = 0 ;
5460	<	PyObject * obj1 = 0 ;
19658	<	PyObject * obj2 = 0 ;
19659	<	PyObject * obj3 = 0 ;
19660	<	PyObject * obj4 = 0 ;
19661	<	PyObject * obj5 = 0 ;
19662	<
19663	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
19664	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19665	<	if (!SWIG_IsOK(res1)) {
19666	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19667	<	}
19668	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19669	<	{
19670	<	std::string *ptr = (std::string *)0;
19671	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19672	<	if (!SWIG_IsOK(res2)) {
19673	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "2"" of type '" "std::string const &""'");
19674	<	}
19675	<	if (!ptr) {
19676	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerCHTool" "', argument " "2"" of type '" "std::string const &""'");
19677	<	}
19678	<	arg2 = ptr;
19679	<	}
19680	<	{
19681	<	std::string *ptr = (std::string *)0;
19682	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
19683	<	if (!SWIG_IsOK(res) || !ptr) {
19684	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "3"" of type '" "std::string""'");
19685	<	}
19686	<	arg3 = *ptr;
19687	<	if (SWIG_IsNewObj(res)) delete ptr;
19688	<	}
19689	<	{
19690	<	std::string *ptr = (std::string *)0;
19691	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
19692	<	if (!SWIG_IsOK(res) || !ptr) {
19693	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "4"" of type '" "std::string""'");
5443	>	static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
5444	>	PyObject *resultobj;
5445	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5446	>	std::string *arg2 = 0 ;
5447	>	int result;
5448	>	std::string temp2 ;
5449	>	PyObject * obj0 = 0 ;
5450	>	PyObject * obj1 = 0 ;
5451	>
5452	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureRTMonDB",&obj0,&obj1)) goto fail;
5453	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5454	>	{
5455	>	if (PyString_Check(obj1)) {
5456	>	temp2 = std::string(PyString_AsString(obj1));
5457	>	arg2 = &temp2;
5458	>	}else {
5459	>	SWIG_exception(SWIG_TypeError, "string expected");
5460	>	}
5461		}
5462	<	arg4 = *ptr;
5463	<	if (SWIG_IsNewObj(res)) delete ptr;
5464	<	}
5465	<	ecode5 = SWIG_AsVal_bool(obj4, &val5);
5466	<	if (!SWIG_IsOK(ecode5)) {
5467	<	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "5"" of type '" "bool""'");
5468	<	}
5469	<	arg5 = static_cast< bool >(val5);
5470	<	ecode6 = SWIG_AsVal_bool(obj5, &val6);
5471	<	if (!SWIG_IsOK(ecode6)) {
5472	<	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "6"" of type '" "bool""'");
19706	<	}
19707	<	arg6 = static_cast< bool >(val6);
19708	<	{
19709	<	try {
19710	<	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
19711	<	} catch (const std::exception& e) {
19712	<	SWIG_exception(SWIG_RuntimeError, e.what());
5462	>	{
5463	>	try {
5464	>	result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5465	>
5466	>	}catch (const BossSchedFailure & e) {
5467	>	PyErr_SetString ( SchedulerError, e.what() );
5468	>	return NULL;
5469	>	}catch (const std::exception& e) {
5470	>	PyErr_SetString ( BossError, e.what() );
5471	>	return NULL;
5472	>	}
5473		}
5474	<	}
5475	<	resultobj = SWIG_From_int(static_cast< int >(result));
5476	<	if (SWIG_IsNewObj(res2)) delete arg2;
5477	<	return resultobj;
19718	<	fail:
19719	<	if (SWIG_IsNewObj(res2)) delete arg2;
19720	<	return NULL;
5474	>	resultobj = PyInt_FromLong((long)result);
5475	>	return resultobj;
5476	>	fail:
5477	>	return NULL;
5478		}
5479
5480
5481	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5482	<	PyObject *resultobj = 0;
5483	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5484	<	std::string *arg2 = 0 ;
5485	<	std::string arg3 ;
5486	<	std::string arg4 ;
5487	<	bool arg5 ;
5488	<	int result;
5489	<	void *argp1 = 0 ;
5490	<	int res1 = 0 ;
5491	<	int res2 = SWIG_OLDOBJ ;
5492	<	bool val5 ;
5493	<	int ecode5 = 0 ;
5494	<	PyObject * obj0 = 0 ;
5495	<	PyObject * obj1 = 0 ;
5496	<	PyObject * obj2 = 0 ;
5497	<	PyObject * obj3 = 0 ;
5498	<	PyObject * obj4 = 0 ;
19742	<
19743	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19744	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19745	<	if (!SWIG_IsOK(res1)) {
19746	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19747	<	}
19748	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19749	<	{
19750	<	std::string *ptr = (std::string *)0;
19751	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19752	<	if (!SWIG_IsOK(res2)) {
19753	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "2"" of type '" "std::string const &""'");
19754	<	}
19755	<	if (!ptr) {
19756	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerCHTool" "', argument " "2"" of type '" "std::string const &""'");
19757	<	}
19758	<	arg2 = ptr;
19759	<	}
19760	<	{
19761	<	std::string *ptr = (std::string *)0;
19762	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
19763	<	if (!SWIG_IsOK(res) || !ptr) {
19764	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "3"" of type '" "std::string""'");
19765	<	}
19766	<	arg3 = *ptr;
19767	<	if (SWIG_IsNewObj(res)) delete ptr;
19768	<	}
19769	<	{
19770	<	std::string *ptr = (std::string *)0;
19771	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
19772	<	if (!SWIG_IsOK(res) || !ptr) {
19773	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "4"" of type '" "std::string""'");
5481	>	static PyObject *_wrap_BossAdministratorSession_deleteCHTool(PyObject *self, PyObject *args) {
5482	>	PyObject *resultobj;
5483	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5484	>	std::string *arg2 = 0 ;
5485	>	int result;
5486	>	std::string temp2 ;
5487	>	PyObject * obj0 = 0 ;
5488	>	PyObject * obj1 = 0 ;
5489	>
5490	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteCHTool",&obj0,&obj1)) goto fail;
5491	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5492	>	{
5493	>	if (PyString_Check(obj1)) {
5494	>	temp2 = std::string(PyString_AsString(obj1));
5495	>	arg2 = &temp2;
5496	>	}else {
5497	>	SWIG_exception(SWIG_TypeError, "string expected");
5498	>	}
5499		}
5500	<	arg4 = *ptr;
5501	<	if (SWIG_IsNewObj(res)) delete ptr;
5502	<	}
5503	<	ecode5 = SWIG_AsVal_bool(obj4, &val5);
5504	<	if (!SWIG_IsOK(ecode5)) {
5505	<	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "5"" of type '" "bool""'");
5506	<	}
5507	<	arg5 = static_cast< bool >(val5);
5508	<	{
5509	<	try {
5510	<	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5);
19786	<	} catch (const std::exception& e) {
19787	<	SWIG_exception(SWIG_RuntimeError, e.what());
5500	>	{
5501	>	try {
5502	>	result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5503	>
5504	>	}catch (const BossSchedFailure & e) {
5505	>	PyErr_SetString ( SchedulerError, e.what() );
5506	>	return NULL;
5507	>	}catch (const std::exception& e) {
5508	>	PyErr_SetString ( BossError, e.what() );
5509	>	return NULL;
5510	>	}
5511		}
5512	<	}
5513	<	resultobj = SWIG_From_int(static_cast< int >(result));
5514	<	if (SWIG_IsNewObj(res2)) delete arg2;
5515	<	return resultobj;
19793	<	fail:
19794	<	if (SWIG_IsNewObj(res2)) delete arg2;
19795	<	return NULL;
5512	>	resultobj = PyInt_FromLong((long)result);
5513	>	return resultobj;
5514	>	fail:
5515	>	return NULL;
5516		}
5517
5518
5519	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5520	<	PyObject *resultobj = 0;
5521	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5522	<	std::string *arg2 = 0 ;
5523	<	std::string arg3 ;
5524	<	std::string arg4 ;
5525	<	int result;
5526	<	void *argp1 = 0 ;
5527	<	int res1 = 0 ;
5528	<	int res2 = SWIG_OLDOBJ ;
5529	<	PyObject * obj0 = 0 ;
5530	<	PyObject * obj1 = 0 ;
5531	<	PyObject * obj2 = 0 ;
5532	<	PyObject * obj3 = 0 ;
5533	<
5534	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5535	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5536	<	if (!SWIG_IsOK(res1)) {
19817	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19818	<	}
19819	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19820	<	{
19821	<	std::string *ptr = (std::string *)0;
19822	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19823	<	if (!SWIG_IsOK(res2)) {
19824	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "2"" of type '" "std::string const &""'");
19825	<	}
19826	<	if (!ptr) {
19827	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerCHTool" "', argument " "2"" of type '" "std::string const &""'");
19828	<	}
19829	<	arg2 = ptr;
19830	<	}
19831	<	{
19832	<	std::string *ptr = (std::string *)0;
19833	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
19834	<	if (!SWIG_IsOK(res) || !ptr) {
19835	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "3"" of type '" "std::string""'");
19836	<	}
19837	<	arg3 = *ptr;
19838	<	if (SWIG_IsNewObj(res)) delete ptr;
19839	<	}
19840	<	{
19841	<	std::string *ptr = (std::string *)0;
19842	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
19843	<	if (!SWIG_IsOK(res) || !ptr) {
19844	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "4"" of type '" "std::string""'");
5519	>	static PyObject *_wrap_BossAdministratorSession_deleteProgramType(PyObject *self, PyObject *args) {
5520	>	PyObject *resultobj;
5521	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5522	>	std::string *arg2 = 0 ;
5523	>	int result;
5524	>	std::string temp2 ;
5525	>	PyObject * obj0 = 0 ;
5526	>	PyObject * obj1 = 0 ;
5527	>
5528	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteProgramType",&obj0,&obj1)) goto fail;
5529	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5530	>	{
5531	>	if (PyString_Check(obj1)) {
5532	>	temp2 = std::string(PyString_AsString(obj1));
5533	>	arg2 = &temp2;
5534	>	}else {
5535	>	SWIG_exception(SWIG_TypeError, "string expected");
5536	>	}
5537		}
5538	<	arg4 = *ptr;
5539	<	if (SWIG_IsNewObj(res)) delete ptr;
5540	<	}
5541	<	{
5542	<	try {
5543	<	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4);
5544	<	} catch (const std::exception& e) {
5545	<	SWIG_exception(SWIG_RuntimeError, e.what());
5538	>	{
5539	>	try {
5540	>	result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5541	>
5542	>	}catch (const BossSchedFailure & e) {
5543	>	PyErr_SetString ( SchedulerError, e.what() );
5544	>	return NULL;
5545	>	}catch (const std::exception& e) {
5546	>	PyErr_SetString ( BossError, e.what() );
5547	>	return NULL;
5548	>	}
5549		}
5550	<	}
5551	<	resultobj = SWIG_From_int(static_cast< int >(result));
5552	<	if (SWIG_IsNewObj(res2)) delete arg2;
5553	<	return resultobj;
19859	<	fail:
19860	<	if (SWIG_IsNewObj(res2)) delete arg2;
19861	<	return NULL;
5550	>	resultobj = PyInt_FromLong((long)result);
5551	>	return resultobj;
5552	>	fail:
5553	>	return NULL;
5554		}
5555
5556
5557	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5558	<	PyObject *resultobj = 0;
5559	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5560	<	std::string *arg2 = 0 ;
5561	<	std::string arg3 ;
5562	<	int result;
5563	<	void *argp1 = 0 ;
5564	<	int res1 = 0 ;
5565	<	int res2 = SWIG_OLDOBJ ;
5566	<	PyObject * obj0 = 0 ;
5567	<	PyObject * obj1 = 0 ;
5568	<	PyObject * obj2 = 0 ;
5569	<
5570	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2)) SWIG_fail;
5571	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5572	<	if (!SWIG_IsOK(res1)) {
5573	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5574	<	}
19883	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19884	<	{
19885	<	std::string *ptr = (std::string *)0;
19886	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19887	<	if (!SWIG_IsOK(res2)) {
19888	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "2"" of type '" "std::string const &""'");
19889	<	}
19890	<	if (!ptr) {
19891	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerCHTool" "', argument " "2"" of type '" "std::string const &""'");
19892	<	}
19893	<	arg2 = ptr;
19894	<	}
19895	<	{
19896	<	std::string *ptr = (std::string *)0;
19897	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
19898	<	if (!SWIG_IsOK(res) || !ptr) {
19899	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "3"" of type '" "std::string""'");
5557	>	static PyObject *_wrap_BossAdministratorSession_deleteRTMon(PyObject *self, PyObject *args) {
5558	>	PyObject *resultobj;
5559	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5560	>	std::string *arg2 = 0 ;
5561	>	int result;
5562	>	std::string temp2 ;
5563	>	PyObject * obj0 = 0 ;
5564	>	PyObject * obj1 = 0 ;
5565	>
5566	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteRTMon",&obj0,&obj1)) goto fail;
5567	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5568	>	{
5569	>	if (PyString_Check(obj1)) {
5570	>	temp2 = std::string(PyString_AsString(obj1));
5571	>	arg2 = &temp2;
5572	>	}else {
5573	>	SWIG_exception(SWIG_TypeError, "string expected");
5574	>	}
5575		}
5576	<	arg3 = *ptr;
5577	<	if (SWIG_IsNewObj(res)) delete ptr;
5578	<	}
5579	<	{
5580	<	try {
5581	<	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3);
5582	<	} catch (const std::exception& e) {
5583	<	SWIG_exception(SWIG_RuntimeError, e.what());
5576	>	{
5577	>	try {
5578	>	result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5579	>
5580	>	}catch (const BossSchedFailure & e) {
5581	>	PyErr_SetString ( SchedulerError, e.what() );
5582	>	return NULL;
5583	>	}catch (const std::exception& e) {
5584	>	PyErr_SetString ( BossError, e.what() );
5585	>	return NULL;
5586	>	}
5587		}
5588	<	}
5589	<	resultobj = SWIG_From_int(static_cast< int >(result));
5590	<	if (SWIG_IsNewObj(res2)) delete arg2;
5591	<	return resultobj;
19914	<	fail:
19915	<	if (SWIG_IsNewObj(res2)) delete arg2;
19916	<	return NULL;
5588	>	resultobj = PyInt_FromLong((long)result);
5589	>	return resultobj;
5590	>	fail:
5591	>	return NULL;
5592		}
5593
5594
5595	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5596	<	PyObject *resultobj = 0;
5597	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5598	<	std::string *arg2 = 0 ;
5599	<	int result;
5600	<	void *argp1 = 0 ;
5601	<	int res1 = 0 ;
5602	<	int res2 = SWIG_OLDOBJ ;
5603	<	PyObject * obj0 = 0 ;
5604	<	PyObject * obj1 = 0 ;
5605	<
5606	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerCHTool",&obj0,&obj1)) SWIG_fail;
5607	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5608	<	if (!SWIG_IsOK(res1)) {
5609	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5610	<	}
5611	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5612	<	{
19938	<	std::string *ptr = (std::string *)0;
19939	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19940	<	if (!SWIG_IsOK(res2)) {
19941	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "2"" of type '" "std::string const &""'");
19942	<	}
19943	<	if (!ptr) {
19944	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerCHTool" "', argument " "2"" of type '" "std::string const &""'");
5595	>	static PyObject *_wrap_BossAdministratorSession_deleteScheduler(PyObject *self, PyObject *args) {
5596	>	PyObject *resultobj;
5597	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5598	>	std::string *arg2 = 0 ;
5599	>	int result;
5600	>	std::string temp2 ;
5601	>	PyObject * obj0 = 0 ;
5602	>	PyObject * obj1 = 0 ;
5603	>
5604	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteScheduler",&obj0,&obj1)) goto fail;
5605	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5606	>	{
5607	>	if (PyString_Check(obj1)) {
5608	>	temp2 = std::string(PyString_AsString(obj1));
5609	>	arg2 = &temp2;
5610	>	}else {
5611	>	SWIG_exception(SWIG_TypeError, "string expected");
5612	>	}
5613		}
5614	<	arg2 = ptr;
5615	<	}
5616	<	{
5617	<	try {
5618	<	result = (int)(arg1)->registerCHTool((std::string const &)*arg2);
5619	<	} catch (const std::exception& e) {
5620	<	SWIG_exception(SWIG_RuntimeError, e.what());
5614	>	{
5615	>	try {
5616	>	result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5617	>
5618	>	}catch (const BossSchedFailure & e) {
5619	>	PyErr_SetString ( SchedulerError, e.what() );
5620	>	return NULL;
5621	>	}catch (const std::exception& e) {
5622	>	PyErr_SetString ( BossError, e.what() );
5623	>	return NULL;
5624	>	}
5625		}
5626	<	}
5627	<	resultobj = SWIG_From_int(static_cast< int >(result));
5628	<	if (SWIG_IsNewObj(res2)) delete arg2;
5629	<	return resultobj;
19958	<	fail:
19959	<	if (SWIG_IsNewObj(res2)) delete arg2;
19960	<	return NULL;
5626	>	resultobj = PyInt_FromLong((long)result);
5627	>	return resultobj;
5628	>	fail:
5629	>	return NULL;
5630		}
5631
5632
5633	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool(PyObject *self, PyObject *args) {
5634	<	int argc;
5635	<	PyObject *argv[7];
5636	<	int ii;
5637	<
5638	<	if (!PyTuple_Check(args)) SWIG_fail;
5639	<	argc = PyObject_Length(args);
5640	<	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
5641	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5642	<	}
5643	<	if (argc == 2) {
5644	<	int _v;
5645	<	void *vptr = 0;
5646	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5647	<	_v = SWIG_CheckState(res);
5648	<	if (_v) {
5649	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5650	<	_v = SWIG_CheckState(res);
5651	<	if (_v) {
5652	<	return _wrap_BossAdministratorSession_registerCHTool__SWIG_4(self, args);
5653	<	}
5654	<	}
5655	<	}
5656	<	if (argc == 3) {
5657	<	int _v;
19989	<	void *vptr = 0;
19990	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
19991	<	_v = SWIG_CheckState(res);
19992	<	if (_v) {
19993	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
19994	<	_v = SWIG_CheckState(res);
19995	<	if (_v) {
19996	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
19997	<	_v = SWIG_CheckState(res);
19998	<	if (_v) {
19999	<	return _wrap_BossAdministratorSession_registerCHTool__SWIG_3(self, args);
20000	<	}
20001	<	}
20002	<	}
20003	<	}
20004	<	if (argc == 4) {
20005	<	int _v;
20006	<	void *vptr = 0;
20007	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
20008	<	_v = SWIG_CheckState(res);
20009	<	if (_v) {
20010	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
20011	<	_v = SWIG_CheckState(res);
20012	<	if (_v) {
20013	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
20014	<	_v = SWIG_CheckState(res);
20015	<	if (_v) {
20016	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
20017	<	_v = SWIG_CheckState(res);
20018	<	if (_v) {
20019	<	return _wrap_BossAdministratorSession_registerCHTool__SWIG_2(self, args);
20020	<	}
5633	>	static PyObject *_wrap_BossAdministratorSession_registerCHTool(PyObject *self, PyObject *args) {
5634	>	PyObject *resultobj;
5635	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5636	>	std::string *arg2 = 0 ;
5637	>	std::string arg3 = (std::string) "NULL" ;
5638	>	std::string arg4 = (std::string) "NULL" ;
5639	>	bool arg5 = (bool) false ;
5640	>	bool arg6 = (bool) false ;
5641	>	int result;
5642	>	std::string temp2 ;
5643	>	PyObject * obj0 = 0 ;
5644	>	PyObject * obj1 = 0 ;
5645	>	PyObject * obj2 = 0 ;
5646	>	PyObject * obj3 = 0 ;
5647	>	PyObject * obj4 = 0 ;
5648	>	PyObject * obj5 = 0 ;
5649	>
5650	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5651	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5652	>	{
5653	>	if (PyString_Check(obj1)) {
5654	>	temp2 = std::string(PyString_AsString(obj1));
5655	>	arg2 = &temp2;
5656	>	}else {
5657	>	SWIG_exception(SWIG_TypeError, "string expected");
5658		}
20022	–	}
5659		}
5660	<	}
5661	<	if (argc == 5) {
5662	<	int _v;
5663	<	void *vptr = 0;
5664	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5665	<	_v = SWIG_CheckState(res);
20030	<	if (_v) {
20031	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
20032	<	_v = SWIG_CheckState(res);
20033	<	if (_v) {
20034	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
20035	<	_v = SWIG_CheckState(res);
20036	<	if (_v) {
20037	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
20038	<	_v = SWIG_CheckState(res);
20039	<	if (_v) {
20040	<	{
20041	<	int res = SWIG_AsVal_bool(argv[4], NULL);
20042	<	_v = SWIG_CheckState(res);
20043	<	}
20044	<	if (_v) {
20045	<	return _wrap_BossAdministratorSession_registerCHTool__SWIG_1(self, args);
20046	<	}
20047	<	}
5660	>	if (obj2) {
5661	>	{
5662	>	if (PyString_Check(obj2))
5663	>	arg3 = std::string(PyString_AsString(obj2));
5664	>	else
5665	>	SWIG_exception(SWIG_TypeError, "string expected");
5666		}
20049	–	}
5667		}
5668	<	}
5669	<	if (argc == 6) {
5670	<	int _v;
5671	<	void *vptr = 0;
5672	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5673	<	_v = SWIG_CheckState(res);
20057	<	if (_v) {
20058	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
20059	<	_v = SWIG_CheckState(res);
20060	<	if (_v) {
20061	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
20062	<	_v = SWIG_CheckState(res);
20063	<	if (_v) {
20064	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
20065	<	_v = SWIG_CheckState(res);
20066	<	if (_v) {
20067	<	{
20068	<	int res = SWIG_AsVal_bool(argv[4], NULL);
20069	<	_v = SWIG_CheckState(res);
20070	<	}
20071	<	if (_v) {
20072	<	{
20073	<	int res = SWIG_AsVal_bool(argv[5], NULL);
20074	<	_v = SWIG_CheckState(res);
20075	<	}
20076	<	if (_v) {
20077	<	return _wrap_BossAdministratorSession_registerCHTool__SWIG_0(self, args);
20078	<	}
20079	<	}
20080	<	}
5668	>	if (obj3) {
5669	>	{
5670	>	if (PyString_Check(obj3))
5671	>	arg4 = std::string(PyString_AsString(obj3));
5672	>	else
5673	>	SWIG_exception(SWIG_TypeError, "string expected");
5674		}
20082	–	}
20083	–	}
20084	–	}
20085	–
20086	–	fail:
20087	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_registerCHTool'");
20088	–	return NULL;
20089	–	}
20090	–
20091	–
20092	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20093	–	PyObject *resultobj = 0;
20094	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20095	–	std::string *arg2 = 0 ;
20096	–	std::string arg3 ;
20097	–	std::string arg4 ;
20098	–	std::string arg5 ;
20099	–	std::string arg6 ;
20100	–	std::string arg7 ;
20101	–	bool arg8 ;
20102	–	int result;
20103	–	void *argp1 = 0 ;
20104	–	int res1 = 0 ;
20105	–	int res2 = SWIG_OLDOBJ ;
20106	–	bool val8 ;
20107	–	int ecode8 = 0 ;
20108	–	PyObject * obj0 = 0 ;
20109	–	PyObject * obj1 = 0 ;
20110	–	PyObject * obj2 = 0 ;
20111	–	PyObject * obj3 = 0 ;
20112	–	PyObject * obj4 = 0 ;
20113	–	PyObject * obj5 = 0 ;
20114	–	PyObject * obj6 = 0 ;
20115	–	PyObject * obj7 = 0 ;
20116	–
20117	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
20118	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20119	–	if (!SWIG_IsOK(res1)) {
20120	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20121	–	}
20122	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20123	–	{
20124	–	std::string *ptr = (std::string *)0;
20125	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20126	–	if (!SWIG_IsOK(res2)) {
20127	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20128	–	}
20129	–	if (!ptr) {
20130	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20131	–	}
20132	–	arg2 = ptr;
20133	–	}
20134	–	{
20135	–	std::string *ptr = (std::string *)0;
20136	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20137	–	if (!SWIG_IsOK(res) || !ptr) {
20138	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "3"" of type '" "std::string""'");
20139	–	}
20140	–	arg3 = *ptr;
20141	–	if (SWIG_IsNewObj(res)) delete ptr;
20142	–	}
20143	–	{
20144	–	std::string *ptr = (std::string *)0;
20145	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20146	–	if (!SWIG_IsOK(res) || !ptr) {
20147	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "4"" of type '" "std::string""'");
20148	–	}
20149	–	arg4 = *ptr;
20150	–	if (SWIG_IsNewObj(res)) delete ptr;
20151	–	}
20152	–	{
20153	–	std::string *ptr = (std::string *)0;
20154	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20155	–	if (!SWIG_IsOK(res) || !ptr) {
20156	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "5"" of type '" "std::string""'");
20157	–	}
20158	–	arg5 = *ptr;
20159	–	if (SWIG_IsNewObj(res)) delete ptr;
20160	–	}
20161	–	{
20162	–	std::string *ptr = (std::string *)0;
20163	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
20164	–	if (!SWIG_IsOK(res) || !ptr) {
20165	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "6"" of type '" "std::string""'");
20166	–	}
20167	–	arg6 = *ptr;
20168	–	if (SWIG_IsNewObj(res)) delete ptr;
20169	–	}
20170	–	{
20171	–	std::string *ptr = (std::string *)0;
20172	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
20173	–	if (!SWIG_IsOK(res) || !ptr) {
20174	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "7"" of type '" "std::string""'");
20175	–	}
20176	–	arg7 = *ptr;
20177	–	if (SWIG_IsNewObj(res)) delete ptr;
20178	–	}
20179	–	ecode8 = SWIG_AsVal_bool(obj7, &val8);
20180	–	if (!SWIG_IsOK(ecode8)) {
20181	–	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BossAdministratorSession_registerProgram" "', argument " "8"" of type '" "bool""'");
20182	–	}
20183	–	arg8 = static_cast< bool >(val8);
20184	–	{
20185	–	try {
20186	–	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
20187	–	} catch (const std::exception& e) {
20188	–	SWIG_exception(SWIG_RuntimeError, e.what());
20189	–	}
20190	–	}
20191	–	resultobj = SWIG_From_int(static_cast< int >(result));
20192	–	if (SWIG_IsNewObj(res2)) delete arg2;
20193	–	return resultobj;
20194	–	fail:
20195	–	if (SWIG_IsNewObj(res2)) delete arg2;
20196	–	return NULL;
20197	–	}
20198	–
20199	–
20200	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20201	–	PyObject *resultobj = 0;
20202	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20203	–	std::string *arg2 = 0 ;
20204	–	std::string arg3 ;
20205	–	std::string arg4 ;
20206	–	std::string arg5 ;
20207	–	std::string arg6 ;
20208	–	std::string arg7 ;
20209	–	int result;
20210	–	void *argp1 = 0 ;
20211	–	int res1 = 0 ;
20212	–	int res2 = SWIG_OLDOBJ ;
20213	–	PyObject * obj0 = 0 ;
20214	–	PyObject * obj1 = 0 ;
20215	–	PyObject * obj2 = 0 ;
20216	–	PyObject * obj3 = 0 ;
20217	–	PyObject * obj4 = 0 ;
20218	–	PyObject * obj5 = 0 ;
20219	–	PyObject * obj6 = 0 ;
20220	–
20221	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
20222	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20223	–	if (!SWIG_IsOK(res1)) {
20224	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20225	–	}
20226	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20227	–	{
20228	–	std::string *ptr = (std::string *)0;
20229	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20230	–	if (!SWIG_IsOK(res2)) {
20231	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20232	–	}
20233	–	if (!ptr) {
20234	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20235	–	}
20236	–	arg2 = ptr;
20237	–	}
20238	–	{
20239	–	std::string *ptr = (std::string *)0;
20240	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20241	–	if (!SWIG_IsOK(res) || !ptr) {
20242	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "3"" of type '" "std::string""'");
20243	–	}
20244	–	arg3 = *ptr;
20245	–	if (SWIG_IsNewObj(res)) delete ptr;
20246	–	}
20247	–	{
20248	–	std::string *ptr = (std::string *)0;
20249	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20250	–	if (!SWIG_IsOK(res) || !ptr) {
20251	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "4"" of type '" "std::string""'");
20252	–	}
20253	–	arg4 = *ptr;
20254	–	if (SWIG_IsNewObj(res)) delete ptr;
20255	–	}
20256	–	{
20257	–	std::string *ptr = (std::string *)0;
20258	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20259	–	if (!SWIG_IsOK(res) || !ptr) {
20260	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "5"" of type '" "std::string""'");
20261	–	}
20262	–	arg5 = *ptr;
20263	–	if (SWIG_IsNewObj(res)) delete ptr;
20264	–	}
20265	–	{
20266	–	std::string *ptr = (std::string *)0;
20267	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
20268	–	if (!SWIG_IsOK(res) || !ptr) {
20269	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "6"" of type '" "std::string""'");
20270	–	}
20271	–	arg6 = *ptr;
20272	–	if (SWIG_IsNewObj(res)) delete ptr;
20273	–	}
20274	–	{
20275	–	std::string *ptr = (std::string *)0;
20276	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
20277	–	if (!SWIG_IsOK(res) || !ptr) {
20278	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "7"" of type '" "std::string""'");
20279	–	}
20280	–	arg7 = *ptr;
20281	–	if (SWIG_IsNewObj(res)) delete ptr;
20282	–	}
20283	–	{
20284	–	try {
20285	–	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
20286	–	} catch (const std::exception& e) {
20287	–	SWIG_exception(SWIG_RuntimeError, e.what());
20288	–	}
20289	–	}
20290	–	resultobj = SWIG_From_int(static_cast< int >(result));
20291	–	if (SWIG_IsNewObj(res2)) delete arg2;
20292	–	return resultobj;
20293	–	fail:
20294	–	if (SWIG_IsNewObj(res2)) delete arg2;
20295	–	return NULL;
20296	–	}
20297	–
20298	–
20299	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300	–	PyObject *resultobj = 0;
20301	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20302	–	std::string *arg2 = 0 ;
20303	–	std::string arg3 ;
20304	–	std::string arg4 ;
20305	–	std::string arg5 ;
20306	–	std::string arg6 ;
20307	–	int result;
20308	–	void *argp1 = 0 ;
20309	–	int res1 = 0 ;
20310	–	int res2 = SWIG_OLDOBJ ;
20311	–	PyObject * obj0 = 0 ;
20312	–	PyObject * obj1 = 0 ;
20313	–	PyObject * obj2 = 0 ;
20314	–	PyObject * obj3 = 0 ;
20315	–	PyObject * obj4 = 0 ;
20316	–	PyObject * obj5 = 0 ;
20317	–
20318	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20319	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20320	–	if (!SWIG_IsOK(res1)) {
20321	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20322	–	}
20323	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20324	–	{
20325	–	std::string *ptr = (std::string *)0;
20326	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20327	–	if (!SWIG_IsOK(res2)) {
20328	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20329	–	}
20330	–	if (!ptr) {
20331	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20332	–	}
20333	–	arg2 = ptr;
20334	–	}
20335	–	{
20336	–	std::string *ptr = (std::string *)0;
20337	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20338	–	if (!SWIG_IsOK(res) || !ptr) {
20339	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "3"" of type '" "std::string""'");
20340	–	}
20341	–	arg3 = *ptr;
20342	–	if (SWIG_IsNewObj(res)) delete ptr;
20343	–	}
20344	–	{
20345	–	std::string *ptr = (std::string *)0;
20346	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20347	–	if (!SWIG_IsOK(res) || !ptr) {
20348	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "4"" of type '" "std::string""'");
20349	–	}
20350	–	arg4 = *ptr;
20351	–	if (SWIG_IsNewObj(res)) delete ptr;
20352	–	}
20353	–	{
20354	–	std::string *ptr = (std::string *)0;
20355	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20356	–	if (!SWIG_IsOK(res) || !ptr) {
20357	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "5"" of type '" "std::string""'");
20358	–	}
20359	–	arg5 = *ptr;
20360	–	if (SWIG_IsNewObj(res)) delete ptr;
20361	–	}
20362	–	{
20363	–	std::string *ptr = (std::string *)0;
20364	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
20365	–	if (!SWIG_IsOK(res) || !ptr) {
20366	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "6"" of type '" "std::string""'");
20367	–	}
20368	–	arg6 = *ptr;
20369	–	if (SWIG_IsNewObj(res)) delete ptr;
20370	–	}
20371	–	{
20372	–	try {
20373	–	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6);
20374	–	} catch (const std::exception& e) {
20375	–	SWIG_exception(SWIG_RuntimeError, e.what());
20376	–	}
20377	–	}
20378	–	resultobj = SWIG_From_int(static_cast< int >(result));
20379	–	if (SWIG_IsNewObj(res2)) delete arg2;
20380	–	return resultobj;
20381	–	fail:
20382	–	if (SWIG_IsNewObj(res2)) delete arg2;
20383	–	return NULL;
20384	–	}
20385	–
20386	–
20387	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20388	–	PyObject *resultobj = 0;
20389	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20390	–	std::string *arg2 = 0 ;
20391	–	std::string arg3 ;
20392	–	std::string arg4 ;
20393	–	std::string arg5 ;
20394	–	int result;
20395	–	void *argp1 = 0 ;
20396	–	int res1 = 0 ;
20397	–	int res2 = SWIG_OLDOBJ ;
20398	–	PyObject * obj0 = 0 ;
20399	–	PyObject * obj1 = 0 ;
20400	–	PyObject * obj2 = 0 ;
20401	–	PyObject * obj3 = 0 ;
20402	–	PyObject * obj4 = 0 ;
20403	–
20404	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20405	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20406	–	if (!SWIG_IsOK(res1)) {
20407	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20408	–	}
20409	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20410	–	{
20411	–	std::string *ptr = (std::string *)0;
20412	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20413	–	if (!SWIG_IsOK(res2)) {
20414	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20415	–	}
20416	–	if (!ptr) {
20417	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20418	–	}
20419	–	arg2 = ptr;
20420	–	}
20421	–	{
20422	–	std::string *ptr = (std::string *)0;
20423	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20424	–	if (!SWIG_IsOK(res) || !ptr) {
20425	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "3"" of type '" "std::string""'");
20426	–	}
20427	–	arg3 = *ptr;
20428	–	if (SWIG_IsNewObj(res)) delete ptr;
20429	–	}
20430	–	{
20431	–	std::string *ptr = (std::string *)0;
20432	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20433	–	if (!SWIG_IsOK(res) || !ptr) {
20434	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "4"" of type '" "std::string""'");
20435	–	}
20436	–	arg4 = *ptr;
20437	–	if (SWIG_IsNewObj(res)) delete ptr;
20438	–	}
20439	–	{
20440	–	std::string *ptr = (std::string *)0;
20441	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20442	–	if (!SWIG_IsOK(res) || !ptr) {
20443	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "5"" of type '" "std::string""'");
20444	–	}
20445	–	arg5 = *ptr;
20446	–	if (SWIG_IsNewObj(res)) delete ptr;
20447	–	}
20448	–	{
20449	–	try {
20450	–	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5);
20451	–	} catch (const std::exception& e) {
20452	–	SWIG_exception(SWIG_RuntimeError, e.what());
20453	–	}
20454	–	}
20455	–	resultobj = SWIG_From_int(static_cast< int >(result));
20456	–	if (SWIG_IsNewObj(res2)) delete arg2;
20457	–	return resultobj;
20458	–	fail:
20459	–	if (SWIG_IsNewObj(res2)) delete arg2;
20460	–	return NULL;
20461	–	}
20462	–
20463	–
20464	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20465	–	PyObject *resultobj = 0;
20466	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20467	–	std::string *arg2 = 0 ;
20468	–	std::string arg3 ;
20469	–	std::string arg4 ;
20470	–	int result;
20471	–	void *argp1 = 0 ;
20472	–	int res1 = 0 ;
20473	–	int res2 = SWIG_OLDOBJ ;
20474	–	PyObject * obj0 = 0 ;
20475	–	PyObject * obj1 = 0 ;
20476	–	PyObject * obj2 = 0 ;
20477	–	PyObject * obj3 = 0 ;
20478	–
20479	–	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20480	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20481	–	if (!SWIG_IsOK(res1)) {
20482	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20483	–	}
20484	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20485	–	{
20486	–	std::string *ptr = (std::string *)0;
20487	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20488	–	if (!SWIG_IsOK(res2)) {
20489	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20490	–	}
20491	–	if (!ptr) {
20492	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20493	–	}
20494	–	arg2 = ptr;
20495	–	}
20496	–	{
20497	–	std::string *ptr = (std::string *)0;
20498	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20499	–	if (!SWIG_IsOK(res) || !ptr) {
20500	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "3"" of type '" "std::string""'");
5675		}
5676	<	arg3 = *ptr;
5677	<	if (SWIG_IsNewObj(res)) delete ptr;
5678	<	}
20505	<	{
20506	<	std::string *ptr = (std::string *)0;
20507	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20508	<	if (!SWIG_IsOK(res) || !ptr) {
20509	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "4"" of type '" "std::string""'");
5676	>	if (obj4) {
5677	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5678	>	if (PyErr_Occurred()) SWIG_fail;
5679		}
5680	<	arg4 = *ptr;
5681	<	if (SWIG_IsNewObj(res)) delete ptr;
5682	<	}
20514	<	{
20515	<	try {
20516	<	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4);
20517	<	} catch (const std::exception& e) {
20518	<	SWIG_exception(SWIG_RuntimeError, e.what());
5680	>	if (obj5) {
5681	>	arg6 = PyInt_AsLong(obj5) ? true : false;
5682	>	if (PyErr_Occurred()) SWIG_fail;
5683		}
5684	<	}
5685	<	resultobj = SWIG_From_int(static_cast< int >(result));
5686	<	if (SWIG_IsNewObj(res2)) delete arg2;
5687	<	return resultobj;
5688	<	fail:
5689	<	if (SWIG_IsNewObj(res2)) delete arg2;
5690	<	return NULL;
5691	<	}
5692	<
5693	<
5694	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20531	<	PyObject *resultobj = 0;
20532	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20533	<	std::string *arg2 = 0 ;
20534	<	std::string arg3 ;
20535	<	int result;
20536	<	void *argp1 = 0 ;
20537	<	int res1 = 0 ;
20538	<	int res2 = SWIG_OLDOBJ ;
20539	<	PyObject * obj0 = 0 ;
20540	<	PyObject * obj1 = 0 ;
20541	<	PyObject * obj2 = 0 ;
20542	<
20543	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2)) SWIG_fail;
20544	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20545	<	if (!SWIG_IsOK(res1)) {
20546	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20547	<	}
20548	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20549	<	{
20550	<	std::string *ptr = (std::string *)0;
20551	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20552	<	if (!SWIG_IsOK(res2)) {
20553	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20554	<	}
20555	<	if (!ptr) {
20556	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20557	<	}
20558	<	arg2 = ptr;
20559	<	}
20560	<	{
20561	<	std::string *ptr = (std::string *)0;
20562	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20563	<	if (!SWIG_IsOK(res) || !ptr) {
20564	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "3"" of type '" "std::string""'");
20565	<	}
20566	<	arg3 = *ptr;
20567	<	if (SWIG_IsNewObj(res)) delete ptr;
20568	<	}
20569	<	{
20570	<	try {
20571	<	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3);
20572	<	} catch (const std::exception& e) {
20573	<	SWIG_exception(SWIG_RuntimeError, e.what());
20574	<	}
20575	<	}
20576	<	resultobj = SWIG_From_int(static_cast< int >(result));
20577	<	if (SWIG_IsNewObj(res2)) delete arg2;
20578	<	return resultobj;
20579	<	fail:
20580	<	if (SWIG_IsNewObj(res2)) delete arg2;
20581	<	return NULL;
20582	<	}
20583	<
20584	<
20585	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20586	<	PyObject *resultobj = 0;
20587	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20588	<	std::string *arg2 = 0 ;
20589	<	int result;
20590	<	void *argp1 = 0 ;
20591	<	int res1 = 0 ;
20592	<	int res2 = SWIG_OLDOBJ ;
20593	<	PyObject * obj0 = 0 ;
20594	<	PyObject * obj1 = 0 ;
20595	<
20596	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerProgram",&obj0,&obj1)) SWIG_fail;
20597	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20598	<	if (!SWIG_IsOK(res1)) {
20599	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20600	<	}
20601	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20602	<	{
20603	<	std::string *ptr = (std::string *)0;
20604	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20605	<	if (!SWIG_IsOK(res2)) {
20606	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20607	<	}
20608	<	if (!ptr) {
20609	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20610	<	}
20611	<	arg2 = ptr;
20612	<	}
20613	<	{
20614	<	try {
20615	<	result = (int)(arg1)->registerProgram((std::string const &)*arg2);
20616	<	} catch (const std::exception& e) {
20617	<	SWIG_exception(SWIG_RuntimeError, e.what());
5684	>	{
5685	>	try {
5686	>	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5687	>
5688	>	}catch (const BossSchedFailure & e) {
5689	>	PyErr_SetString ( SchedulerError, e.what() );
5690	>	return NULL;
5691	>	}catch (const std::exception& e) {
5692	>	PyErr_SetString ( BossError, e.what() );
5693	>	return NULL;
5694	>	}
5695		}
5696	<	}
5697	<	resultobj = SWIG_From_int(static_cast< int >(result));
5698	<	if (SWIG_IsNewObj(res2)) delete arg2;
5699	<	return resultobj;
20623	<	fail:
20624	<	if (SWIG_IsNewObj(res2)) delete arg2;
20625	<	return NULL;
5696	>	resultobj = PyInt_FromLong((long)result);
5697	>	return resultobj;
5698	>	fail:
5699	>	return NULL;
5700		}
5701
5702
5703	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
5704	<	int argc;
5705	<	PyObject *argv[9];
5706	<	int ii;
5707	<
5708	<	if (!PyTuple_Check(args)) SWIG_fail;
5709	<	argc = PyObject_Length(args);
5710	<	for (ii = 0; (ii < argc) && (ii < 8); ii++) {
5711	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5712	<	}
5713	<	if (argc == 2) {
5714	<	int _v;
5715	<	void *vptr = 0;
5716	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5717	<	_v = SWIG_CheckState(res);
5718	<	if (_v) {
5719	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5720	<	_v = SWIG_CheckState(res);
5721	<	if (_v) {
5722	<	return _wrap_BossAdministratorSession_registerProgram__SWIG_6(self, args);
5723	<	}
5724	<	}
5725	<	}
5726	<	if (argc == 3) {
5727	<	int _v;
5728	<	void *vptr = 0;
5729	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5730	<	_v = SWIG_CheckState(res);
5731	<	if (_v) {
20658	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
20659	<	_v = SWIG_CheckState(res);
20660	<	if (_v) {
20661	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
20662	<	_v = SWIG_CheckState(res);
20663	<	if (_v) {
20664	<	return _wrap_BossAdministratorSession_registerProgram__SWIG_5(self, args);
5703	>	static PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
5704	>	PyObject *resultobj;
5705	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5706	>	std::string *arg2 = 0 ;
5707	>	std::string arg3 = (std::string) "NULL" ;
5708	>	std::string arg4 = (std::string) "NULL" ;
5709	>	std::string arg5 = (std::string) "NULL" ;
5710	>	std::string arg6 = (std::string) "NULL" ;
5711	>	std::string arg7 = (std::string) "" ;
5712	>	bool arg8 = (bool) false ;
5713	>	int result;
5714	>	std::string temp2 ;
5715	>	PyObject * obj0 = 0 ;
5716	>	PyObject * obj1 = 0 ;
5717	>	PyObject * obj2 = 0 ;
5718	>	PyObject * obj3 = 0 ;
5719	>	PyObject * obj4 = 0 ;
5720	>	PyObject * obj5 = 0 ;
5721	>	PyObject * obj6 = 0 ;
5722	>	PyObject * obj7 = 0 ;
5723	>
5724	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5725	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5726	>	{
5727	>	if (PyString_Check(obj1)) {
5728	>	temp2 = std::string(PyString_AsString(obj1));
5729	>	arg2 = &temp2;
5730	>	}else {
5731	>	SWIG_exception(SWIG_TypeError, "string expected");
5732		}
20666	–	}
5733		}
5734	<	}
5735	<	if (argc == 4) {
5736	<	int _v;
5737	<	void *vptr = 0;
5738	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5739	<	_v = SWIG_CheckState(res);
20674	<	if (_v) {
20675	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
20676	<	_v = SWIG_CheckState(res);
20677	<	if (_v) {
20678	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
20679	<	_v = SWIG_CheckState(res);
20680	<	if (_v) {
20681	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
20682	<	_v = SWIG_CheckState(res);
20683	<	if (_v) {
20684	<	return _wrap_BossAdministratorSession_registerProgram__SWIG_4(self, args);
20685	<	}
5734	>	if (obj2) {
5735	>	{
5736	>	if (PyString_Check(obj2))
5737	>	arg3 = std::string(PyString_AsString(obj2));
5738	>	else
5739	>	SWIG_exception(SWIG_TypeError, "string expected");
5740		}
20687	–	}
5741		}
5742	<	}
5743	<	if (argc == 5) {
5744	<	int _v;
5745	<	void *vptr = 0;
5746	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5747	<	_v = SWIG_CheckState(res);
20695	<	if (_v) {
20696	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
20697	<	_v = SWIG_CheckState(res);
20698	<	if (_v) {
20699	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
20700	<	_v = SWIG_CheckState(res);
20701	<	if (_v) {
20702	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
20703	<	_v = SWIG_CheckState(res);
20704	<	if (_v) {
20705	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
20706	<	_v = SWIG_CheckState(res);
20707	<	if (_v) {
20708	<	return _wrap_BossAdministratorSession_registerProgram__SWIG_3(self, args);
20709	<	}
20710	<	}
5742	>	if (obj3) {
5743	>	{
5744	>	if (PyString_Check(obj3))
5745	>	arg4 = std::string(PyString_AsString(obj3));
5746	>	else
5747	>	SWIG_exception(SWIG_TypeError, "string expected");
5748		}
20712	–	}
5749		}
5750	<	}
5751	<	if (argc == 6) {
5752	<	int _v;
5753	<	void *vptr = 0;
5754	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5755	<	_v = SWIG_CheckState(res);
20720	<	if (_v) {
20721	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
20722	<	_v = SWIG_CheckState(res);
20723	<	if (_v) {
20724	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
20725	<	_v = SWIG_CheckState(res);
20726	<	if (_v) {
20727	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
20728	<	_v = SWIG_CheckState(res);
20729	<	if (_v) {
20730	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
20731	<	_v = SWIG_CheckState(res);
20732	<	if (_v) {
20733	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
20734	<	_v = SWIG_CheckState(res);
20735	<	if (_v) {
20736	<	return _wrap_BossAdministratorSession_registerProgram__SWIG_2(self, args);
20737	<	}
20738	<	}
20739	<	}
5750	>	if (obj4) {
5751	>	{
5752	>	if (PyString_Check(obj4))
5753	>	arg5 = std::string(PyString_AsString(obj4));
5754	>	else
5755	>	SWIG_exception(SWIG_TypeError, "string expected");
5756		}
20741	–	}
5757		}
5758	<	}
5759	<	if (argc == 7) {
5760	<	int _v;
5761	<	void *vptr = 0;
5762	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5763	<	_v = SWIG_CheckState(res);
20749	<	if (_v) {
20750	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
20751	<	_v = SWIG_CheckState(res);
20752	<	if (_v) {
20753	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
20754	<	_v = SWIG_CheckState(res);
20755	<	if (_v) {
20756	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
20757	<	_v = SWIG_CheckState(res);
20758	<	if (_v) {
20759	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
20760	<	_v = SWIG_CheckState(res);
20761	<	if (_v) {
20762	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
20763	<	_v = SWIG_CheckState(res);
20764	<	if (_v) {
20765	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
20766	<	_v = SWIG_CheckState(res);
20767	<	if (_v) {
20768	<	return _wrap_BossAdministratorSession_registerProgram__SWIG_1(self, args);
20769	<	}
20770	<	}
20771	<	}
20772	<	}
5758	>	if (obj5) {
5759	>	{
5760	>	if (PyString_Check(obj5))
5761	>	arg6 = std::string(PyString_AsString(obj5));
5762	>	else
5763	>	SWIG_exception(SWIG_TypeError, "string expected");
5764		}
20774	–	}
5765		}
5766	<	}
5767	<	if (argc == 8) {
5768	<	int _v;
5769	<	void *vptr = 0;
5770	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5771	<	_v = SWIG_CheckState(res);
20782	<	if (_v) {
20783	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
20784	<	_v = SWIG_CheckState(res);
20785	<	if (_v) {
20786	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
20787	<	_v = SWIG_CheckState(res);
20788	<	if (_v) {
20789	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
20790	<	_v = SWIG_CheckState(res);
20791	<	if (_v) {
20792	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
20793	<	_v = SWIG_CheckState(res);
20794	<	if (_v) {
20795	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
20796	<	_v = SWIG_CheckState(res);
20797	<	if (_v) {
20798	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
20799	<	_v = SWIG_CheckState(res);
20800	<	if (_v) {
20801	<	{
20802	<	int res = SWIG_AsVal_bool(argv[7], NULL);
20803	<	_v = SWIG_CheckState(res);
20804	<	}
20805	<	if (_v) {
20806	<	return _wrap_BossAdministratorSession_registerProgram__SWIG_0(self, args);
20807	<	}
20808	<	}
20809	<	}
20810	<	}
20811	<	}
5766	>	if (obj6) {
5767	>	{
5768	>	if (PyString_Check(obj6))
5769	>	arg7 = std::string(PyString_AsString(obj6));
5770	>	else
5771	>	SWIG_exception(SWIG_TypeError, "string expected");
5772		}
20813	–	}
20814	–	}
20815	–	}
20816	–
20817	–	fail:
20818	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_registerProgram'");
20819	–	return NULL;
20820	–	}
20821	–
20822	–
20823	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20824	–	PyObject *resultobj = 0;
20825	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20826	–	std::string *arg2 = 0 ;
20827	–	std::string arg3 ;
20828	–	std::string arg4 ;
20829	–	std::string arg5 ;
20830	–	bool arg6 ;
20831	–	bool arg7 ;
20832	–	int result;
20833	–	void *argp1 = 0 ;
20834	–	int res1 = 0 ;
20835	–	int res2 = SWIG_OLDOBJ ;
20836	–	bool val6 ;
20837	–	int ecode6 = 0 ;
20838	–	bool val7 ;
20839	–	int ecode7 = 0 ;
20840	–	PyObject * obj0 = 0 ;
20841	–	PyObject * obj1 = 0 ;
20842	–	PyObject * obj2 = 0 ;
20843	–	PyObject * obj3 = 0 ;
20844	–	PyObject * obj4 = 0 ;
20845	–	PyObject * obj5 = 0 ;
20846	–	PyObject * obj6 = 0 ;
20847	–
20848	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
20849	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20850	–	if (!SWIG_IsOK(res1)) {
20851	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20852	–	}
20853	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20854	–	{
20855	–	std::string *ptr = (std::string *)0;
20856	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20857	–	if (!SWIG_IsOK(res2)) {
20858	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
20859	–	}
20860	–	if (!ptr) {
20861	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
20862	–	}
20863	–	arg2 = ptr;
20864	–	}
20865	–	{
20866	–	std::string *ptr = (std::string *)0;
20867	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20868	–	if (!SWIG_IsOK(res) || !ptr) {
20869	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
20870	–	}
20871	–	arg3 = *ptr;
20872	–	if (SWIG_IsNewObj(res)) delete ptr;
20873	–	}
20874	–	{
20875	–	std::string *ptr = (std::string *)0;
20876	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20877	–	if (!SWIG_IsOK(res) || !ptr) {
20878	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "4"" of type '" "std::string""'");
20879	–	}
20880	–	arg4 = *ptr;
20881	–	if (SWIG_IsNewObj(res)) delete ptr;
20882	–	}
20883	–	{
20884	–	std::string *ptr = (std::string *)0;
20885	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20886	–	if (!SWIG_IsOK(res) || !ptr) {
20887	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "5"" of type '" "std::string""'");
20888	–	}
20889	–	arg5 = *ptr;
20890	–	if (SWIG_IsNewObj(res)) delete ptr;
20891	–	}
20892	–	ecode6 = SWIG_AsVal_bool(obj5, &val6);
20893	–	if (!SWIG_IsOK(ecode6)) {
20894	–	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "6"" of type '" "bool""'");
20895	–	}
20896	–	arg6 = static_cast< bool >(val6);
20897	–	ecode7 = SWIG_AsVal_bool(obj6, &val7);
20898	–	if (!SWIG_IsOK(ecode7)) {
20899	–	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "7"" of type '" "bool""'");
20900	–	}
20901	–	arg7 = static_cast< bool >(val7);
20902	–	{
20903	–	try {
20904	–	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
20905	–	} catch (const std::exception& e) {
20906	–	SWIG_exception(SWIG_RuntimeError, e.what());
20907	–	}
20908	–	}
20909	–	resultobj = SWIG_From_int(static_cast< int >(result));
20910	–	if (SWIG_IsNewObj(res2)) delete arg2;
20911	–	return resultobj;
20912	–	fail:
20913	–	if (SWIG_IsNewObj(res2)) delete arg2;
20914	–	return NULL;
20915	–	}
20916	–
20917	–
20918	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20919	–	PyObject *resultobj = 0;
20920	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20921	–	std::string *arg2 = 0 ;
20922	–	std::string arg3 ;
20923	–	std::string arg4 ;
20924	–	std::string arg5 ;
20925	–	bool arg6 ;
20926	–	int result;
20927	–	void *argp1 = 0 ;
20928	–	int res1 = 0 ;
20929	–	int res2 = SWIG_OLDOBJ ;
20930	–	bool val6 ;
20931	–	int ecode6 = 0 ;
20932	–	PyObject * obj0 = 0 ;
20933	–	PyObject * obj1 = 0 ;
20934	–	PyObject * obj2 = 0 ;
20935	–	PyObject * obj3 = 0 ;
20936	–	PyObject * obj4 = 0 ;
20937	–	PyObject * obj5 = 0 ;
20938	–
20939	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20940	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20941	–	if (!SWIG_IsOK(res1)) {
20942	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20943	–	}
20944	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20945	–	{
20946	–	std::string *ptr = (std::string *)0;
20947	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20948	–	if (!SWIG_IsOK(res2)) {
20949	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
5773		}
5774	<	if (!ptr) {
5775	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
5776	<	}
20954	<	arg2 = ptr;
20955	<	}
20956	<	{
20957	<	std::string *ptr = (std::string *)0;
20958	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20959	<	if (!SWIG_IsOK(res) || !ptr) {
20960	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
5774	>	if (obj7) {
5775	>	arg8 = PyInt_AsLong(obj7) ? true : false;
5776	>	if (PyErr_Occurred()) SWIG_fail;
5777		}
5778	<	arg3 = *ptr;
5779	<	if (SWIG_IsNewObj(res)) delete ptr;
5780	<	}
5781	<	{
5782	<	std::string *ptr = (std::string *)0;
5783	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
5784	<	if (!SWIG_IsOK(res) || !ptr) {
5785	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "4"" of type '" "std::string""'");
5786	<	}
5787	<	arg4 = *ptr;
5788	<	if (SWIG_IsNewObj(res)) delete ptr;
20973	<	}
20974	<	{
20975	<	std::string *ptr = (std::string *)0;
20976	<	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20977	<	if (!SWIG_IsOK(res) || !ptr) {
20978	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "5"" of type '" "std::string""'");
20979	<	}
20980	<	arg5 = *ptr;
20981	<	if (SWIG_IsNewObj(res)) delete ptr;
20982	<	}
20983	<	ecode6 = SWIG_AsVal_bool(obj5, &val6);
20984	<	if (!SWIG_IsOK(ecode6)) {
20985	<	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "6"" of type '" "bool""'");
20986	<	}
20987	<	arg6 = static_cast< bool >(val6);
20988	<	{
20989	<	try {
20990	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6);
20991	<	} catch (const std::exception& e) {
20992	<	SWIG_exception(SWIG_RuntimeError, e.what());
20993	<	}
20994	<	}
20995	<	resultobj = SWIG_From_int(static_cast< int >(result));
20996	<	if (SWIG_IsNewObj(res2)) delete arg2;
20997	<	return resultobj;
20998	<	fail:
20999	<	if (SWIG_IsNewObj(res2)) delete arg2;
21000	<	return NULL;
21001	<	}
21002	<
21003	<
21004	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21005	<	PyObject *resultobj = 0;
21006	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21007	<	std::string *arg2 = 0 ;
21008	<	std::string arg3 ;
21009	<	std::string arg4 ;
21010	<	std::string arg5 ;
21011	<	int result;
21012	<	void *argp1 = 0 ;
21013	<	int res1 = 0 ;
21014	<	int res2 = SWIG_OLDOBJ ;
21015	<	PyObject * obj0 = 0 ;
21016	<	PyObject * obj1 = 0 ;
21017	<	PyObject * obj2 = 0 ;
21018	<	PyObject * obj3 = 0 ;
21019	<	PyObject * obj4 = 0 ;
21020	<
21021	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21022	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21023	<	if (!SWIG_IsOK(res1)) {
21024	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21025	<	}
21026	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21027	<	{
21028	<	std::string *ptr = (std::string *)0;
21029	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21030	<	if (!SWIG_IsOK(res2)) {
21031	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21032	<	}
21033	<	if (!ptr) {
21034	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21035	<	}
21036	<	arg2 = ptr;
21037	<	}
21038	<	{
21039	<	std::string *ptr = (std::string *)0;
21040	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21041	<	if (!SWIG_IsOK(res) || !ptr) {
21042	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
21043	<	}
21044	<	arg3 = *ptr;
21045	<	if (SWIG_IsNewObj(res)) delete ptr;
21046	<	}
21047	<	{
21048	<	std::string *ptr = (std::string *)0;
21049	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21050	<	if (!SWIG_IsOK(res) || !ptr) {
21051	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "4"" of type '" "std::string""'");
21052	<	}
21053	<	arg4 = *ptr;
21054	<	if (SWIG_IsNewObj(res)) delete ptr;
21055	<	}
21056	<	{
21057	<	std::string *ptr = (std::string *)0;
21058	<	int res = SWIG_AsPtr_std_string(obj4, &ptr);
21059	<	if (!SWIG_IsOK(res) || !ptr) {
21060	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "5"" of type '" "std::string""'");
21061	<	}
21062	<	arg5 = *ptr;
21063	<	if (SWIG_IsNewObj(res)) delete ptr;
21064	<	}
21065	<	{
21066	<	try {
21067	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5);
21068	<	} catch (const std::exception& e) {
21069	<	SWIG_exception(SWIG_RuntimeError, e.what());
21070	<	}
21071	<	}
21072	<	resultobj = SWIG_From_int(static_cast< int >(result));
21073	<	if (SWIG_IsNewObj(res2)) delete arg2;
21074	<	return resultobj;
21075	<	fail:
21076	<	if (SWIG_IsNewObj(res2)) delete arg2;
21077	<	return NULL;
21078	<	}
21079	<
21080	<
21081	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21082	<	PyObject *resultobj = 0;
21083	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21084	<	std::string *arg2 = 0 ;
21085	<	std::string arg3 ;
21086	<	std::string arg4 ;
21087	<	int result;
21088	<	void *argp1 = 0 ;
21089	<	int res1 = 0 ;
21090	<	int res2 = SWIG_OLDOBJ ;
21091	<	PyObject * obj0 = 0 ;
21092	<	PyObject * obj1 = 0 ;
21093	<	PyObject * obj2 = 0 ;
21094	<	PyObject * obj3 = 0 ;
21095	<
21096	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21097	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21098	<	if (!SWIG_IsOK(res1)) {
21099	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21100	<	}
21101	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21102	<	{
21103	<	std::string *ptr = (std::string *)0;
21104	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21105	<	if (!SWIG_IsOK(res2)) {
21106	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21107	<	}
21108	<	if (!ptr) {
21109	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21110	<	}
21111	<	arg2 = ptr;
21112	<	}
21113	<	{
21114	<	std::string *ptr = (std::string *)0;
21115	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21116	<	if (!SWIG_IsOK(res) || !ptr) {
21117	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
21118	<	}
21119	<	arg3 = *ptr;
21120	<	if (SWIG_IsNewObj(res)) delete ptr;
21121	<	}
21122	<	{
21123	<	std::string *ptr = (std::string *)0;
21124	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21125	<	if (!SWIG_IsOK(res) || !ptr) {
21126	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "4"" of type '" "std::string""'");
21127	<	}
21128	<	arg4 = *ptr;
21129	<	if (SWIG_IsNewObj(res)) delete ptr;
21130	<	}
21131	<	{
21132	<	try {
21133	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4);
21134	<	} catch (const std::exception& e) {
21135	<	SWIG_exception(SWIG_RuntimeError, e.what());
21136	<	}
21137	<	}
21138	<	resultobj = SWIG_From_int(static_cast< int >(result));
21139	<	if (SWIG_IsNewObj(res2)) delete arg2;
21140	<	return resultobj;
21141	<	fail:
21142	<	if (SWIG_IsNewObj(res2)) delete arg2;
21143	<	return NULL;
21144	<	}
21145	<
21146	<
21147	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21148	<	PyObject *resultobj = 0;
21149	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21150	<	std::string *arg2 = 0 ;
21151	<	std::string arg3 ;
21152	<	int result;
21153	<	void *argp1 = 0 ;
21154	<	int res1 = 0 ;
21155	<	int res2 = SWIG_OLDOBJ ;
21156	<	PyObject * obj0 = 0 ;
21157	<	PyObject * obj1 = 0 ;
21158	<	PyObject * obj2 = 0 ;
21159	<
21160	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2)) SWIG_fail;
21161	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21162	<	if (!SWIG_IsOK(res1)) {
21163	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21164	<	}
21165	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21166	<	{
21167	<	std::string *ptr = (std::string *)0;
21168	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21169	<	if (!SWIG_IsOK(res2)) {
21170	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21171	<	}
21172	<	if (!ptr) {
21173	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21174	<	}
21175	<	arg2 = ptr;
21176	<	}
21177	<	{
21178	<	std::string *ptr = (std::string *)0;
21179	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21180	<	if (!SWIG_IsOK(res) || !ptr) {
21181	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
21182	<	}
21183	<	arg3 = *ptr;
21184	<	if (SWIG_IsNewObj(res)) delete ptr;
21185	<	}
21186	<	{
21187	<	try {
21188	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3);
21189	<	} catch (const std::exception& e) {
21190	<	SWIG_exception(SWIG_RuntimeError, e.what());
21191	<	}
21192	<	}
21193	<	resultobj = SWIG_From_int(static_cast< int >(result));
21194	<	if (SWIG_IsNewObj(res2)) delete arg2;
21195	<	return resultobj;
21196	<	fail:
21197	<	if (SWIG_IsNewObj(res2)) delete arg2;
21198	<	return NULL;
21199	<	}
21200	<
21201	<
21202	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21203	<	PyObject *resultobj = 0;
21204	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21205	<	std::string *arg2 = 0 ;
21206	<	int result;
21207	<	void *argp1 = 0 ;
21208	<	int res1 = 0 ;
21209	<	int res2 = SWIG_OLDOBJ ;
21210	<	PyObject * obj0 = 0 ;
21211	<	PyObject * obj1 = 0 ;
21212	<
21213	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerRTMon",&obj0,&obj1)) SWIG_fail;
21214	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21215	<	if (!SWIG_IsOK(res1)) {
21216	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21217	<	}
21218	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21219	<	{
21220	<	std::string *ptr = (std::string *)0;
21221	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21222	<	if (!SWIG_IsOK(res2)) {
21223	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21224	<	}
21225	<	if (!ptr) {
21226	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21227	<	}
21228	<	arg2 = ptr;
21229	<	}
21230	<	{
21231	<	try {
21232	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2);
21233	<	} catch (const std::exception& e) {
21234	<	SWIG_exception(SWIG_RuntimeError, e.what());
5778	>	{
5779	>	try {
5780	>	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5781	>
5782	>	}catch (const BossSchedFailure & e) {
5783	>	PyErr_SetString ( SchedulerError, e.what() );
5784	>	return NULL;
5785	>	}catch (const std::exception& e) {
5786	>	PyErr_SetString ( BossError, e.what() );
5787	>	return NULL;
5788	>	}
5789		}
5790	<	}
5791	<	resultobj = SWIG_From_int(static_cast< int >(result));
5792	<	if (SWIG_IsNewObj(res2)) delete arg2;
5793	<	return resultobj;
21240	<	fail:
21241	<	if (SWIG_IsNewObj(res2)) delete arg2;
21242	<	return NULL;
5790	>	resultobj = PyInt_FromLong((long)result);
5791	>	return resultobj;
5792	>	fail:
5793	>	return NULL;
5794		}
5795
5796
5797	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
5798	<	int argc;
5799	<	PyObject *argv[8];
5800	<	int ii;
5801	<
5802	<	if (!PyTuple_Check(args)) SWIG_fail;
5803	<	argc = PyObject_Length(args);
5804	<	for (ii = 0; (ii < argc) && (ii < 7); ii++) {
5805	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5806	<	}
5807	<	if (argc == 2) {
5808	<	int _v;
5809	<	void *vptr = 0;
5810	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5811	<	_v = SWIG_CheckState(res);
5812	<	if (_v) {
5813	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5814	<	_v = SWIG_CheckState(res);
5815	<	if (_v) {
5816	<	return _wrap_BossAdministratorSession_registerRTMon__SWIG_5(self, args);
5817	<	}
5818	<	}
5819	<	}
5820	<	if (argc == 3) {
5821	<	int _v;
5822	<	void *vptr = 0;
5823	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
21273	<	_v = SWIG_CheckState(res);
21274	<	if (_v) {
21275	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
21276	<	_v = SWIG_CheckState(res);
21277	<	if (_v) {
21278	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
21279	<	_v = SWIG_CheckState(res);
21280	<	if (_v) {
21281	<	return _wrap_BossAdministratorSession_registerRTMon__SWIG_4(self, args);
21282	<	}
21283	<	}
21284	<	}
21285	<	}
21286	<	if (argc == 4) {
21287	<	int _v;
21288	<	void *vptr = 0;
21289	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
21290	<	_v = SWIG_CheckState(res);
21291	<	if (_v) {
21292	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
21293	<	_v = SWIG_CheckState(res);
21294	<	if (_v) {
21295	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
21296	<	_v = SWIG_CheckState(res);
21297	<	if (_v) {
21298	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
21299	<	_v = SWIG_CheckState(res);
21300	<	if (_v) {
21301	<	return _wrap_BossAdministratorSession_registerRTMon__SWIG_3(self, args);
21302	<	}
5797	>	static PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
5798	>	PyObject *resultobj;
5799	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5800	>	std::string *arg2 = 0 ;
5801	>	std::string arg3 = (std::string) "NULL" ;
5802	>	std::string arg4 = (std::string) "NULL" ;
5803	>	std::string arg5 = (std::string) "NULL" ;
5804	>	bool arg6 = (bool) false ;
5805	>	bool arg7 = (bool) false ;
5806	>	int result;
5807	>	std::string temp2 ;
5808	>	PyObject * obj0 = 0 ;
5809	>	PyObject * obj1 = 0 ;
5810	>	PyObject * obj2 = 0 ;
5811	>	PyObject * obj3 = 0 ;
5812	>	PyObject * obj4 = 0 ;
5813	>	PyObject * obj5 = 0 ;
5814	>	PyObject * obj6 = 0 ;
5815	>
5816	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5817	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5818	>	{
5819	>	if (PyString_Check(obj1)) {
5820	>	temp2 = std::string(PyString_AsString(obj1));
5821	>	arg2 = &temp2;
5822	>	}else {
5823	>	SWIG_exception(SWIG_TypeError, "string expected");
5824		}
21304	–	}
5825		}
5826	<	}
5827	<	if (argc == 5) {
5828	<	int _v;
5829	<	void *vptr = 0;
5830	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5831	<	_v = SWIG_CheckState(res);
21312	<	if (_v) {
21313	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
21314	<	_v = SWIG_CheckState(res);
21315	<	if (_v) {
21316	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
21317	<	_v = SWIG_CheckState(res);
21318	<	if (_v) {
21319	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
21320	<	_v = SWIG_CheckState(res);
21321	<	if (_v) {
21322	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
21323	<	_v = SWIG_CheckState(res);
21324	<	if (_v) {
21325	<	return _wrap_BossAdministratorSession_registerRTMon__SWIG_2(self, args);
21326	<	}
21327	<	}
5826	>	if (obj2) {
5827	>	{
5828	>	if (PyString_Check(obj2))
5829	>	arg3 = std::string(PyString_AsString(obj2));
5830	>	else
5831	>	SWIG_exception(SWIG_TypeError, "string expected");
5832		}
21329	–	}
5833		}
5834	<	}
5835	<	if (argc == 6) {
5836	<	int _v;
5837	<	void *vptr = 0;
5838	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5839	<	_v = SWIG_CheckState(res);
21337	<	if (_v) {
21338	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
21339	<	_v = SWIG_CheckState(res);
21340	<	if (_v) {
21341	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
21342	<	_v = SWIG_CheckState(res);
21343	<	if (_v) {
21344	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
21345	<	_v = SWIG_CheckState(res);
21346	<	if (_v) {
21347	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
21348	<	_v = SWIG_CheckState(res);
21349	<	if (_v) {
21350	<	{
21351	<	int res = SWIG_AsVal_bool(argv[5], NULL);
21352	<	_v = SWIG_CheckState(res);
21353	<	}
21354	<	if (_v) {
21355	<	return _wrap_BossAdministratorSession_registerRTMon__SWIG_1(self, args);
21356	<	}
21357	<	}
21358	<	}
5834	>	if (obj3) {
5835	>	{
5836	>	if (PyString_Check(obj3))
5837	>	arg4 = std::string(PyString_AsString(obj3));
5838	>	else
5839	>	SWIG_exception(SWIG_TypeError, "string expected");
5840		}
21360	–	}
5841		}
5842	<	}
5843	<	if (argc == 7) {
5844	<	int _v;
5845	<	void *vptr = 0;
5846	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5847	<	_v = SWIG_CheckState(res);
21368	<	if (_v) {
21369	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
21370	<	_v = SWIG_CheckState(res);
21371	<	if (_v) {
21372	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
21373	<	_v = SWIG_CheckState(res);
21374	<	if (_v) {
21375	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
21376	<	_v = SWIG_CheckState(res);
21377	<	if (_v) {
21378	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
21379	<	_v = SWIG_CheckState(res);
21380	<	if (_v) {
21381	<	{
21382	<	int res = SWIG_AsVal_bool(argv[5], NULL);
21383	<	_v = SWIG_CheckState(res);
21384	<	}
21385	<	if (_v) {
21386	<	{
21387	<	int res = SWIG_AsVal_bool(argv[6], NULL);
21388	<	_v = SWIG_CheckState(res);
21389	<	}
21390	<	if (_v) {
21391	<	return _wrap_BossAdministratorSession_registerRTMon__SWIG_0(self, args);
21392	<	}
21393	<	}
21394	<	}
21395	<	}
5842	>	if (obj4) {
5843	>	{
5844	>	if (PyString_Check(obj4))
5845	>	arg5 = std::string(PyString_AsString(obj4));
5846	>	else
5847	>	SWIG_exception(SWIG_TypeError, "string expected");
5848		}
21397	–	}
21398	–	}
21399	–	}
21400	–
21401	–	fail:
21402	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_registerRTMon'");
21403	–	return NULL;
21404	–	}
21405	–
21406	–
21407	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21408	–	PyObject *resultobj = 0;
21409	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21410	–	std::string *arg2 = 0 ;
21411	–	std::string arg3 ;
21412	–	std::string arg4 ;
21413	–	std::string arg5 ;
21414	–	std::string arg6 ;
21415	–	std::string arg7 ;
21416	–	std::string arg8 ;
21417	–	std::string arg9 ;
21418	–	std::string arg10 ;
21419	–	std::string *arg11 = 0 ;
21420	–	std::string arg12 ;
21421	–	std::string arg13 ;
21422	–	bool arg14 ;
21423	–	bool arg15 ;
21424	–	int result;
21425	–	void *argp1 = 0 ;
21426	–	int res1 = 0 ;
21427	–	int res2 = SWIG_OLDOBJ ;
21428	–	int res11 = SWIG_OLDOBJ ;
21429	–	bool val14 ;
21430	–	int ecode14 = 0 ;
21431	–	bool val15 ;
21432	–	int ecode15 = 0 ;
21433	–	PyObject * obj0 = 0 ;
21434	–	PyObject * obj1 = 0 ;
21435	–	PyObject * obj2 = 0 ;
21436	–	PyObject * obj3 = 0 ;
21437	–	PyObject * obj4 = 0 ;
21438	–	PyObject * obj5 = 0 ;
21439	–	PyObject * obj6 = 0 ;
21440	–	PyObject * obj7 = 0 ;
21441	–	PyObject * obj8 = 0 ;
21442	–	PyObject * obj9 = 0 ;
21443	–	PyObject * obj10 = 0 ;
21444	–	PyObject * obj11 = 0 ;
21445	–	PyObject * obj12 = 0 ;
21446	–	PyObject * obj13 = 0 ;
21447	–	PyObject * obj14 = 0 ;
21448	–
21449	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
21450	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21451	–	if (!SWIG_IsOK(res1)) {
21452	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21453	–	}
21454	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21455	–	{
21456	–	std::string *ptr = (std::string *)0;
21457	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21458	–	if (!SWIG_IsOK(res2)) {
21459	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21460	–	}
21461	–	if (!ptr) {
21462	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21463	–	}
21464	–	arg2 = ptr;
21465	–	}
21466	–	{
21467	–	std::string *ptr = (std::string *)0;
21468	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21469	–	if (!SWIG_IsOK(res) || !ptr) {
21470	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
21471	–	}
21472	–	arg3 = *ptr;
21473	–	if (SWIG_IsNewObj(res)) delete ptr;
21474	–	}
21475	–	{
21476	–	std::string *ptr = (std::string *)0;
21477	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21478	–	if (!SWIG_IsOK(res) || !ptr) {
21479	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
21480	–	}
21481	–	arg4 = *ptr;
21482	–	if (SWIG_IsNewObj(res)) delete ptr;
21483	–	}
21484	–	{
21485	–	std::string *ptr = (std::string *)0;
21486	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
21487	–	if (!SWIG_IsOK(res) || !ptr) {
21488	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
21489	–	}
21490	–	arg5 = *ptr;
21491	–	if (SWIG_IsNewObj(res)) delete ptr;
21492	–	}
21493	–	{
21494	–	std::string *ptr = (std::string *)0;
21495	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
21496	–	if (!SWIG_IsOK(res) || !ptr) {
21497	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
21498	–	}
21499	–	arg6 = *ptr;
21500	–	if (SWIG_IsNewObj(res)) delete ptr;
21501	–	}
21502	–	{
21503	–	std::string *ptr = (std::string *)0;
21504	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
21505	–	if (!SWIG_IsOK(res) || !ptr) {
21506	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
21507	–	}
21508	–	arg7 = *ptr;
21509	–	if (SWIG_IsNewObj(res)) delete ptr;
21510	–	}
21511	–	{
21512	–	std::string *ptr = (std::string *)0;
21513	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
21514	–	if (!SWIG_IsOK(res) || !ptr) {
21515	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
21516	–	}
21517	–	arg8 = *ptr;
21518	–	if (SWIG_IsNewObj(res)) delete ptr;
21519	–	}
21520	–	{
21521	–	std::string *ptr = (std::string *)0;
21522	–	int res = SWIG_AsPtr_std_string(obj8, &ptr);
21523	–	if (!SWIG_IsOK(res) || !ptr) {
21524	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
21525	–	}
21526	–	arg9 = *ptr;
21527	–	if (SWIG_IsNewObj(res)) delete ptr;
21528	–	}
21529	–	{
21530	–	std::string *ptr = (std::string *)0;
21531	–	int res = SWIG_AsPtr_std_string(obj9, &ptr);
21532	–	if (!SWIG_IsOK(res) || !ptr) {
21533	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
21534	–	}
21535	–	arg10 = *ptr;
21536	–	if (SWIG_IsNewObj(res)) delete ptr;
21537	–	}
21538	–	{
21539	–	std::string *ptr = (std::string *)0;
21540	–	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
21541	–	if (!SWIG_IsOK(res11)) {
21542	–	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21543	–	}
21544	–	if (!ptr) {
21545	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21546	–	}
21547	–	arg11 = ptr;
21548	–	}
21549	–	{
21550	–	std::string *ptr = (std::string *)0;
21551	–	int res = SWIG_AsPtr_std_string(obj11, &ptr);
21552	–	if (!SWIG_IsOK(res) || !ptr) {
21553	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "12"" of type '" "std::string""'");
21554	–	}
21555	–	arg12 = *ptr;
21556	–	if (SWIG_IsNewObj(res)) delete ptr;
21557	–	}
21558	–	{
21559	–	std::string *ptr = (std::string *)0;
21560	–	int res = SWIG_AsPtr_std_string(obj12, &ptr);
21561	–	if (!SWIG_IsOK(res) || !ptr) {
21562	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "13"" of type '" "std::string""'");
21563	–	}
21564	–	arg13 = *ptr;
21565	–	if (SWIG_IsNewObj(res)) delete ptr;
21566	–	}
21567	–	ecode14 = SWIG_AsVal_bool(obj13, &val14);
21568	–	if (!SWIG_IsOK(ecode14)) {
21569	–	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "14"" of type '" "bool""'");
21570	–	}
21571	–	arg14 = static_cast< bool >(val14);
21572	–	ecode15 = SWIG_AsVal_bool(obj14, &val15);
21573	–	if (!SWIG_IsOK(ecode15)) {
21574	–	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "15"" of type '" "bool""'");
21575	–	}
21576	–	arg15 = static_cast< bool >(val15);
21577	–	{
21578	–	try {
21579	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
21580	–	} catch (const std::exception& e) {
21581	–	SWIG_exception(SWIG_RuntimeError, e.what());
21582	–	}
21583	–	}
21584	–	resultobj = SWIG_From_int(static_cast< int >(result));
21585	–	if (SWIG_IsNewObj(res2)) delete arg2;
21586	–	if (SWIG_IsNewObj(res11)) delete arg11;
21587	–	return resultobj;
21588	–	fail:
21589	–	if (SWIG_IsNewObj(res2)) delete arg2;
21590	–	if (SWIG_IsNewObj(res11)) delete arg11;
21591	–	return NULL;
21592	–	}
21593	–
21594	–
21595	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21596	–	PyObject *resultobj = 0;
21597	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21598	–	std::string *arg2 = 0 ;
21599	–	std::string arg3 ;
21600	–	std::string arg4 ;
21601	–	std::string arg5 ;
21602	–	std::string arg6 ;
21603	–	std::string arg7 ;
21604	–	std::string arg8 ;
21605	–	std::string arg9 ;
21606	–	std::string arg10 ;
21607	–	std::string *arg11 = 0 ;
21608	–	std::string arg12 ;
21609	–	std::string arg13 ;
21610	–	bool arg14 ;
21611	–	int result;
21612	–	void *argp1 = 0 ;
21613	–	int res1 = 0 ;
21614	–	int res2 = SWIG_OLDOBJ ;
21615	–	int res11 = SWIG_OLDOBJ ;
21616	–	bool val14 ;
21617	–	int ecode14 = 0 ;
21618	–	PyObject * obj0 = 0 ;
21619	–	PyObject * obj1 = 0 ;
21620	–	PyObject * obj2 = 0 ;
21621	–	PyObject * obj3 = 0 ;
21622	–	PyObject * obj4 = 0 ;
21623	–	PyObject * obj5 = 0 ;
21624	–	PyObject * obj6 = 0 ;
21625	–	PyObject * obj7 = 0 ;
21626	–	PyObject * obj8 = 0 ;
21627	–	PyObject * obj9 = 0 ;
21628	–	PyObject * obj10 = 0 ;
21629	–	PyObject * obj11 = 0 ;
21630	–	PyObject * obj12 = 0 ;
21631	–	PyObject * obj13 = 0 ;
21632	–
21633	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
21634	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21635	–	if (!SWIG_IsOK(res1)) {
21636	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21637	–	}
21638	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21639	–	{
21640	–	std::string *ptr = (std::string *)0;
21641	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21642	–	if (!SWIG_IsOK(res2)) {
21643	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21644	–	}
21645	–	if (!ptr) {
21646	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21647	–	}
21648	–	arg2 = ptr;
21649	–	}
21650	–	{
21651	–	std::string *ptr = (std::string *)0;
21652	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21653	–	if (!SWIG_IsOK(res) || !ptr) {
21654	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
21655	–	}
21656	–	arg3 = *ptr;
21657	–	if (SWIG_IsNewObj(res)) delete ptr;
21658	–	}
21659	–	{
21660	–	std::string *ptr = (std::string *)0;
21661	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21662	–	if (!SWIG_IsOK(res) || !ptr) {
21663	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
21664	–	}
21665	–	arg4 = *ptr;
21666	–	if (SWIG_IsNewObj(res)) delete ptr;
21667	–	}
21668	–	{
21669	–	std::string *ptr = (std::string *)0;
21670	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
21671	–	if (!SWIG_IsOK(res) || !ptr) {
21672	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
21673	–	}
21674	–	arg5 = *ptr;
21675	–	if (SWIG_IsNewObj(res)) delete ptr;
21676	–	}
21677	–	{
21678	–	std::string *ptr = (std::string *)0;
21679	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
21680	–	if (!SWIG_IsOK(res) || !ptr) {
21681	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
21682	–	}
21683	–	arg6 = *ptr;
21684	–	if (SWIG_IsNewObj(res)) delete ptr;
21685	–	}
21686	–	{
21687	–	std::string *ptr = (std::string *)0;
21688	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
21689	–	if (!SWIG_IsOK(res) || !ptr) {
21690	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
21691	–	}
21692	–	arg7 = *ptr;
21693	–	if (SWIG_IsNewObj(res)) delete ptr;
21694	–	}
21695	–	{
21696	–	std::string *ptr = (std::string *)0;
21697	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
21698	–	if (!SWIG_IsOK(res) || !ptr) {
21699	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
21700	–	}
21701	–	arg8 = *ptr;
21702	–	if (SWIG_IsNewObj(res)) delete ptr;
21703	–	}
21704	–	{
21705	–	std::string *ptr = (std::string *)0;
21706	–	int res = SWIG_AsPtr_std_string(obj8, &ptr);
21707	–	if (!SWIG_IsOK(res) || !ptr) {
21708	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
21709	–	}
21710	–	arg9 = *ptr;
21711	–	if (SWIG_IsNewObj(res)) delete ptr;
21712	–	}
21713	–	{
21714	–	std::string *ptr = (std::string *)0;
21715	–	int res = SWIG_AsPtr_std_string(obj9, &ptr);
21716	–	if (!SWIG_IsOK(res) || !ptr) {
21717	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
21718	–	}
21719	–	arg10 = *ptr;
21720	–	if (SWIG_IsNewObj(res)) delete ptr;
21721	–	}
21722	–	{
21723	–	std::string *ptr = (std::string *)0;
21724	–	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
21725	–	if (!SWIG_IsOK(res11)) {
21726	–	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21727	–	}
21728	–	if (!ptr) {
21729	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21730	–	}
21731	–	arg11 = ptr;
21732	–	}
21733	–	{
21734	–	std::string *ptr = (std::string *)0;
21735	–	int res = SWIG_AsPtr_std_string(obj11, &ptr);
21736	–	if (!SWIG_IsOK(res) || !ptr) {
21737	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "12"" of type '" "std::string""'");
21738	–	}
21739	–	arg12 = *ptr;
21740	–	if (SWIG_IsNewObj(res)) delete ptr;
21741	–	}
21742	–	{
21743	–	std::string *ptr = (std::string *)0;
21744	–	int res = SWIG_AsPtr_std_string(obj12, &ptr);
21745	–	if (!SWIG_IsOK(res) || !ptr) {
21746	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "13"" of type '" "std::string""'");
21747	–	}
21748	–	arg13 = *ptr;
21749	–	if (SWIG_IsNewObj(res)) delete ptr;
21750	–	}
21751	–	ecode14 = SWIG_AsVal_bool(obj13, &val14);
21752	–	if (!SWIG_IsOK(ecode14)) {
21753	–	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "14"" of type '" "bool""'");
21754	–	}
21755	–	arg14 = static_cast< bool >(val14);
21756	–	{
21757	–	try {
21758	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14);
21759	–	} catch (const std::exception& e) {
21760	–	SWIG_exception(SWIG_RuntimeError, e.what());
21761	–	}
21762	–	}
21763	–	resultobj = SWIG_From_int(static_cast< int >(result));
21764	–	if (SWIG_IsNewObj(res2)) delete arg2;
21765	–	if (SWIG_IsNewObj(res11)) delete arg11;
21766	–	return resultobj;
21767	–	fail:
21768	–	if (SWIG_IsNewObj(res2)) delete arg2;
21769	–	if (SWIG_IsNewObj(res11)) delete arg11;
21770	–	return NULL;
21771	–	}
21772	–
21773	–
21774	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21775	–	PyObject *resultobj = 0;
21776	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21777	–	std::string *arg2 = 0 ;
21778	–	std::string arg3 ;
21779	–	std::string arg4 ;
21780	–	std::string arg5 ;
21781	–	std::string arg6 ;
21782	–	std::string arg7 ;
21783	–	std::string arg8 ;
21784	–	std::string arg9 ;
21785	–	std::string arg10 ;
21786	–	std::string *arg11 = 0 ;
21787	–	std::string arg12 ;
21788	–	std::string arg13 ;
21789	–	int result;
21790	–	void *argp1 = 0 ;
21791	–	int res1 = 0 ;
21792	–	int res2 = SWIG_OLDOBJ ;
21793	–	int res11 = SWIG_OLDOBJ ;
21794	–	PyObject * obj0 = 0 ;
21795	–	PyObject * obj1 = 0 ;
21796	–	PyObject * obj2 = 0 ;
21797	–	PyObject * obj3 = 0 ;
21798	–	PyObject * obj4 = 0 ;
21799	–	PyObject * obj5 = 0 ;
21800	–	PyObject * obj6 = 0 ;
21801	–	PyObject * obj7 = 0 ;
21802	–	PyObject * obj8 = 0 ;
21803	–	PyObject * obj9 = 0 ;
21804	–	PyObject * obj10 = 0 ;
21805	–	PyObject * obj11 = 0 ;
21806	–	PyObject * obj12 = 0 ;
21807	–
21808	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
21809	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21810	–	if (!SWIG_IsOK(res1)) {
21811	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21812	–	}
21813	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21814	–	{
21815	–	std::string *ptr = (std::string *)0;
21816	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21817	–	if (!SWIG_IsOK(res2)) {
21818	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21819	–	}
21820	–	if (!ptr) {
21821	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21822	–	}
21823	–	arg2 = ptr;
21824	–	}
21825	–	{
21826	–	std::string *ptr = (std::string *)0;
21827	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21828	–	if (!SWIG_IsOK(res) || !ptr) {
21829	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
21830	–	}
21831	–	arg3 = *ptr;
21832	–	if (SWIG_IsNewObj(res)) delete ptr;
21833	–	}
21834	–	{
21835	–	std::string *ptr = (std::string *)0;
21836	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21837	–	if (!SWIG_IsOK(res) || !ptr) {
21838	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
21839	–	}
21840	–	arg4 = *ptr;
21841	–	if (SWIG_IsNewObj(res)) delete ptr;
21842	–	}
21843	–	{
21844	–	std::string *ptr = (std::string *)0;
21845	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
21846	–	if (!SWIG_IsOK(res) || !ptr) {
21847	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
21848	–	}
21849	–	arg5 = *ptr;
21850	–	if (SWIG_IsNewObj(res)) delete ptr;
21851	–	}
21852	–	{
21853	–	std::string *ptr = (std::string *)0;
21854	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
21855	–	if (!SWIG_IsOK(res) || !ptr) {
21856	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
21857	–	}
21858	–	arg6 = *ptr;
21859	–	if (SWIG_IsNewObj(res)) delete ptr;
21860	–	}
21861	–	{
21862	–	std::string *ptr = (std::string *)0;
21863	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
21864	–	if (!SWIG_IsOK(res) || !ptr) {
21865	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
21866	–	}
21867	–	arg7 = *ptr;
21868	–	if (SWIG_IsNewObj(res)) delete ptr;
21869	–	}
21870	–	{
21871	–	std::string *ptr = (std::string *)0;
21872	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
21873	–	if (!SWIG_IsOK(res) || !ptr) {
21874	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
21875	–	}
21876	–	arg8 = *ptr;
21877	–	if (SWIG_IsNewObj(res)) delete ptr;
21878	–	}
21879	–	{
21880	–	std::string *ptr = (std::string *)0;
21881	–	int res = SWIG_AsPtr_std_string(obj8, &ptr);
21882	–	if (!SWIG_IsOK(res) || !ptr) {
21883	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
21884	–	}
21885	–	arg9 = *ptr;
21886	–	if (SWIG_IsNewObj(res)) delete ptr;
21887	–	}
21888	–	{
21889	–	std::string *ptr = (std::string *)0;
21890	–	int res = SWIG_AsPtr_std_string(obj9, &ptr);
21891	–	if (!SWIG_IsOK(res) || !ptr) {
21892	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
21893	–	}
21894	–	arg10 = *ptr;
21895	–	if (SWIG_IsNewObj(res)) delete ptr;
21896	–	}
21897	–	{
21898	–	std::string *ptr = (std::string *)0;
21899	–	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
21900	–	if (!SWIG_IsOK(res11)) {
21901	–	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21902	–	}
21903	–	if (!ptr) {
21904	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21905	–	}
21906	–	arg11 = ptr;
21907	–	}
21908	–	{
21909	–	std::string *ptr = (std::string *)0;
21910	–	int res = SWIG_AsPtr_std_string(obj11, &ptr);
21911	–	if (!SWIG_IsOK(res) || !ptr) {
21912	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "12"" of type '" "std::string""'");
21913	–	}
21914	–	arg12 = *ptr;
21915	–	if (SWIG_IsNewObj(res)) delete ptr;
21916	–	}
21917	–	{
21918	–	std::string *ptr = (std::string *)0;
21919	–	int res = SWIG_AsPtr_std_string(obj12, &ptr);
21920	–	if (!SWIG_IsOK(res) || !ptr) {
21921	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "13"" of type '" "std::string""'");
21922	–	}
21923	–	arg13 = *ptr;
21924	–	if (SWIG_IsNewObj(res)) delete ptr;
21925	–	}
21926	–	{
21927	–	try {
21928	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13);
21929	–	} catch (const std::exception& e) {
21930	–	SWIG_exception(SWIG_RuntimeError, e.what());
21931	–	}
21932	–	}
21933	–	resultobj = SWIG_From_int(static_cast< int >(result));
21934	–	if (SWIG_IsNewObj(res2)) delete arg2;
21935	–	if (SWIG_IsNewObj(res11)) delete arg11;
21936	–	return resultobj;
21937	–	fail:
21938	–	if (SWIG_IsNewObj(res2)) delete arg2;
21939	–	if (SWIG_IsNewObj(res11)) delete arg11;
21940	–	return NULL;
21941	–	}
21942	–
21943	–
21944	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21945	–	PyObject *resultobj = 0;
21946	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21947	–	std::string *arg2 = 0 ;
21948	–	std::string arg3 ;
21949	–	std::string arg4 ;
21950	–	std::string arg5 ;
21951	–	std::string arg6 ;
21952	–	std::string arg7 ;
21953	–	std::string arg8 ;
21954	–	std::string arg9 ;
21955	–	std::string arg10 ;
21956	–	std::string *arg11 = 0 ;
21957	–	std::string arg12 ;
21958	–	int result;
21959	–	void *argp1 = 0 ;
21960	–	int res1 = 0 ;
21961	–	int res2 = SWIG_OLDOBJ ;
21962	–	int res11 = SWIG_OLDOBJ ;
21963	–	PyObject * obj0 = 0 ;
21964	–	PyObject * obj1 = 0 ;
21965	–	PyObject * obj2 = 0 ;
21966	–	PyObject * obj3 = 0 ;
21967	–	PyObject * obj4 = 0 ;
21968	–	PyObject * obj5 = 0 ;
21969	–	PyObject * obj6 = 0 ;
21970	–	PyObject * obj7 = 0 ;
21971	–	PyObject * obj8 = 0 ;
21972	–	PyObject * obj9 = 0 ;
21973	–	PyObject * obj10 = 0 ;
21974	–	PyObject * obj11 = 0 ;
21975	–
21976	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
21977	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21978	–	if (!SWIG_IsOK(res1)) {
21979	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21980	–	}
21981	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21982	–	{
21983	–	std::string *ptr = (std::string *)0;
21984	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21985	–	if (!SWIG_IsOK(res2)) {
21986	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21987	–	}
21988	–	if (!ptr) {
21989	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21990	–	}
21991	–	arg2 = ptr;
21992	–	}
21993	–	{
21994	–	std::string *ptr = (std::string *)0;
21995	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21996	–	if (!SWIG_IsOK(res) || !ptr) {
21997	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
21998	–	}
21999	–	arg3 = *ptr;
22000	–	if (SWIG_IsNewObj(res)) delete ptr;
22001	–	}
22002	–	{
22003	–	std::string *ptr = (std::string *)0;
22004	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22005	–	if (!SWIG_IsOK(res) || !ptr) {
22006	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22007	–	}
22008	–	arg4 = *ptr;
22009	–	if (SWIG_IsNewObj(res)) delete ptr;
22010	–	}
22011	–	{
22012	–	std::string *ptr = (std::string *)0;
22013	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22014	–	if (!SWIG_IsOK(res) || !ptr) {
22015	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22016	–	}
22017	–	arg5 = *ptr;
22018	–	if (SWIG_IsNewObj(res)) delete ptr;
22019	–	}
22020	–	{
22021	–	std::string *ptr = (std::string *)0;
22022	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22023	–	if (!SWIG_IsOK(res) || !ptr) {
22024	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22025	–	}
22026	–	arg6 = *ptr;
22027	–	if (SWIG_IsNewObj(res)) delete ptr;
22028	–	}
22029	–	{
22030	–	std::string *ptr = (std::string *)0;
22031	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22032	–	if (!SWIG_IsOK(res) || !ptr) {
22033	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22034	–	}
22035	–	arg7 = *ptr;
22036	–	if (SWIG_IsNewObj(res)) delete ptr;
22037	–	}
22038	–	{
22039	–	std::string *ptr = (std::string *)0;
22040	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
22041	–	if (!SWIG_IsOK(res) || !ptr) {
22042	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
22043	–	}
22044	–	arg8 = *ptr;
22045	–	if (SWIG_IsNewObj(res)) delete ptr;
22046	–	}
22047	–	{
22048	–	std::string *ptr = (std::string *)0;
22049	–	int res = SWIG_AsPtr_std_string(obj8, &ptr);
22050	–	if (!SWIG_IsOK(res) || !ptr) {
22051	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
22052	–	}
22053	–	arg9 = *ptr;
22054	–	if (SWIG_IsNewObj(res)) delete ptr;
22055	–	}
22056	–	{
22057	–	std::string *ptr = (std::string *)0;
22058	–	int res = SWIG_AsPtr_std_string(obj9, &ptr);
22059	–	if (!SWIG_IsOK(res) || !ptr) {
22060	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
22061	–	}
22062	–	arg10 = *ptr;
22063	–	if (SWIG_IsNewObj(res)) delete ptr;
22064	–	}
22065	–	{
22066	–	std::string *ptr = (std::string *)0;
22067	–	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
22068	–	if (!SWIG_IsOK(res11)) {
22069	–	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
22070	–	}
22071	–	if (!ptr) {
22072	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
22073	–	}
22074	–	arg11 = ptr;
22075	–	}
22076	–	{
22077	–	std::string *ptr = (std::string *)0;
22078	–	int res = SWIG_AsPtr_std_string(obj11, &ptr);
22079	–	if (!SWIG_IsOK(res) || !ptr) {
22080	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "12"" of type '" "std::string""'");
22081	–	}
22082	–	arg12 = *ptr;
22083	–	if (SWIG_IsNewObj(res)) delete ptr;
22084	–	}
22085	–	{
22086	–	try {
22087	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12);
22088	–	} catch (const std::exception& e) {
22089	–	SWIG_exception(SWIG_RuntimeError, e.what());
22090	–	}
22091	–	}
22092	–	resultobj = SWIG_From_int(static_cast< int >(result));
22093	–	if (SWIG_IsNewObj(res2)) delete arg2;
22094	–	if (SWIG_IsNewObj(res11)) delete arg11;
22095	–	return resultobj;
22096	–	fail:
22097	–	if (SWIG_IsNewObj(res2)) delete arg2;
22098	–	if (SWIG_IsNewObj(res11)) delete arg11;
22099	–	return NULL;
22100	–	}
22101	–
22102	–
22103	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22104	–	PyObject *resultobj = 0;
22105	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22106	–	std::string *arg2 = 0 ;
22107	–	std::string arg3 ;
22108	–	std::string arg4 ;
22109	–	std::string arg5 ;
22110	–	std::string arg6 ;
22111	–	std::string arg7 ;
22112	–	std::string arg8 ;
22113	–	std::string arg9 ;
22114	–	std::string arg10 ;
22115	–	std::string *arg11 = 0 ;
22116	–	int result;
22117	–	void *argp1 = 0 ;
22118	–	int res1 = 0 ;
22119	–	int res2 = SWIG_OLDOBJ ;
22120	–	int res11 = SWIG_OLDOBJ ;
22121	–	PyObject * obj0 = 0 ;
22122	–	PyObject * obj1 = 0 ;
22123	–	PyObject * obj2 = 0 ;
22124	–	PyObject * obj3 = 0 ;
22125	–	PyObject * obj4 = 0 ;
22126	–	PyObject * obj5 = 0 ;
22127	–	PyObject * obj6 = 0 ;
22128	–	PyObject * obj7 = 0 ;
22129	–	PyObject * obj8 = 0 ;
22130	–	PyObject * obj9 = 0 ;
22131	–	PyObject * obj10 = 0 ;
22132	–
22133	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
22134	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22135	–	if (!SWIG_IsOK(res1)) {
22136	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22137	–	}
22138	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22139	–	{
22140	–	std::string *ptr = (std::string *)0;
22141	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22142	–	if (!SWIG_IsOK(res2)) {
22143	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22144	–	}
22145	–	if (!ptr) {
22146	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22147	–	}
22148	–	arg2 = ptr;
22149	–	}
22150	–	{
22151	–	std::string *ptr = (std::string *)0;
22152	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22153	–	if (!SWIG_IsOK(res) || !ptr) {
22154	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22155	–	}
22156	–	arg3 = *ptr;
22157	–	if (SWIG_IsNewObj(res)) delete ptr;
22158	–	}
22159	–	{
22160	–	std::string *ptr = (std::string *)0;
22161	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22162	–	if (!SWIG_IsOK(res) || !ptr) {
22163	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22164	–	}
22165	–	arg4 = *ptr;
22166	–	if (SWIG_IsNewObj(res)) delete ptr;
22167	–	}
22168	–	{
22169	–	std::string *ptr = (std::string *)0;
22170	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22171	–	if (!SWIG_IsOK(res) || !ptr) {
22172	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22173	–	}
22174	–	arg5 = *ptr;
22175	–	if (SWIG_IsNewObj(res)) delete ptr;
22176	–	}
22177	–	{
22178	–	std::string *ptr = (std::string *)0;
22179	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22180	–	if (!SWIG_IsOK(res) || !ptr) {
22181	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22182	–	}
22183	–	arg6 = *ptr;
22184	–	if (SWIG_IsNewObj(res)) delete ptr;
22185	–	}
22186	–	{
22187	–	std::string *ptr = (std::string *)0;
22188	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22189	–	if (!SWIG_IsOK(res) || !ptr) {
22190	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22191	–	}
22192	–	arg7 = *ptr;
22193	–	if (SWIG_IsNewObj(res)) delete ptr;
22194	–	}
22195	–	{
22196	–	std::string *ptr = (std::string *)0;
22197	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
22198	–	if (!SWIG_IsOK(res) || !ptr) {
22199	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
22200	–	}
22201	–	arg8 = *ptr;
22202	–	if (SWIG_IsNewObj(res)) delete ptr;
22203	–	}
22204	–	{
22205	–	std::string *ptr = (std::string *)0;
22206	–	int res = SWIG_AsPtr_std_string(obj8, &ptr);
22207	–	if (!SWIG_IsOK(res) || !ptr) {
22208	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
22209	–	}
22210	–	arg9 = *ptr;
22211	–	if (SWIG_IsNewObj(res)) delete ptr;
22212	–	}
22213	–	{
22214	–	std::string *ptr = (std::string *)0;
22215	–	int res = SWIG_AsPtr_std_string(obj9, &ptr);
22216	–	if (!SWIG_IsOK(res) || !ptr) {
22217	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
22218	–	}
22219	–	arg10 = *ptr;
22220	–	if (SWIG_IsNewObj(res)) delete ptr;
22221	–	}
22222	–	{
22223	–	std::string *ptr = (std::string *)0;
22224	–	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
22225	–	if (!SWIG_IsOK(res11)) {
22226	–	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
22227	–	}
22228	–	if (!ptr) {
22229	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
22230	–	}
22231	–	arg11 = ptr;
22232	–	}
22233	–	{
22234	–	try {
22235	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11);
22236	–	} catch (const std::exception& e) {
22237	–	SWIG_exception(SWIG_RuntimeError, e.what());
22238	–	}
22239	–	}
22240	–	resultobj = SWIG_From_int(static_cast< int >(result));
22241	–	if (SWIG_IsNewObj(res2)) delete arg2;
22242	–	if (SWIG_IsNewObj(res11)) delete arg11;
22243	–	return resultobj;
22244	–	fail:
22245	–	if (SWIG_IsNewObj(res2)) delete arg2;
22246	–	if (SWIG_IsNewObj(res11)) delete arg11;
22247	–	return NULL;
22248	–	}
22249	–
22250	–
22251	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22252	–	PyObject *resultobj = 0;
22253	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22254	–	std::string *arg2 = 0 ;
22255	–	std::string arg3 ;
22256	–	std::string arg4 ;
22257	–	std::string arg5 ;
22258	–	std::string arg6 ;
22259	–	std::string arg7 ;
22260	–	std::string arg8 ;
22261	–	std::string arg9 ;
22262	–	std::string arg10 ;
22263	–	int result;
22264	–	void *argp1 = 0 ;
22265	–	int res1 = 0 ;
22266	–	int res2 = SWIG_OLDOBJ ;
22267	–	PyObject * obj0 = 0 ;
22268	–	PyObject * obj1 = 0 ;
22269	–	PyObject * obj2 = 0 ;
22270	–	PyObject * obj3 = 0 ;
22271	–	PyObject * obj4 = 0 ;
22272	–	PyObject * obj5 = 0 ;
22273	–	PyObject * obj6 = 0 ;
22274	–	PyObject * obj7 = 0 ;
22275	–	PyObject * obj8 = 0 ;
22276	–	PyObject * obj9 = 0 ;
22277	–
22278	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
22279	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22280	–	if (!SWIG_IsOK(res1)) {
22281	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22282	–	}
22283	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22284	–	{
22285	–	std::string *ptr = (std::string *)0;
22286	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22287	–	if (!SWIG_IsOK(res2)) {
22288	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22289	–	}
22290	–	if (!ptr) {
22291	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22292	–	}
22293	–	arg2 = ptr;
22294	–	}
22295	–	{
22296	–	std::string *ptr = (std::string *)0;
22297	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22298	–	if (!SWIG_IsOK(res) || !ptr) {
22299	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22300	–	}
22301	–	arg3 = *ptr;
22302	–	if (SWIG_IsNewObj(res)) delete ptr;
22303	–	}
22304	–	{
22305	–	std::string *ptr = (std::string *)0;
22306	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22307	–	if (!SWIG_IsOK(res) || !ptr) {
22308	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22309	–	}
22310	–	arg4 = *ptr;
22311	–	if (SWIG_IsNewObj(res)) delete ptr;
22312	–	}
22313	–	{
22314	–	std::string *ptr = (std::string *)0;
22315	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22316	–	if (!SWIG_IsOK(res) || !ptr) {
22317	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22318	–	}
22319	–	arg5 = *ptr;
22320	–	if (SWIG_IsNewObj(res)) delete ptr;
22321	–	}
22322	–	{
22323	–	std::string *ptr = (std::string *)0;
22324	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22325	–	if (!SWIG_IsOK(res) || !ptr) {
22326	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22327	–	}
22328	–	arg6 = *ptr;
22329	–	if (SWIG_IsNewObj(res)) delete ptr;
22330	–	}
22331	–	{
22332	–	std::string *ptr = (std::string *)0;
22333	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22334	–	if (!SWIG_IsOK(res) || !ptr) {
22335	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22336	–	}
22337	–	arg7 = *ptr;
22338	–	if (SWIG_IsNewObj(res)) delete ptr;
22339	–	}
22340	–	{
22341	–	std::string *ptr = (std::string *)0;
22342	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
22343	–	if (!SWIG_IsOK(res) || !ptr) {
22344	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
22345	–	}
22346	–	arg8 = *ptr;
22347	–	if (SWIG_IsNewObj(res)) delete ptr;
22348	–	}
22349	–	{
22350	–	std::string *ptr = (std::string *)0;
22351	–	int res = SWIG_AsPtr_std_string(obj8, &ptr);
22352	–	if (!SWIG_IsOK(res) || !ptr) {
22353	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
22354	–	}
22355	–	arg9 = *ptr;
22356	–	if (SWIG_IsNewObj(res)) delete ptr;
22357	–	}
22358	–	{
22359	–	std::string *ptr = (std::string *)0;
22360	–	int res = SWIG_AsPtr_std_string(obj9, &ptr);
22361	–	if (!SWIG_IsOK(res) || !ptr) {
22362	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
22363	–	}
22364	–	arg10 = *ptr;
22365	–	if (SWIG_IsNewObj(res)) delete ptr;
22366	–	}
22367	–	{
22368	–	try {
22369	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
22370	–	} catch (const std::exception& e) {
22371	–	SWIG_exception(SWIG_RuntimeError, e.what());
22372	–	}
22373	–	}
22374	–	resultobj = SWIG_From_int(static_cast< int >(result));
22375	–	if (SWIG_IsNewObj(res2)) delete arg2;
22376	–	return resultobj;
22377	–	fail:
22378	–	if (SWIG_IsNewObj(res2)) delete arg2;
22379	–	return NULL;
22380	–	}
22381	–
22382	–
22383	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22384	–	PyObject *resultobj = 0;
22385	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22386	–	std::string *arg2 = 0 ;
22387	–	std::string arg3 ;
22388	–	std::string arg4 ;
22389	–	std::string arg5 ;
22390	–	std::string arg6 ;
22391	–	std::string arg7 ;
22392	–	std::string arg8 ;
22393	–	std::string arg9 ;
22394	–	int result;
22395	–	void *argp1 = 0 ;
22396	–	int res1 = 0 ;
22397	–	int res2 = SWIG_OLDOBJ ;
22398	–	PyObject * obj0 = 0 ;
22399	–	PyObject * obj1 = 0 ;
22400	–	PyObject * obj2 = 0 ;
22401	–	PyObject * obj3 = 0 ;
22402	–	PyObject * obj4 = 0 ;
22403	–	PyObject * obj5 = 0 ;
22404	–	PyObject * obj6 = 0 ;
22405	–	PyObject * obj7 = 0 ;
22406	–	PyObject * obj8 = 0 ;
22407	–
22408	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
22409	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22410	–	if (!SWIG_IsOK(res1)) {
22411	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22412	–	}
22413	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22414	–	{
22415	–	std::string *ptr = (std::string *)0;
22416	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22417	–	if (!SWIG_IsOK(res2)) {
22418	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22419	–	}
22420	–	if (!ptr) {
22421	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22422	–	}
22423	–	arg2 = ptr;
22424	–	}
22425	–	{
22426	–	std::string *ptr = (std::string *)0;
22427	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22428	–	if (!SWIG_IsOK(res) || !ptr) {
22429	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22430	–	}
22431	–	arg3 = *ptr;
22432	–	if (SWIG_IsNewObj(res)) delete ptr;
22433	–	}
22434	–	{
22435	–	std::string *ptr = (std::string *)0;
22436	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22437	–	if (!SWIG_IsOK(res) || !ptr) {
22438	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22439	–	}
22440	–	arg4 = *ptr;
22441	–	if (SWIG_IsNewObj(res)) delete ptr;
22442	–	}
22443	–	{
22444	–	std::string *ptr = (std::string *)0;
22445	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22446	–	if (!SWIG_IsOK(res) || !ptr) {
22447	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22448	–	}
22449	–	arg5 = *ptr;
22450	–	if (SWIG_IsNewObj(res)) delete ptr;
22451	–	}
22452	–	{
22453	–	std::string *ptr = (std::string *)0;
22454	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22455	–	if (!SWIG_IsOK(res) || !ptr) {
22456	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22457	–	}
22458	–	arg6 = *ptr;
22459	–	if (SWIG_IsNewObj(res)) delete ptr;
22460	–	}
22461	–	{
22462	–	std::string *ptr = (std::string *)0;
22463	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22464	–	if (!SWIG_IsOK(res) || !ptr) {
22465	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22466	–	}
22467	–	arg7 = *ptr;
22468	–	if (SWIG_IsNewObj(res)) delete ptr;
22469	–	}
22470	–	{
22471	–	std::string *ptr = (std::string *)0;
22472	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
22473	–	if (!SWIG_IsOK(res) || !ptr) {
22474	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
22475	–	}
22476	–	arg8 = *ptr;
22477	–	if (SWIG_IsNewObj(res)) delete ptr;
22478	–	}
22479	–	{
22480	–	std::string *ptr = (std::string *)0;
22481	–	int res = SWIG_AsPtr_std_string(obj8, &ptr);
22482	–	if (!SWIG_IsOK(res) || !ptr) {
22483	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
22484	–	}
22485	–	arg9 = *ptr;
22486	–	if (SWIG_IsNewObj(res)) delete ptr;
22487	–	}
22488	–	{
22489	–	try {
22490	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
22491	–	} catch (const std::exception& e) {
22492	–	SWIG_exception(SWIG_RuntimeError, e.what());
22493	–	}
22494	–	}
22495	–	resultobj = SWIG_From_int(static_cast< int >(result));
22496	–	if (SWIG_IsNewObj(res2)) delete arg2;
22497	–	return resultobj;
22498	–	fail:
22499	–	if (SWIG_IsNewObj(res2)) delete arg2;
22500	–	return NULL;
22501	–	}
22502	–
22503	–
22504	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22505	–	PyObject *resultobj = 0;
22506	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22507	–	std::string *arg2 = 0 ;
22508	–	std::string arg3 ;
22509	–	std::string arg4 ;
22510	–	std::string arg5 ;
22511	–	std::string arg6 ;
22512	–	std::string arg7 ;
22513	–	std::string arg8 ;
22514	–	int result;
22515	–	void *argp1 = 0 ;
22516	–	int res1 = 0 ;
22517	–	int res2 = SWIG_OLDOBJ ;
22518	–	PyObject * obj0 = 0 ;
22519	–	PyObject * obj1 = 0 ;
22520	–	PyObject * obj2 = 0 ;
22521	–	PyObject * obj3 = 0 ;
22522	–	PyObject * obj4 = 0 ;
22523	–	PyObject * obj5 = 0 ;
22524	–	PyObject * obj6 = 0 ;
22525	–	PyObject * obj7 = 0 ;
22526	–
22527	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
22528	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22529	–	if (!SWIG_IsOK(res1)) {
22530	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22531	–	}
22532	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22533	–	{
22534	–	std::string *ptr = (std::string *)0;
22535	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22536	–	if (!SWIG_IsOK(res2)) {
22537	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22538	–	}
22539	–	if (!ptr) {
22540	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22541	–	}
22542	–	arg2 = ptr;
22543	–	}
22544	–	{
22545	–	std::string *ptr = (std::string *)0;
22546	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22547	–	if (!SWIG_IsOK(res) || !ptr) {
22548	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22549	–	}
22550	–	arg3 = *ptr;
22551	–	if (SWIG_IsNewObj(res)) delete ptr;
22552	–	}
22553	–	{
22554	–	std::string *ptr = (std::string *)0;
22555	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22556	–	if (!SWIG_IsOK(res) || !ptr) {
22557	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22558	–	}
22559	–	arg4 = *ptr;
22560	–	if (SWIG_IsNewObj(res)) delete ptr;
22561	–	}
22562	–	{
22563	–	std::string *ptr = (std::string *)0;
22564	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22565	–	if (!SWIG_IsOK(res) || !ptr) {
22566	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22567	–	}
22568	–	arg5 = *ptr;
22569	–	if (SWIG_IsNewObj(res)) delete ptr;
22570	–	}
22571	–	{
22572	–	std::string *ptr = (std::string *)0;
22573	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22574	–	if (!SWIG_IsOK(res) || !ptr) {
22575	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22576	–	}
22577	–	arg6 = *ptr;
22578	–	if (SWIG_IsNewObj(res)) delete ptr;
22579	–	}
22580	–	{
22581	–	std::string *ptr = (std::string *)0;
22582	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22583	–	if (!SWIG_IsOK(res) || !ptr) {
22584	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22585	–	}
22586	–	arg7 = *ptr;
22587	–	if (SWIG_IsNewObj(res)) delete ptr;
22588	–	}
22589	–	{
22590	–	std::string *ptr = (std::string *)0;
22591	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
22592	–	if (!SWIG_IsOK(res) || !ptr) {
22593	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
22594	–	}
22595	–	arg8 = *ptr;
22596	–	if (SWIG_IsNewObj(res)) delete ptr;
22597	–	}
22598	–	{
22599	–	try {
22600	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
22601	–	} catch (const std::exception& e) {
22602	–	SWIG_exception(SWIG_RuntimeError, e.what());
22603	–	}
22604	–	}
22605	–	resultobj = SWIG_From_int(static_cast< int >(result));
22606	–	if (SWIG_IsNewObj(res2)) delete arg2;
22607	–	return resultobj;
22608	–	fail:
22609	–	if (SWIG_IsNewObj(res2)) delete arg2;
22610	–	return NULL;
22611	–	}
22612	–
22613	–
22614	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22615	–	PyObject *resultobj = 0;
22616	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22617	–	std::string *arg2 = 0 ;
22618	–	std::string arg3 ;
22619	–	std::string arg4 ;
22620	–	std::string arg5 ;
22621	–	std::string arg6 ;
22622	–	std::string arg7 ;
22623	–	int result;
22624	–	void *argp1 = 0 ;
22625	–	int res1 = 0 ;
22626	–	int res2 = SWIG_OLDOBJ ;
22627	–	PyObject * obj0 = 0 ;
22628	–	PyObject * obj1 = 0 ;
22629	–	PyObject * obj2 = 0 ;
22630	–	PyObject * obj3 = 0 ;
22631	–	PyObject * obj4 = 0 ;
22632	–	PyObject * obj5 = 0 ;
22633	–	PyObject * obj6 = 0 ;
22634	–
22635	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22636	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22637	–	if (!SWIG_IsOK(res1)) {
22638	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22639	–	}
22640	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22641	–	{
22642	–	std::string *ptr = (std::string *)0;
22643	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22644	–	if (!SWIG_IsOK(res2)) {
22645	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22646	–	}
22647	–	if (!ptr) {
22648	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22649	–	}
22650	–	arg2 = ptr;
22651	–	}
22652	–	{
22653	–	std::string *ptr = (std::string *)0;
22654	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22655	–	if (!SWIG_IsOK(res) || !ptr) {
22656	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22657	–	}
22658	–	arg3 = *ptr;
22659	–	if (SWIG_IsNewObj(res)) delete ptr;
22660	–	}
22661	–	{
22662	–	std::string *ptr = (std::string *)0;
22663	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22664	–	if (!SWIG_IsOK(res) || !ptr) {
22665	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22666	–	}
22667	–	arg4 = *ptr;
22668	–	if (SWIG_IsNewObj(res)) delete ptr;
22669	–	}
22670	–	{
22671	–	std::string *ptr = (std::string *)0;
22672	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22673	–	if (!SWIG_IsOK(res) || !ptr) {
22674	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22675	–	}
22676	–	arg5 = *ptr;
22677	–	if (SWIG_IsNewObj(res)) delete ptr;
22678	–	}
22679	–	{
22680	–	std::string *ptr = (std::string *)0;
22681	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22682	–	if (!SWIG_IsOK(res) || !ptr) {
22683	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22684	–	}
22685	–	arg6 = *ptr;
22686	–	if (SWIG_IsNewObj(res)) delete ptr;
22687	–	}
22688	–	{
22689	–	std::string *ptr = (std::string *)0;
22690	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22691	–	if (!SWIG_IsOK(res) || !ptr) {
22692	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22693	–	}
22694	–	arg7 = *ptr;
22695	–	if (SWIG_IsNewObj(res)) delete ptr;
22696	–	}
22697	–	{
22698	–	try {
22699	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
22700	–	} catch (const std::exception& e) {
22701	–	SWIG_exception(SWIG_RuntimeError, e.what());
22702	–	}
22703	–	}
22704	–	resultobj = SWIG_From_int(static_cast< int >(result));
22705	–	if (SWIG_IsNewObj(res2)) delete arg2;
22706	–	return resultobj;
22707	–	fail:
22708	–	if (SWIG_IsNewObj(res2)) delete arg2;
22709	–	return NULL;
22710	–	}
22711	–
22712	–
22713	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22714	–	PyObject *resultobj = 0;
22715	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22716	–	std::string *arg2 = 0 ;
22717	–	std::string arg3 ;
22718	–	std::string arg4 ;
22719	–	std::string arg5 ;
22720	–	std::string arg6 ;
22721	–	int result;
22722	–	void *argp1 = 0 ;
22723	–	int res1 = 0 ;
22724	–	int res2 = SWIG_OLDOBJ ;
22725	–	PyObject * obj0 = 0 ;
22726	–	PyObject * obj1 = 0 ;
22727	–	PyObject * obj2 = 0 ;
22728	–	PyObject * obj3 = 0 ;
22729	–	PyObject * obj4 = 0 ;
22730	–	PyObject * obj5 = 0 ;
22731	–
22732	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
22733	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22734	–	if (!SWIG_IsOK(res1)) {
22735	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22736	–	}
22737	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22738	–	{
22739	–	std::string *ptr = (std::string *)0;
22740	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22741	–	if (!SWIG_IsOK(res2)) {
22742	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22743	–	}
22744	–	if (!ptr) {
22745	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22746	–	}
22747	–	arg2 = ptr;
22748	–	}
22749	–	{
22750	–	std::string *ptr = (std::string *)0;
22751	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22752	–	if (!SWIG_IsOK(res) || !ptr) {
22753	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22754	–	}
22755	–	arg3 = *ptr;
22756	–	if (SWIG_IsNewObj(res)) delete ptr;
22757	–	}
22758	–	{
22759	–	std::string *ptr = (std::string *)0;
22760	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22761	–	if (!SWIG_IsOK(res) || !ptr) {
22762	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22763	–	}
22764	–	arg4 = *ptr;
22765	–	if (SWIG_IsNewObj(res)) delete ptr;
22766	–	}
22767	–	{
22768	–	std::string *ptr = (std::string *)0;
22769	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22770	–	if (!SWIG_IsOK(res) || !ptr) {
22771	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22772	–	}
22773	–	arg5 = *ptr;
22774	–	if (SWIG_IsNewObj(res)) delete ptr;
22775	–	}
22776	–	{
22777	–	std::string *ptr = (std::string *)0;
22778	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22779	–	if (!SWIG_IsOK(res) || !ptr) {
22780	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22781	–	}
22782	–	arg6 = *ptr;
22783	–	if (SWIG_IsNewObj(res)) delete ptr;
22784	–	}
22785	–	{
22786	–	try {
22787	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6);
22788	–	} catch (const std::exception& e) {
22789	–	SWIG_exception(SWIG_RuntimeError, e.what());
22790	–	}
22791	–	}
22792	–	resultobj = SWIG_From_int(static_cast< int >(result));
22793	–	if (SWIG_IsNewObj(res2)) delete arg2;
22794	–	return resultobj;
22795	–	fail:
22796	–	if (SWIG_IsNewObj(res2)) delete arg2;
22797	–	return NULL;
22798	–	}
22799	–
22800	–
22801	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22802	–	PyObject *resultobj = 0;
22803	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22804	–	std::string *arg2 = 0 ;
22805	–	std::string arg3 ;
22806	–	std::string arg4 ;
22807	–	std::string arg5 ;
22808	–	int result;
22809	–	void *argp1 = 0 ;
22810	–	int res1 = 0 ;
22811	–	int res2 = SWIG_OLDOBJ ;
22812	–	PyObject * obj0 = 0 ;
22813	–	PyObject * obj1 = 0 ;
22814	–	PyObject * obj2 = 0 ;
22815	–	PyObject * obj3 = 0 ;
22816	–	PyObject * obj4 = 0 ;
22817	–
22818	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22819	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22820	–	if (!SWIG_IsOK(res1)) {
22821	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22822	–	}
22823	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22824	–	{
22825	–	std::string *ptr = (std::string *)0;
22826	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22827	–	if (!SWIG_IsOK(res2)) {
22828	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22829	–	}
22830	–	if (!ptr) {
22831	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22832	–	}
22833	–	arg2 = ptr;
22834	–	}
22835	–	{
22836	–	std::string *ptr = (std::string *)0;
22837	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22838	–	if (!SWIG_IsOK(res) || !ptr) {
22839	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22840	–	}
22841	–	arg3 = *ptr;
22842	–	if (SWIG_IsNewObj(res)) delete ptr;
22843	–	}
22844	–	{
22845	–	std::string *ptr = (std::string *)0;
22846	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22847	–	if (!SWIG_IsOK(res) || !ptr) {
22848	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22849	–	}
22850	–	arg4 = *ptr;
22851	–	if (SWIG_IsNewObj(res)) delete ptr;
22852	–	}
22853	–	{
22854	–	std::string *ptr = (std::string *)0;
22855	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22856	–	if (!SWIG_IsOK(res) || !ptr) {
22857	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22858	–	}
22859	–	arg5 = *ptr;
22860	–	if (SWIG_IsNewObj(res)) delete ptr;
22861	–	}
22862	–	{
22863	–	try {
22864	–	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5);
22865	–	} catch (const std::exception& e) {
22866	–	SWIG_exception(SWIG_RuntimeError, e.what());
22867	–	}
22868	–	}
22869	–	resultobj = SWIG_From_int(static_cast< int >(result));
22870	–	if (SWIG_IsNewObj(res2)) delete arg2;
22871	–	return resultobj;
22872	–	fail:
22873	–	if (SWIG_IsNewObj(res2)) delete arg2;
22874	–	return NULL;
22875	–	}
22876	–
22877	–
22878	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22879	–	PyObject *resultobj = 0;
22880	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22881	–	std::string *arg2 = 0 ;
22882	–	std::string arg3 ;
22883	–	std::string arg4 ;
22884	–	int result;
22885	–	void *argp1 = 0 ;
22886	–	int res1 = 0 ;
22887	–	int res2 = SWIG_OLDOBJ ;
22888	–	PyObject * obj0 = 0 ;
22889	–	PyObject * obj1 = 0 ;
22890	–	PyObject * obj2 = 0 ;
22891	–	PyObject * obj3 = 0 ;
22892	–
22893	–	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22894	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22895	–	if (!SWIG_IsOK(res1)) {
22896	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22897	–	}
22898	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22899	–	{
22900	–	std::string *ptr = (std::string *)0;
22901	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22902	–	if (!SWIG_IsOK(res2)) {
22903	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22904	–	}
22905	–	if (!ptr) {
22906	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
5849		}
5850	<	arg2 = ptr;
5851	<	}
5852	<	{
22911	<	std::string *ptr = (std::string *)0;
22912	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22913	<	if (!SWIG_IsOK(res) || !ptr) {
22914	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
5850	>	if (obj5) {
5851	>	arg6 = PyInt_AsLong(obj5) ? true : false;
5852	>	if (PyErr_Occurred()) SWIG_fail;
5853		}
5854	<	arg3 = *ptr;
5855	<	if (SWIG_IsNewObj(res)) delete ptr;
5856	<	}
22919	<	{
22920	<	std::string *ptr = (std::string *)0;
22921	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22922	<	if (!SWIG_IsOK(res) || !ptr) {
22923	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22924	<	}
22925	<	arg4 = *ptr;
22926	<	if (SWIG_IsNewObj(res)) delete ptr;
22927	<	}
22928	<	{
22929	<	try {
22930	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4);
22931	<	} catch (const std::exception& e) {
22932	<	SWIG_exception(SWIG_RuntimeError, e.what());
5854	>	if (obj6) {
5855	>	arg7 = PyInt_AsLong(obj6) ? true : false;
5856	>	if (PyErr_Occurred()) SWIG_fail;
5857		}
5858	<	}
5859	<	resultobj = SWIG_From_int(static_cast< int >(result));
5860	<	if (SWIG_IsNewObj(res2)) delete arg2;
5861	<	return resultobj;
5862	<	fail:
5863	<	if (SWIG_IsNewObj(res2)) delete arg2;
5864	<	return NULL;
5865	<	}
5866	<
5867	<
5868	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22945	<	PyObject *resultobj = 0;
22946	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22947	<	std::string *arg2 = 0 ;
22948	<	std::string arg3 ;
22949	<	int result;
22950	<	void *argp1 = 0 ;
22951	<	int res1 = 0 ;
22952	<	int res2 = SWIG_OLDOBJ ;
22953	<	PyObject * obj0 = 0 ;
22954	<	PyObject * obj1 = 0 ;
22955	<	PyObject * obj2 = 0 ;
22956	<
22957	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2)) SWIG_fail;
22958	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22959	<	if (!SWIG_IsOK(res1)) {
22960	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22961	<	}
22962	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22963	<	{
22964	<	std::string *ptr = (std::string *)0;
22965	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22966	<	if (!SWIG_IsOK(res2)) {
22967	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22968	<	}
22969	<	if (!ptr) {
22970	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22971	<	}
22972	<	arg2 = ptr;
22973	<	}
22974	<	{
22975	<	std::string *ptr = (std::string *)0;
22976	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22977	<	if (!SWIG_IsOK(res) || !ptr) {
22978	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22979	<	}
22980	<	arg3 = *ptr;
22981	<	if (SWIG_IsNewObj(res)) delete ptr;
22982	<	}
22983	<	{
22984	<	try {
22985	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3);
22986	<	} catch (const std::exception& e) {
22987	<	SWIG_exception(SWIG_RuntimeError, e.what());
22988	<	}
22989	<	}
22990	<	resultobj = SWIG_From_int(static_cast< int >(result));
22991	<	if (SWIG_IsNewObj(res2)) delete arg2;
22992	<	return resultobj;
22993	<	fail:
22994	<	if (SWIG_IsNewObj(res2)) delete arg2;
22995	<	return NULL;
22996	<	}
22997	<
22998	<
22999	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23000	<	PyObject *resultobj = 0;
23001	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
23002	<	std::string *arg2 = 0 ;
23003	<	int result;
23004	<	void *argp1 = 0 ;
23005	<	int res1 = 0 ;
23006	<	int res2 = SWIG_OLDOBJ ;
23007	<	PyObject * obj0 = 0 ;
23008	<	PyObject * obj1 = 0 ;
23009	<
23010	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerScheduler",&obj0,&obj1)) SWIG_fail;
23011	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
23012	<	if (!SWIG_IsOK(res1)) {
23013	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
23014	<	}
23015	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
23016	<	{
23017	<	std::string *ptr = (std::string *)0;
23018	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
23019	<	if (!SWIG_IsOK(res2)) {
23020	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
23021	<	}
23022	<	if (!ptr) {
23023	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
23024	<	}
23025	<	arg2 = ptr;
23026	<	}
23027	<	{
23028	<	try {
23029	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2);
23030	<	} catch (const std::exception& e) {
23031	<	SWIG_exception(SWIG_RuntimeError, e.what());
5858	>	{
5859	>	try {
5860	>	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5861	>
5862	>	}catch (const BossSchedFailure & e) {
5863	>	PyErr_SetString ( SchedulerError, e.what() );
5864	>	return NULL;
5865	>	}catch (const std::exception& e) {
5866	>	PyErr_SetString ( BossError, e.what() );
5867	>	return NULL;
5868	>	}
5869		}
5870	<	}
5871	<	resultobj = SWIG_From_int(static_cast< int >(result));
5872	<	if (SWIG_IsNewObj(res2)) delete arg2;
5873	<	return resultobj;
23037	<	fail:
23038	<	if (SWIG_IsNewObj(res2)) delete arg2;
23039	<	return NULL;
5870	>	resultobj = PyInt_FromLong((long)result);
5871	>	return resultobj;
5872	>	fail:
5873	>	return NULL;
5874		}
5875
5876
5877	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
5878	<	int argc;
5879	<	PyObject *argv[16];
5880	<	int ii;
5881	<
5882	<	if (!PyTuple_Check(args)) SWIG_fail;
5883	<	argc = PyObject_Length(args);
5884	<	for (ii = 0; (ii < argc) && (ii < 15); ii++) {
5885	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5886	<	}
5887	<	if (argc == 2) {
5888	<	int _v;
5889	<	void *vptr = 0;
5890	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5891	<	_v = SWIG_CheckState(res);
5892	<	if (_v) {
5893	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5894	<	_v = SWIG_CheckState(res);
5895	<	if (_v) {
5896	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_13(self, args);
5897	<	}
5898	<	}
5899	<	}
5900	<	if (argc == 3) {
5901	<	int _v;
5902	<	void *vptr = 0;
5903	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5904	<	_v = SWIG_CheckState(res);
5905	<	if (_v) {
5906	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5907	<	_v = SWIG_CheckState(res);
5908	<	if (_v) {
5909	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
5910	<	_v = SWIG_CheckState(res);
5911	<	if (_v) {
5912	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_12(self, args);
5913	<	}
5914	<	}
5915	<	}
5916	<	}
5917	<	if (argc == 4) {
5918	<	int _v;
5919	<	void *vptr = 0;
5920	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5921	<	_v = SWIG_CheckState(res);
5922	<	if (_v) {
5923	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5924	<	_v = SWIG_CheckState(res);
5925	<	if (_v) {
23092	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23093	<	_v = SWIG_CheckState(res);
23094	<	if (_v) {
23095	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23096	<	_v = SWIG_CheckState(res);
23097	<	if (_v) {
23098	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_11(self, args);
23099	<	}
5877	>	static PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
5878	>	PyObject *resultobj;
5879	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5880	>	std::string *arg2 = 0 ;
5881	>	std::string arg3 = (std::string) "NULL" ;
5882	>	std::string arg4 = (std::string) "NULL" ;
5883	>	std::string arg5 = (std::string) "NULL" ;
5884	>	std::string arg6 = (std::string) "NULL" ;
5885	>	std::string arg7 = (std::string) "" ;
5886	>	std::string arg8 = (std::string) "" ;
5887	>	std::string arg9 = (std::string) "" ;
5888	>	std::string arg10 = (std::string) "" ;
5889	>	std::string const &arg11_defvalue = "" ;
5890	>	std::string *arg11 = (std::string *) &arg11_defvalue ;
5891	>	std::string arg12 = (std::string) "" ;
5892	>	std::string arg13 = (std::string) "" ;
5893	>	bool arg14 = (bool) false ;
5894	>	bool arg15 = (bool) false ;
5895	>	bool arg16 = (bool) false ;
5896	>	bool arg17 = (bool) false ;
5897	>	int result;
5898	>	std::string temp2 ;
5899	>	std::string temp11 ;
5900	>	PyObject * obj0 = 0 ;
5901	>	PyObject * obj1 = 0 ;
5902	>	PyObject * obj2 = 0 ;
5903	>	PyObject * obj3 = 0 ;
5904	>	PyObject * obj4 = 0 ;
5905	>	PyObject * obj5 = 0 ;
5906	>	PyObject * obj6 = 0 ;
5907	>	PyObject * obj7 = 0 ;
5908	>	PyObject * obj8 = 0 ;
5909	>	PyObject * obj9 = 0 ;
5910	>	PyObject * obj10 = 0 ;
5911	>	PyObject * obj11 = 0 ;
5912	>	PyObject * obj12 = 0 ;
5913	>	PyObject * obj13 = 0 ;
5914	>	PyObject * obj14 = 0 ;
5915	>	PyObject * obj15 = 0 ;
5916	>	PyObject * obj16 = 0 ;
5917	>
5918	>	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;
5919	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5920	>	{
5921	>	if (PyString_Check(obj1)) {
5922	>	temp2 = std::string(PyString_AsString(obj1));
5923	>	arg2 = &temp2;
5924	>	}else {
5925	>	SWIG_exception(SWIG_TypeError, "string expected");
5926		}
23101	–	}
5927		}
5928	<	}
5929	<	if (argc == 5) {
5930	<	int _v;
5931	<	void *vptr = 0;
5932	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5933	<	_v = SWIG_CheckState(res);
23109	<	if (_v) {
23110	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23111	<	_v = SWIG_CheckState(res);
23112	<	if (_v) {
23113	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23114	<	_v = SWIG_CheckState(res);
23115	<	if (_v) {
23116	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23117	<	_v = SWIG_CheckState(res);
23118	<	if (_v) {
23119	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23120	<	_v = SWIG_CheckState(res);
23121	<	if (_v) {
23122	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_10(self, args);
23123	<	}
23124	<	}
5928	>	if (obj2) {
5929	>	{
5930	>	if (PyString_Check(obj2))
5931	>	arg3 = std::string(PyString_AsString(obj2));
5932	>	else
5933	>	SWIG_exception(SWIG_TypeError, "string expected");
5934		}
23126	–	}
5935		}
5936	<	}
5937	<	if (argc == 6) {
5938	<	int _v;
5939	<	void *vptr = 0;
5940	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5941	<	_v = SWIG_CheckState(res);
23134	<	if (_v) {
23135	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23136	<	_v = SWIG_CheckState(res);
23137	<	if (_v) {
23138	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23139	<	_v = SWIG_CheckState(res);
23140	<	if (_v) {
23141	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23142	<	_v = SWIG_CheckState(res);
23143	<	if (_v) {
23144	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23145	<	_v = SWIG_CheckState(res);
23146	<	if (_v) {
23147	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
23148	<	_v = SWIG_CheckState(res);
23149	<	if (_v) {
23150	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_9(self, args);
23151	<	}
23152	<	}
23153	<	}
5936	>	if (obj3) {
5937	>	{
5938	>	if (PyString_Check(obj3))
5939	>	arg4 = std::string(PyString_AsString(obj3));
5940	>	else
5941	>	SWIG_exception(SWIG_TypeError, "string expected");
5942		}
23155	–	}
5943		}
5944	<	}
5945	<	if (argc == 7) {
5946	<	int _v;
5947	<	void *vptr = 0;
5948	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5949	<	_v = SWIG_CheckState(res);
23163	<	if (_v) {
23164	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23165	<	_v = SWIG_CheckState(res);
23166	<	if (_v) {
23167	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23168	<	_v = SWIG_CheckState(res);
23169	<	if (_v) {
23170	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23171	<	_v = SWIG_CheckState(res);
23172	<	if (_v) {
23173	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23174	<	_v = SWIG_CheckState(res);
23175	<	if (_v) {
23176	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
23177	<	_v = SWIG_CheckState(res);
23178	<	if (_v) {
23179	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
23180	<	_v = SWIG_CheckState(res);
23181	<	if (_v) {
23182	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_8(self, args);
23183	<	}
23184	<	}
23185	<	}
23186	<	}
5944	>	if (obj4) {
5945	>	{
5946	>	if (PyString_Check(obj4))
5947	>	arg5 = std::string(PyString_AsString(obj4));
5948	>	else
5949	>	SWIG_exception(SWIG_TypeError, "string expected");
5950		}
23188	–	}
5951		}
5952	<	}
5953	<	if (argc == 8) {
5954	<	int _v;
5955	<	void *vptr = 0;
5956	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5957	<	_v = SWIG_CheckState(res);
23196	<	if (_v) {
23197	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23198	<	_v = SWIG_CheckState(res);
23199	<	if (_v) {
23200	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23201	<	_v = SWIG_CheckState(res);
23202	<	if (_v) {
23203	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23204	<	_v = SWIG_CheckState(res);
23205	<	if (_v) {
23206	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23207	<	_v = SWIG_CheckState(res);
23208	<	if (_v) {
23209	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
23210	<	_v = SWIG_CheckState(res);
23211	<	if (_v) {
23212	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
23213	<	_v = SWIG_CheckState(res);
23214	<	if (_v) {
23215	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
23216	<	_v = SWIG_CheckState(res);
23217	<	if (_v) {
23218	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_7(self, args);
23219	<	}
23220	<	}
23221	<	}
23222	<	}
23223	<	}
5952	>	if (obj5) {
5953	>	{
5954	>	if (PyString_Check(obj5))
5955	>	arg6 = std::string(PyString_AsString(obj5));
5956	>	else
5957	>	SWIG_exception(SWIG_TypeError, "string expected");
5958		}
23225	–	}
5959		}
5960	<	}
5961	<	if (argc == 9) {
5962	<	int _v;
5963	<	void *vptr = 0;
5964	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5965	<	_v = SWIG_CheckState(res);
23233	<	if (_v) {
23234	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23235	<	_v = SWIG_CheckState(res);
23236	<	if (_v) {
23237	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23238	<	_v = SWIG_CheckState(res);
23239	<	if (_v) {
23240	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23241	<	_v = SWIG_CheckState(res);
23242	<	if (_v) {
23243	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23244	<	_v = SWIG_CheckState(res);
23245	<	if (_v) {
23246	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
23247	<	_v = SWIG_CheckState(res);
23248	<	if (_v) {
23249	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
23250	<	_v = SWIG_CheckState(res);
23251	<	if (_v) {
23252	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
23253	<	_v = SWIG_CheckState(res);
23254	<	if (_v) {
23255	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
23256	<	_v = SWIG_CheckState(res);
23257	<	if (_v) {
23258	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_6(self, args);
23259	<	}
23260	<	}
23261	<	}
23262	<	}
23263	<	}
23264	<	}
5960	>	if (obj6) {
5961	>	{
5962	>	if (PyString_Check(obj6))
5963	>	arg7 = std::string(PyString_AsString(obj6));
5964	>	else
5965	>	SWIG_exception(SWIG_TypeError, "string expected");
5966		}
23266	–	}
5967		}
5968	<	}
5969	<	if (argc == 10) {
5970	<	int _v;
5971	<	void *vptr = 0;
5972	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5973	<	_v = SWIG_CheckState(res);
23274	<	if (_v) {
23275	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23276	<	_v = SWIG_CheckState(res);
23277	<	if (_v) {
23278	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23279	<	_v = SWIG_CheckState(res);
23280	<	if (_v) {
23281	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23282	<	_v = SWIG_CheckState(res);
23283	<	if (_v) {
23284	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23285	<	_v = SWIG_CheckState(res);
23286	<	if (_v) {
23287	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
23288	<	_v = SWIG_CheckState(res);
23289	<	if (_v) {
23290	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
23291	<	_v = SWIG_CheckState(res);
23292	<	if (_v) {
23293	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
23294	<	_v = SWIG_CheckState(res);
23295	<	if (_v) {
23296	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
23297	<	_v = SWIG_CheckState(res);
23298	<	if (_v) {
23299	<	int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
23300	<	_v = SWIG_CheckState(res);
23301	<	if (_v) {
23302	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_5(self, args);
23303	<	}
23304	<	}
23305	<	}
23306	<	}
23307	<	}
23308	<	}
23309	<	}
5968	>	if (obj7) {
5969	>	{
5970	>	if (PyString_Check(obj7))
5971	>	arg8 = std::string(PyString_AsString(obj7));
5972	>	else
5973	>	SWIG_exception(SWIG_TypeError, "string expected");
5974		}
23311	–	}
5975		}
5976	<	}
5977	<	if (argc == 11) {
5978	<	int _v;
5979	<	void *vptr = 0;
5980	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5981	<	_v = SWIG_CheckState(res);
23319	<	if (_v) {
23320	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23321	<	_v = SWIG_CheckState(res);
23322	<	if (_v) {
23323	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23324	<	_v = SWIG_CheckState(res);
23325	<	if (_v) {
23326	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23327	<	_v = SWIG_CheckState(res);
23328	<	if (_v) {
23329	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23330	<	_v = SWIG_CheckState(res);
23331	<	if (_v) {
23332	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
23333	<	_v = SWIG_CheckState(res);
23334	<	if (_v) {
23335	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
23336	<	_v = SWIG_CheckState(res);
23337	<	if (_v) {
23338	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
23339	<	_v = SWIG_CheckState(res);
23340	<	if (_v) {
23341	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
23342	<	_v = SWIG_CheckState(res);
23343	<	if (_v) {
23344	<	int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
23345	<	_v = SWIG_CheckState(res);
23346	<	if (_v) {
23347	<	int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
23348	<	_v = SWIG_CheckState(res);
23349	<	if (_v) {
23350	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_4(self, args);
23351	<	}
23352	<	}
23353	<	}
23354	<	}
23355	<	}
23356	<	}
23357	<	}
23358	<	}
5976	>	if (obj8) {
5977	>	{
5978	>	if (PyString_Check(obj8))
5979	>	arg9 = std::string(PyString_AsString(obj8));
5980	>	else
5981	>	SWIG_exception(SWIG_TypeError, "string expected");
5982		}
23360	–	}
5983		}
5984	<	}
5985	<	if (argc == 12) {
5986	<	int _v;
5987	<	void *vptr = 0;
5988	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5989	<	_v = SWIG_CheckState(res);
23368	<	if (_v) {
23369	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23370	<	_v = SWIG_CheckState(res);
23371	<	if (_v) {
23372	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23373	<	_v = SWIG_CheckState(res);
23374	<	if (_v) {
23375	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23376	<	_v = SWIG_CheckState(res);
23377	<	if (_v) {
23378	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23379	<	_v = SWIG_CheckState(res);
23380	<	if (_v) {
23381	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
23382	<	_v = SWIG_CheckState(res);
23383	<	if (_v) {
23384	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
23385	<	_v = SWIG_CheckState(res);
23386	<	if (_v) {
23387	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
23388	<	_v = SWIG_CheckState(res);
23389	<	if (_v) {
23390	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
23391	<	_v = SWIG_CheckState(res);
23392	<	if (_v) {
23393	<	int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
23394	<	_v = SWIG_CheckState(res);
23395	<	if (_v) {
23396	<	int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
23397	<	_v = SWIG_CheckState(res);
23398	<	if (_v) {
23399	<	int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
23400	<	_v = SWIG_CheckState(res);
23401	<	if (_v) {
23402	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_3(self, args);
23403	<	}
23404	<	}
23405	<	}
23406	<	}
23407	<	}
23408	<	}
23409	<	}
23410	<	}
23411	<	}
5984	>	if (obj9) {
5985	>	{
5986	>	if (PyString_Check(obj9))
5987	>	arg10 = std::string(PyString_AsString(obj9));
5988	>	else
5989	>	SWIG_exception(SWIG_TypeError, "string expected");
5990		}
23413	–	}
5991		}
5992	<	}
5993	<	if (argc == 13) {
5994	<	int _v;
5995	<	void *vptr = 0;
5996	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5997	<	_v = SWIG_CheckState(res);
5998	<	if (_v) {
23422	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23423	<	_v = SWIG_CheckState(res);
23424	<	if (_v) {
23425	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23426	<	_v = SWIG_CheckState(res);
23427	<	if (_v) {
23428	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23429	<	_v = SWIG_CheckState(res);
23430	<	if (_v) {
23431	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23432	<	_v = SWIG_CheckState(res);
23433	<	if (_v) {
23434	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
23435	<	_v = SWIG_CheckState(res);
23436	<	if (_v) {
23437	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
23438	<	_v = SWIG_CheckState(res);
23439	<	if (_v) {
23440	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
23441	<	_v = SWIG_CheckState(res);
23442	<	if (_v) {
23443	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
23444	<	_v = SWIG_CheckState(res);
23445	<	if (_v) {
23446	<	int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
23447	<	_v = SWIG_CheckState(res);
23448	<	if (_v) {
23449	<	int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
23450	<	_v = SWIG_CheckState(res);
23451	<	if (_v) {
23452	<	int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
23453	<	_v = SWIG_CheckState(res);
23454	<	if (_v) {
23455	<	int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
23456	<	_v = SWIG_CheckState(res);
23457	<	if (_v) {
23458	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_2(self, args);
23459	<	}
23460	<	}
23461	<	}
23462	<	}
23463	<	}
23464	<	}
23465	<	}
23466	<	}
5992	>	if (obj10) {
5993	>	{
5994	>	if (PyString_Check(obj10)) {
5995	>	temp11 = std::string(PyString_AsString(obj10));
5996	>	arg11 = &temp11;
5997	>	}else {
5998	>	SWIG_exception(SWIG_TypeError, "string expected");
5999		}
23468	–	}
6000		}
23470	–	}
6001		}
6002	<	}
6003	<	if (argc == 14) {
6004	<	int _v;
6005	<	void *vptr = 0;
6006	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6007	<	_v = SWIG_CheckState(res);
23478	<	if (_v) {
23479	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23480	<	_v = SWIG_CheckState(res);
23481	<	if (_v) {
23482	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23483	<	_v = SWIG_CheckState(res);
23484	<	if (_v) {
23485	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23486	<	_v = SWIG_CheckState(res);
23487	<	if (_v) {
23488	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23489	<	_v = SWIG_CheckState(res);
23490	<	if (_v) {
23491	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
23492	<	_v = SWIG_CheckState(res);
23493	<	if (_v) {
23494	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
23495	<	_v = SWIG_CheckState(res);
23496	<	if (_v) {
23497	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
23498	<	_v = SWIG_CheckState(res);
23499	<	if (_v) {
23500	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
23501	<	_v = SWIG_CheckState(res);
23502	<	if (_v) {
23503	<	int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
23504	<	_v = SWIG_CheckState(res);
23505	<	if (_v) {
23506	<	int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
23507	<	_v = SWIG_CheckState(res);
23508	<	if (_v) {
23509	<	int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
23510	<	_v = SWIG_CheckState(res);
23511	<	if (_v) {
23512	<	int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
23513	<	_v = SWIG_CheckState(res);
23514	<	if (_v) {
23515	<	{
23516	<	int res = SWIG_AsVal_bool(argv[13], NULL);
23517	<	_v = SWIG_CheckState(res);
23518	<	}
23519	<	if (_v) {
23520	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_1(self, args);
23521	<	}
23522	<	}
23523	<	}
23524	<	}
23525	<	}
23526	<	}
23527	<	}
23528	<	}
23529	<	}
23530	<	}
23531	<	}
6002	>	if (obj11) {
6003	>	{
6004	>	if (PyString_Check(obj11))
6005	>	arg12 = std::string(PyString_AsString(obj11));
6006	>	else
6007	>	SWIG_exception(SWIG_TypeError, "string expected");
6008		}
23533	–	}
6009		}
6010	<	}
6011	<	if (argc == 15) {
6012	<	int _v;
6013	<	void *vptr = 0;
6014	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6015	<	_v = SWIG_CheckState(res);
23541	<	if (_v) {
23542	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23543	<	_v = SWIG_CheckState(res);
23544	<	if (_v) {
23545	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23546	<	_v = SWIG_CheckState(res);
23547	<	if (_v) {
23548	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23549	<	_v = SWIG_CheckState(res);
23550	<	if (_v) {
23551	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23552	<	_v = SWIG_CheckState(res);
23553	<	if (_v) {
23554	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
23555	<	_v = SWIG_CheckState(res);
23556	<	if (_v) {
23557	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
23558	<	_v = SWIG_CheckState(res);
23559	<	if (_v) {
23560	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
23561	<	_v = SWIG_CheckState(res);
23562	<	if (_v) {
23563	<	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
23564	<	_v = SWIG_CheckState(res);
23565	<	if (_v) {
23566	<	int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
23567	<	_v = SWIG_CheckState(res);
23568	<	if (_v) {
23569	<	int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
23570	<	_v = SWIG_CheckState(res);
23571	<	if (_v) {
23572	<	int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
23573	<	_v = SWIG_CheckState(res);
23574	<	if (_v) {
23575	<	int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
23576	<	_v = SWIG_CheckState(res);
23577	<	if (_v) {
23578	<	{
23579	<	int res = SWIG_AsVal_bool(argv[13], NULL);
23580	<	_v = SWIG_CheckState(res);
23581	<	}
23582	<	if (_v) {
23583	<	{
23584	<	int res = SWIG_AsVal_bool(argv[14], NULL);
23585	<	_v = SWIG_CheckState(res);
23586	<	}
23587	<	if (_v) {
23588	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_0(self, args);
23589	<	}
23590	<	}
23591	<	}
23592	<	}
23593	<	}
23594	<	}
23595	<	}
23596	<	}
23597	<	}
23598	<	}
23599	<	}
23600	<	}
6010	>	if (obj12) {
6011	>	{
6012	>	if (PyString_Check(obj12))
6013	>	arg13 = std::string(PyString_AsString(obj12));
6014	>	else
6015	>	SWIG_exception(SWIG_TypeError, "string expected");
6016		}
23602	–	}
6017		}
6018	<	}
6019	<
6020	<	fail:
23607	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_registerScheduler'");
23608	<	return NULL;
23609	<	}
23610	<
23611	<
23612	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_help(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23613	<	PyObject *resultobj = 0;
23614	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
23615	<	std::string result;
23616	<	void *argp1 = 0 ;
23617	<	int res1 = 0 ;
23618	<	PyObject * obj0 = 0 ;
23619	<
23620	<	if (!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_help",&obj0)) SWIG_fail;
23621	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
23622	<	if (!SWIG_IsOK(res1)) {
23623	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_help" "', argument " "1"" of type '" "BossAdministratorSession *""'");
23624	<	}
23625	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
23626	<	{
23627	<	try {
23628	<	result = (arg1)->help();
23629	<	} catch (const std::exception& e) {
23630	<	SWIG_exception(SWIG_RuntimeError, e.what());
6018	>	if (obj13) {
6019	>	arg14 = PyInt_AsLong(obj13) ? true : false;
6020	>	if (PyErr_Occurred()) SWIG_fail;
6021		}
6022	<	}
6023	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
6024	<	return resultobj;
23635	<	fail:
23636	<	return NULL;
23637	<	}
23638	<
23639	<
23640	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_SQL__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23641	<	PyObject *resultobj = 0;
23642	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
23643	<	std::string arg2 ;
23644	<	bool arg3 ;
23645	<	std::string result;
23646	<	void *argp1 = 0 ;
23647	<	int res1 = 0 ;
23648	<	bool val3 ;
23649	<	int ecode3 = 0 ;
23650	<	PyObject * obj0 = 0 ;
23651	<	PyObject * obj1 = 0 ;
23652	<	PyObject * obj2 = 0 ;
23653	<
23654	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) SWIG_fail;
23655	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
23656	<	if (!SWIG_IsOK(res1)) {
23657	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_SQL" "', argument " "1"" of type '" "BossAdministratorSession *""'");
23658	<	}
23659	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
23660	<	{
23661	<	std::string *ptr = (std::string *)0;
23662	<	int res = SWIG_AsPtr_std_string(obj1, &ptr);
23663	<	if (!SWIG_IsOK(res) || !ptr) {
23664	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_SQL" "', argument " "2"" of type '" "std::string""'");
6022	>	if (obj14) {
6023	>	arg15 = PyInt_AsLong(obj14) ? true : false;
6024	>	if (PyErr_Occurred()) SWIG_fail;
6025		}
6026	<	arg2 = *ptr;
6027	<	if (SWIG_IsNewObj(res)) delete ptr;
6028	<	}
23669	<	ecode3 = SWIG_AsVal_bool(obj2, &val3);
23670	<	if (!SWIG_IsOK(ecode3)) {
23671	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossAdministratorSession_SQL" "', argument " "3"" of type '" "bool""'");
23672	<	}
23673	<	arg3 = static_cast< bool >(val3);
23674	<	{
23675	<	try {
23676	<	result = (arg1)->SQL(arg2,arg3);
23677	<	} catch (const std::exception& e) {
23678	<	SWIG_exception(SWIG_RuntimeError, e.what());
6026	>	if (obj15) {
6027	>	arg16 = PyInt_AsLong(obj15) ? true : false;
6028	>	if (PyErr_Occurred()) SWIG_fail;
6029		}
6030	<	}
6031	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
6032	<	return resultobj;
23683	<	fail:
23684	<	return NULL;
23685	<	}
23686	<
23687	<
23688	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_SQL__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23689	<	PyObject *resultobj = 0;
23690	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
23691	<	std::string arg2 ;
23692	<	std::string result;
23693	<	void *argp1 = 0 ;
23694	<	int res1 = 0 ;
23695	<	PyObject * obj0 = 0 ;
23696	<	PyObject * obj1 = 0 ;
23697	<
23698	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_SQL",&obj0,&obj1)) SWIG_fail;
23699	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
23700	<	if (!SWIG_IsOK(res1)) {
23701	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_SQL" "', argument " "1"" of type '" "BossAdministratorSession *""'");
23702	<	}
23703	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
23704	<	{
23705	<	std::string *ptr = (std::string *)0;
23706	<	int res = SWIG_AsPtr_std_string(obj1, &ptr);
23707	<	if (!SWIG_IsOK(res) || !ptr) {
23708	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_SQL" "', argument " "2"" of type '" "std::string""'");
6030	>	if (obj16) {
6031	>	arg17 = PyInt_AsLong(obj16) ? true : false;
6032	>	if (PyErr_Occurred()) SWIG_fail;
6033		}
6034	<	arg2 = *ptr;
6035	<	if (SWIG_IsNewObj(res)) delete ptr;
6036	<	}
6037	<	{
6038	<	try {
6039	<	result = (arg1)->SQL(arg2);
6040	<	} catch (const std::exception& e) {
6041	<	SWIG_exception(SWIG_RuntimeError, e.what());
6034	>	{
6035	>	try {
6036	>	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);
6037	>
6038	>	}catch (const BossSchedFailure & e) {
6039	>	PyErr_SetString ( SchedulerError, e.what() );
6040	>	return NULL;
6041	>	}catch (const std::exception& e) {
6042	>	PyErr_SetString ( BossError, e.what() );
6043	>	return NULL;
6044	>	}
6045		}
6046	<	}
6047	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
6048	<	return resultobj;
6049	<	fail:
23723	<	return NULL;
6046	>	resultobj = PyInt_FromLong((long)result);
6047	>	return resultobj;
6048	>	fail:
6049	>	return NULL;
6050		}
6051
6052
6053	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6054	<	int argc;
6055	<	PyObject *argv[4];
6056	<	int ii;
6057	<
6058	<	if (!PyTuple_Check(args)) SWIG_fail;
6059	<	argc = PyObject_Length(args);
6060	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6061	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
6062	<	}
6063	<	if (argc == 2) {
6064	<	int _v;
6065	<	void *vptr = 0;
6066	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6067	<	_v = SWIG_CheckState(res);
6068	<	if (_v) {
6069	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
6070	<	_v = SWIG_CheckState(res);
23745	<	if (_v) {
23746	<	return _wrap_BossAdministratorSession_SQL__SWIG_1(self, args);
23747	<	}
23748	<	}
23749	<	}
23750	<	if (argc == 3) {
23751	<	int _v;
23752	<	void *vptr = 0;
23753	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23754	<	_v = SWIG_CheckState(res);
23755	<	if (_v) {
23756	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23757	<	_v = SWIG_CheckState(res);
23758	<	if (_v) {
23759	<	{
23760	<	int res = SWIG_AsVal_bool(argv[2], NULL);
23761	<	_v = SWIG_CheckState(res);
23762	<	}
23763	<	if (_v) {
23764	<	return _wrap_BossAdministratorSession_SQL__SWIG_0(self, args);
6053	>	static PyObject *_wrap_BossAdministratorSession_help(PyObject *self, PyObject *args) {
6054	>	PyObject *resultobj;
6055	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6056	>	std::string result;
6057	>	PyObject * obj0 = 0 ;
6058	>
6059	>	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_help",&obj0)) goto fail;
6060	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6061	>	{
6062	>	try {
6063	>	result = (arg1)->help();
6064	>
6065	>	}catch (const BossSchedFailure & e) {
6066	>	PyErr_SetString ( SchedulerError, e.what() );
6067	>	return NULL;
6068	>	}catch (const std::exception& e) {
6069	>	PyErr_SetString ( BossError, e.what() );
6070	>	return NULL;
6071		}
23766	–	}
6072		}
6073	<	}
6074	<
6075	<	fail:
6076	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_SQL'");
6077	<	return NULL;
6073	>	{
6074	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
6075	>	}
6076	>	return resultobj;
6077	>	fail:
6078	>	return NULL;
6079		}
6080
6081
6082	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_purge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6083	<	PyObject *resultobj = 0;
6084	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6085	<	std::string *arg2 = 0 ;
6086	<	std::string *arg3 = 0 ;
6087	<	std::string *arg4 = 0 ;
6088	<	std::string *arg5 = 0 ;
6089	<	int result;
6090	<	void *argp1 = 0 ;
6091	<	int res1 = 0 ;
6092	<	int res2 = SWIG_OLDOBJ ;
6093	<	int res3 = SWIG_OLDOBJ ;
6094	<	int res4 = SWIG_OLDOBJ ;
6095	<	int res5 = SWIG_OLDOBJ ;
6096	<	PyObject * obj0 = 0 ;
6097	<	PyObject * obj1 = 0 ;
6098	<	PyObject * obj2 = 0 ;
23793	<	PyObject * obj3 = 0 ;
23794	<	PyObject * obj4 = 0 ;
23795	<
23796	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23797	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
23798	<	if (!SWIG_IsOK(res1)) {
23799	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_purge" "', argument " "1"" of type '" "BossAdministratorSession *""'");
23800	<	}
23801	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
23802	<	{
23803	<	std::string *ptr = (std::string *)0;
23804	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
23805	<	if (!SWIG_IsOK(res2)) {
23806	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_purge" "', argument " "2"" of type '" "std::string const &""'");
23807	<	}
23808	<	if (!ptr) {
23809	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "2"" of type '" "std::string const &""'");
23810	<	}
23811	<	arg2 = ptr;
23812	<	}
23813	<	{
23814	<	std::string *ptr = (std::string *)0;
23815	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
23816	<	if (!SWIG_IsOK(res3)) {
23817	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossAdministratorSession_purge" "', argument " "3"" of type '" "std::string const &""'");
23818	<	}
23819	<	if (!ptr) {
23820	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "3"" of type '" "std::string const &""'");
23821	<	}
23822	<	arg3 = ptr;
23823	<	}
23824	<	{
23825	<	std::string *ptr = (std::string *)0;
23826	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
23827	<	if (!SWIG_IsOK(res4)) {
23828	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossAdministratorSession_purge" "', argument " "4"" of type '" "std::string const &""'");
23829	<	}
23830	<	if (!ptr) {
23831	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "4"" of type '" "std::string const &""'");
6082	>	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6083	>	PyObject *resultobj;
6084	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6085	>	std::string arg2 ;
6086	>	bool arg3 = (bool) false ;
6087	>	std::string result;
6088	>	PyObject * obj0 = 0 ;
6089	>	PyObject * obj1 = 0 ;
6090	>	PyObject * obj2 = 0 ;
6091	>
6092	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
6093	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6094	>	{
6095	>	if (PyString_Check(obj1))
6096	>	arg2 = std::string(PyString_AsString(obj1));
6097	>	else
6098	>	SWIG_exception(SWIG_TypeError, "string expected");
6099		}
6100	<	arg4 = ptr;
6101	<	}
6102	<	{
23836	<	std::string *ptr = (std::string *)0;
23837	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
23838	<	if (!SWIG_IsOK(res5)) {
23839	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossAdministratorSession_purge" "', argument " "5"" of type '" "std::string const &""'");
6100	>	if (obj2) {
6101	>	arg3 = PyInt_AsLong(obj2) ? true : false;
6102	>	if (PyErr_Occurred()) SWIG_fail;
6103		}
6104	<	if (!ptr) {
6105	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "5"" of type '" "std::string const &""'");
6104	>	{
6105	>	try {
6106	>	result = (arg1)->SQL(arg2,arg3);
6107	>
6108	>	}catch (const BossSchedFailure & e) {
6109	>	PyErr_SetString ( SchedulerError, e.what() );
6110	>	return NULL;
6111	>	}catch (const std::exception& e) {
6112	>	PyErr_SetString ( BossError, e.what() );
6113	>	return NULL;
6114	>	}
6115		}
6116	<	arg5 = ptr;
6117	<	}
23846	<	{
23847	<	try {
23848	<	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
23849	<	} catch (const std::exception& e) {
23850	<	SWIG_exception(SWIG_RuntimeError, e.what());
6116	>	{
6117	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
6118		}
6119	<	}
6120	<	resultobj = SWIG_From_int(static_cast< int >(result));
6121	<	if (SWIG_IsNewObj(res2)) delete arg2;
23855	<	if (SWIG_IsNewObj(res3)) delete arg3;
23856	<	if (SWIG_IsNewObj(res4)) delete arg4;
23857	<	if (SWIG_IsNewObj(res5)) delete arg5;
23858	<	return resultobj;
23859	<	fail:
23860	<	if (SWIG_IsNewObj(res2)) delete arg2;
23861	<	if (SWIG_IsNewObj(res3)) delete arg3;
23862	<	if (SWIG_IsNewObj(res4)) delete arg4;
23863	<	if (SWIG_IsNewObj(res5)) delete arg5;
23864	<	return NULL;
6119	>	return resultobj;
6120	>	fail:
6121	>	return NULL;
6122		}
6123
6124
6125	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_purge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6126	<	PyObject *resultobj = 0;
6127	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6128	<	std::string *arg2 = 0 ;
6129	<	std::string *arg3 = 0 ;
6130	<	std::string *arg4 = 0 ;
6131	<	int result;
6132	<	void *argp1 = 0 ;
6133	<	int res1 = 0 ;
6134	<	int res2 = SWIG_OLDOBJ ;
6135	<	int res3 = SWIG_OLDOBJ ;
6136	<	int res4 = SWIG_OLDOBJ ;
6137	<	PyObject * obj0 = 0 ;
6138	<	PyObject * obj1 = 0 ;
6139	<	PyObject * obj2 = 0 ;
6140	<	PyObject * obj3 = 0 ;
6141	<
6142	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6143	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
6144	<	if (!SWIG_IsOK(res1)) {
6145	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_purge" "', argument " "1"" of type '" "BossAdministratorSession *""'");
6146	<	}
6147	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
6148	<	{
6149	<	std::string *ptr = (std::string *)0;
6150	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
6151	<	if (!SWIG_IsOK(res2)) {
6152	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_purge" "', argument " "2"" of type '" "std::string const &""'");
23896	<	}
23897	<	if (!ptr) {
23898	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "2"" of type '" "std::string const &""'");
23899	<	}
23900	<	arg2 = ptr;
23901	<	}
23902	<	{
23903	<	std::string *ptr = (std::string *)0;
23904	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
23905	<	if (!SWIG_IsOK(res3)) {
23906	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossAdministratorSession_purge" "', argument " "3"" of type '" "std::string const &""'");
23907	<	}
23908	<	if (!ptr) {
23909	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "3"" of type '" "std::string const &""'");
23910	<	}
23911	<	arg3 = ptr;
23912	<	}
23913	<	{
23914	<	std::string *ptr = (std::string *)0;
23915	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
23916	<	if (!SWIG_IsOK(res4)) {
23917	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossAdministratorSession_purge" "', argument " "4"" of type '" "std::string const &""'");
23918	<	}
23919	<	if (!ptr) {
23920	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "4"" of type '" "std::string const &""'");
6125	>	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
6126	>	PyObject *resultobj;
6127	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6128	>	std::string *arg2 = 0 ;
6129	>	std::string *arg3 = 0 ;
6130	>	std::string *arg4 = 0 ;
6131	>	std::string const &arg5_defvalue = "0" ;
6132	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
6133	>	int result;
6134	>	std::string temp2 ;
6135	>	std::string temp3 ;
6136	>	std::string temp4 ;
6137	>	std::string temp5 ;
6138	>	PyObject * obj0 = 0 ;
6139	>	PyObject * obj1 = 0 ;
6140	>	PyObject * obj2 = 0 ;
6141	>	PyObject * obj3 = 0 ;
6142	>	PyObject * obj4 = 0 ;
6143	>
6144	>	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6145	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6146	>	{
6147	>	if (PyString_Check(obj1)) {
6148	>	temp2 = std::string(PyString_AsString(obj1));
6149	>	arg2 = &temp2;
6150	>	}else {
6151	>	SWIG_exception(SWIG_TypeError, "string expected");
6152	>	}
6153		}
6154	<	arg4 = ptr;
6155	<	}
6156	<	{
6157	<	try {
6158	<	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
6159	<	} catch (const std::exception& e) {
6160	<	SWIG_exception(SWIG_RuntimeError, e.what());
6154	>	{
6155	>	if (PyString_Check(obj2)) {
6156	>	temp3 = std::string(PyString_AsString(obj2));
6157	>	arg3 = &temp3;
6158	>	}else {
6159	>	SWIG_exception(SWIG_TypeError, "string expected");
6160	>	}
6161		}
6162	<	}
6163	<	resultobj = SWIG_From_int(static_cast< int >(result));
6164	<	if (SWIG_IsNewObj(res2)) delete arg2;
6165	<	if (SWIG_IsNewObj(res3)) delete arg3;
6166	<	if (SWIG_IsNewObj(res4)) delete arg4;
6167	<	return resultobj;
23936	<	fail:
23937	<	if (SWIG_IsNewObj(res2)) delete arg2;
23938	<	if (SWIG_IsNewObj(res3)) delete arg3;
23939	<	if (SWIG_IsNewObj(res4)) delete arg4;
23940	<	return NULL;
23941	<	}
23942	<
23943	<
23944	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
23945	<	int argc;
23946	<	PyObject *argv[6];
23947	<	int ii;
23948	<
23949	<	if (!PyTuple_Check(args)) SWIG_fail;
23950	<	argc = PyObject_Length(args);
23951	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
23952	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
23953	<	}
23954	<	if (argc == 4) {
23955	<	int _v;
23956	<	void *vptr = 0;
23957	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23958	<	_v = SWIG_CheckState(res);
23959	<	if (_v) {
23960	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23961	<	_v = SWIG_CheckState(res);
23962	<	if (_v) {
23963	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23964	<	_v = SWIG_CheckState(res);
23965	<	if (_v) {
23966	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23967	<	_v = SWIG_CheckState(res);
23968	<	if (_v) {
23969	<	return _wrap_BossAdministratorSession_purge__SWIG_1(self, args);
23970	<	}
6162	>	{
6163	>	if (PyString_Check(obj3)) {
6164	>	temp4 = std::string(PyString_AsString(obj3));
6165	>	arg4 = &temp4;
6166	>	}else {
6167	>	SWIG_exception(SWIG_TypeError, "string expected");
6168		}
23972	–	}
6169		}
6170	<	}
6171	<	if (argc == 5) {
6172	<	int _v;
6173	<	void *vptr = 0;
6174	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6175	<	_v = SWIG_CheckState(res);
6176	<	if (_v) {
23981	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23982	<	_v = SWIG_CheckState(res);
23983	<	if (_v) {
23984	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23985	<	_v = SWIG_CheckState(res);
23986	<	if (_v) {
23987	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
23988	<	_v = SWIG_CheckState(res);
23989	<	if (_v) {
23990	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
23991	<	_v = SWIG_CheckState(res);
23992	<	if (_v) {
23993	<	return _wrap_BossAdministratorSession_purge__SWIG_0(self, args);
6170	>	if (obj4) {
6171	>	{
6172	>	if (PyString_Check(obj4)) {
6173	>	temp5 = std::string(PyString_AsString(obj4));
6174	>	arg5 = &temp5;
6175	>	}else {
6176	>	SWIG_exception(SWIG_TypeError, "string expected");
6177		}
23995	–	}
6178		}
23997	–	}
6179		}
6180	<	}
6181	<
6182	<	fail:
6183	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_purge'");
6184	<	return NULL;
6180	>	{
6181	>	try {
6182	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6183	>
6184	>	}catch (const BossSchedFailure & e) {
6185	>	PyErr_SetString ( SchedulerError, e.what() );
6186	>	return NULL;
6187	>	}catch (const std::exception& e) {
6188	>	PyErr_SetString ( BossError, e.what() );
6189	>	return NULL;
6190	>	}
6191	>	}
6192	>	resultobj = PyInt_FromLong((long)result);
6193	>	return resultobj;
6194	>	fail:
6195	>	return NULL;
6196		}
6197
6198
6199	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6200	<	PyObject *resultobj = 0;
6201	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6202	<	std::string arg2 ;
6203	<	int result;
6204	<	void *argp1 = 0 ;
6205	<	int res1 = 0 ;
6206	<	PyObject * obj0 = 0 ;
6207	<	PyObject * obj1 = 0 ;
6208	<
6209	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configure",&obj0,&obj1)) SWIG_fail;
6210	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
6211	<	if (!SWIG_IsOK(res1)) {
6212	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_configure" "', argument " "1"" of type '" "BossAdministratorSession *""'");
6213	<	}
24022	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
24023	<	{
24024	<	std::string *ptr = (std::string *)0;
24025	<	int res = SWIG_AsPtr_std_string(obj1, &ptr);
24026	<	if (!SWIG_IsOK(res) || !ptr) {
24027	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_configure" "', argument " "2"" of type '" "std::string""'");
6199	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
6200	>	PyObject *resultobj;
6201	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6202	>	std::string arg2 ;
6203	>	int result;
6204	>	PyObject * obj0 = 0 ;
6205	>	PyObject * obj1 = 0 ;
6206	>
6207	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6208	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6209	>	{
6210	>	if (PyString_Check(obj1))
6211	>	arg2 = std::string(PyString_AsString(obj1));
6212	>	else
6213	>	SWIG_exception(SWIG_TypeError, "string expected");
6214		}
6215	<	arg2 = *ptr;
6216	<	if (SWIG_IsNewObj(res)) delete ptr;
6217	<	}
6218	<	{
6219	<	try {
6220	<	result = (int)(arg1)->configure(arg2);
6221	<	} catch (const std::exception& e) {
6222	<	SWIG_exception(SWIG_RuntimeError, e.what());
6215	>	{
6216	>	try {
6217	>	result = (int)(arg1)->registerPlugins(arg2);
6218	>
6219	>	}catch (const BossSchedFailure & e) {
6220	>	PyErr_SetString ( SchedulerError, e.what() );
6221	>	return NULL;
6222	>	}catch (const std::exception& e) {
6223	>	PyErr_SetString ( BossError, e.what() );
6224	>	return NULL;
6225	>	}
6226		}
6227	<	}
6228	<	resultobj = SWIG_From_int(static_cast< int >(result));
6229	<	return resultobj;
6230	<	fail:
24042	<	return NULL;
6227	>	resultobj = PyInt_FromLong((long)result);
6228	>	return resultobj;
6229	>	fail:
6230	>	return NULL;
6231		}
6232
6233
6234	<	SWIGINTERN PyObject *BossAdministratorSession_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6235	<	PyObject *obj;
6236	<	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
6237	<	SWIG_TypeNewClientData(SWIGTYPE_p_BossAdministratorSession, SWIG_NewClientData(obj));
6238	<	return SWIG_Py_Void();
6234	>	static PyObject * BossAdministratorSession_swigregister(PyObject *self, PyObject *args) {
6235	>	PyObject *obj;
6236	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6237	>	SWIG_TypeClientData(SWIGTYPE_p_BossAdministratorSession, obj);
6238	>	Py_INCREF(obj);
6239	>	return Py_BuildValue((char *)"");
6240		}
24052	–
6241		static PyMethodDef SwigMethods[] = {
6242	<	{ (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
6243	<	{ (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
6244	<	{ (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
6245	<	{ (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
6246	<	{ (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
6247	<	{ (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
6248	<	{ (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
6249	<	{ (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
6250	<	{ (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
6251	<	{ (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
6252	<	{ (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
6253	<	{ (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
6254	<	{ (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
6255	<	{ (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
6256	<	{ (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
6257	<	{ (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
6258	<	{ (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
6259	<	{ (char *)"objectMap_iterator", _wrap_objectMap_iterator, METH_VARARGS, NULL},
6260	<	{ (char *)"objectMap___nonzero__", _wrap_objectMap___nonzero__, METH_VARARGS, NULL},
6261	<	{ (char *)"objectMap___len__", _wrap_objectMap___len__, METH_VARARGS, NULL},
6262	<	{ (char *)"objectMap___getitem__", _wrap_objectMap___getitem__, METH_VARARGS, NULL},
6263	<	{ (char *)"objectMap___setitem__", _wrap_objectMap___setitem__, METH_VARARGS, NULL},
6264	<	{ (char *)"objectMap___delitem__", _wrap_objectMap___delitem__, METH_VARARGS, NULL},
6265	<	{ (char *)"objectMap_has_key", _wrap_objectMap_has_key, METH_VARARGS, NULL},
6266	<	{ (char *)"objectMap_keys", _wrap_objectMap_keys, METH_VARARGS, NULL},
6267	<	{ (char *)"objectMap_values", _wrap_objectMap_values, METH_VARARGS, NULL},
6268	<	{ (char *)"objectMap_items", _wrap_objectMap_items, METH_VARARGS, NULL},
6269	<	{ (char *)"objectMap___contains__", _wrap_objectMap___contains__, METH_VARARGS, NULL},
6270	<	{ (char *)"objectMap_key_iterator", _wrap_objectMap_key_iterator, METH_VARARGS, NULL},
6271	<	{ (char *)"objectMap_value_iterator", _wrap_objectMap_value_iterator, METH_VARARGS, NULL},
6272	<	{ (char *)"new_objectMap", _wrap_new_objectMap, METH_VARARGS, NULL},
6273	<	{ (char *)"objectMap_empty", _wrap_objectMap_empty, METH_VARARGS, NULL},
6274	<	{ (char *)"objectMap_size", _wrap_objectMap_size, METH_VARARGS, NULL},
6275	<	{ (char *)"objectMap_clear", _wrap_objectMap_clear, METH_VARARGS, NULL},
6276	<	{ (char *)"objectMap_swap", _wrap_objectMap_swap, METH_VARARGS, NULL},
6277	<	{ (char *)"objectMap_get_allocator", _wrap_objectMap_get_allocator, METH_VARARGS, NULL},
6278	<	{ (char *)"objectMap_begin", _wrap_objectMap_begin, METH_VARARGS, NULL},
6279	<	{ (char *)"objectMap_end", _wrap_objectMap_end, METH_VARARGS, NULL},
6280	<	{ (char *)"objectMap_rbegin", _wrap_objectMap_rbegin, METH_VARARGS, NULL},
6281	<	{ (char *)"objectMap_rend", _wrap_objectMap_rend, METH_VARARGS, NULL},
6282	<	{ (char *)"objectMap_count", _wrap_objectMap_count, METH_VARARGS, NULL},
6283	<	{ (char *)"objectMap_erase", _wrap_objectMap_erase, METH_VARARGS, NULL},
6284	<	{ (char *)"objectMap_find", _wrap_objectMap_find, METH_VARARGS, NULL},
6285	<	{ (char *)"objectMap_lower_bound", _wrap_objectMap_lower_bound, METH_VARARGS, NULL},
6286	<	{ (char *)"objectMap_upper_bound", _wrap_objectMap_upper_bound, METH_VARARGS, NULL},
6287	<	{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS, NULL},
6288	<	{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS, NULL},
6289	<	{ (char *)"vector_string_iterator", _wrap_vector_string_iterator, METH_VARARGS, NULL},
6290	<	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS, NULL},
6291	<	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS, NULL},
6292	<	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS, NULL},
6293	<	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS, NULL},
6294	<	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS, NULL},
6295	<	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS, NULL},
6296	<	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS, NULL},
6297	<	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS, NULL},
6298	<	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS, NULL},
6299	<	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS, NULL},
6300	<	{ (char *)"vector_string_empty", _wrap_vector_string_empty, METH_VARARGS, NULL},
6301	<	{ (char *)"vector_string_size", _wrap_vector_string_size, METH_VARARGS, NULL},
6302	<	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS, NULL},
6303	<	{ (char *)"vector_string_swap", _wrap_vector_string_swap, METH_VARARGS, NULL},
6304	<	{ (char *)"vector_string_get_allocator", _wrap_vector_string_get_allocator, METH_VARARGS, NULL},
6305	<	{ (char *)"vector_string_begin", _wrap_vector_string_begin, METH_VARARGS, NULL},
6306	<	{ (char *)"vector_string_end", _wrap_vector_string_end, METH_VARARGS, NULL},
6307	<	{ (char *)"vector_string_rbegin", _wrap_vector_string_rbegin, METH_VARARGS, NULL},
6308	<	{ (char *)"vector_string_rend", _wrap_vector_string_rend, METH_VARARGS, NULL},
6309	<	{ (char *)"vector_string_pop_back", _wrap_vector_string_pop_back, METH_VARARGS, NULL},
6310	<	{ (char *)"vector_string_erase", _wrap_vector_string_erase, METH_VARARGS, NULL},
6311	<	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS, NULL},
6312	<	{ (char *)"vector_string_push_back", _wrap_vector_string_push_back, METH_VARARGS, NULL},
6313	<	{ (char *)"vector_string_front", _wrap_vector_string_front, METH_VARARGS, NULL},
6314	<	{ (char *)"vector_string_back", _wrap_vector_string_back, METH_VARARGS, NULL},
6315	<	{ (char *)"vector_string_assign", _wrap_vector_string_assign, METH_VARARGS, NULL},
6316	<	{ (char *)"vector_string_resize", _wrap_vector_string_resize, METH_VARARGS, NULL},
6317	<	{ (char *)"vector_string_insert", _wrap_vector_string_insert, METH_VARARGS, NULL},
6318	<	{ (char *)"vector_string_reserve", _wrap_vector_string_reserve, METH_VARARGS, NULL},
6319	<	{ (char *)"vector_string_capacity", _wrap_vector_string_capacity, METH_VARARGS, NULL},
6320	<	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS, NULL},
6321	<	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS, NULL},
6322	<	{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS, NULL},
6323	<	{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS, NULL},
6324	<	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS, NULL},
6325	<	{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS, NULL},
6326	<	{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS, NULL},
6327	<	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS, NULL},
6328	<	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS, NULL},
6329	<	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS, NULL},
6330	<	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS, NULL},
6331	<	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS, NULL},
6332	<	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS, NULL},
6333	<	{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS, NULL},
6334	<	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS, NULL},
6335	<	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS, NULL},
6336	<	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS, NULL},
6337	<	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS, NULL},
6338	<	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS, NULL},
6339	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS, NULL},
6340	<	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS, NULL},
6341	<	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS, NULL},
6342	<	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS, NULL},
6343	<	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS, NULL},
6344	<	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS, NULL},
6345	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS, NULL},
6346	<	{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS, NULL},
6347	<	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS, NULL},
6348	<	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS, NULL},
6349	<	{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS, NULL},
6350	<	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS, NULL},
6351	<	{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS, NULL},
6352	<	{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS, NULL},
24165	<	{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS, NULL},
24166	<	{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS, NULL},
24167	<	{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS, NULL},
24168	<	{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS, NULL},
24169	<	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS, NULL},
24170	<	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS, NULL},
24171	<	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS, NULL},
24172	<	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS, NULL},
24173	<	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS, NULL},
24174	<	{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS, NULL},
24175	<	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS, NULL},
24176	<	{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS, NULL},
24177	<	{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS, NULL},
24178	<	{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS, NULL},
24179	<	{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS, NULL},
24180	<	{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS, NULL},
24181	<	{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS, NULL},
24182	<	{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS, NULL},
24183	<	{ (char *)"BossTask_getAllOutput", _wrap_BossTask_getAllOutput, METH_VARARGS, NULL},
24184	<	{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS, NULL},
24185	<	{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS, NULL},
24186	<	{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS, NULL},
24187	<	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS, NULL},
24188	<	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS, NULL},
24189	<	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS, NULL},
24190	<	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS, NULL},
24191	<	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS, NULL},
24192	<	{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS, NULL},
24193	<	{ (char *)"prompt", _wrap_prompt, METH_VARARGS, NULL},
24194	<	{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS, NULL},
24195	<	{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS, NULL},
24196	<	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS, NULL},
24197	<	{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS, NULL},
24198	<	{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS, NULL},
24199	<	{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS, NULL},
24200	<	{ (char *)"BossAdministratorSession_deleteRTMon", _wrap_BossAdministratorSession_deleteRTMon, METH_VARARGS, NULL},
24201	<	{ (char *)"BossAdministratorSession_deleteScheduler", _wrap_BossAdministratorSession_deleteScheduler, METH_VARARGS, NULL},
24202	<	{ (char *)"BossAdministratorSession_registerCHTool", _wrap_BossAdministratorSession_registerCHTool, METH_VARARGS, NULL},
24203	<	{ (char *)"BossAdministratorSession_registerProgram", _wrap_BossAdministratorSession_registerProgram, METH_VARARGS, NULL},
24204	<	{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS, NULL},
24205	<	{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS, NULL},
24206	<	{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS, NULL},
24207	<	{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS, NULL},
24208	<	{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS, NULL},
24209	<	{ (char *)"BossAdministratorSession_configure", _wrap_BossAdministratorSession_configure, METH_VARARGS, NULL},
24210	<	{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS, NULL},
24211	<	{ NULL, NULL, 0, NULL }
6242	>	{ (char *)"new_objectMap", _wrap_new_objectMap, METH_VARARGS },
6243	>	{ (char *)"objectMap___len__", _wrap_objectMap___len__, METH_VARARGS },
6244	>	{ (char *)"objectMap_clear", _wrap_objectMap_clear, METH_VARARGS },
6245	>	{ (char *)"objectMap___nonzero__", _wrap_objectMap___nonzero__, METH_VARARGS },
6246	>	{ (char *)"objectMap___getitem__", _wrap_objectMap___getitem__, METH_VARARGS },
6247	>	{ (char *)"objectMap___setitem__", _wrap_objectMap___setitem__, METH_VARARGS },
6248	>	{ (char *)"objectMap___delitem__", _wrap_objectMap___delitem__, METH_VARARGS },
6249	>	{ (char *)"objectMap_has_key", _wrap_objectMap_has_key, METH_VARARGS },
6250	>	{ (char *)"objectMap_keys", _wrap_objectMap_keys, METH_VARARGS },
6251	>	{ (char *)"objectMap_values", _wrap_objectMap_values, METH_VARARGS },
6252	>	{ (char *)"objectMap_items", _wrap_objectMap_items, METH_VARARGS },
6253	>	{ (char *)"objectMap___contains__", _wrap_objectMap___contains__, METH_VARARGS },
6254	>	{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6255	>	{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6256	>	{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6257	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6258	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6259	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6260	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6261	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6262	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6263	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6264	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6265	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6266	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6267	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6268	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6269	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6270	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6271	>	{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6272	>	{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6273	>	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6274	>	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6275	>	{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6276	>	{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6277	>	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6278	>	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6279	>	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6280	>	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6281	>	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6282	>	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6283	>	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
6284	>	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS },
6285	>	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
6286	>	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
6287	>	{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
6288	>	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6289	>	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6290	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6291	>	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6292	>	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6293	>	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6294	>	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6295	>	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6296	>	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6297	>	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6298	>	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6299	>	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6300	>	{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6301	>	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6302	>	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
6303	>	{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
6304	>	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6305	>	{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6306	>	{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
6307	>	{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6308	>	{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6309	>	{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
6310	>	{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
6311	>	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6312	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6313	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6314	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
6315	>	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6316	>	{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6317	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6318	>	{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
6319	>	{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
6320	>	{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
6321	>	{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
6322	>	{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6323	>	{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6324	>	{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6325	>	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6326	>	{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6327	>	{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6328	>	{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6329	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6330	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6331	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6332	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6333	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6334	>	{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6335	>	{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6336	>	{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
6337	>	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
6338	>	{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
6339	>	{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
6340	>	{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
6341	>	{ (char *)"BossAdministratorSession_deleteRTMon", _wrap_BossAdministratorSession_deleteRTMon, METH_VARARGS },
6342	>	{ (char *)"BossAdministratorSession_deleteScheduler", _wrap_BossAdministratorSession_deleteScheduler, METH_VARARGS },
6343	>	{ (char *)"BossAdministratorSession_registerCHTool", _wrap_BossAdministratorSession_registerCHTool, METH_VARARGS },
6344	>	{ (char *)"BossAdministratorSession_registerProgram", _wrap_BossAdministratorSession_registerProgram, METH_VARARGS },
6345	>	{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
6346	>	{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
6347	>	{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
6348	>	{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
6349	>	{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
6350	>	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
6351	>	{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
6352	>	{ NULL, NULL }
6353		};
6354
6355
6356		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6357
6358	<	static void *_p_BossTaskExceptionTo_p_std__exception(void *x) {
6359	<	return (void *)((std::exception *)  ((BossTaskException *) x));
6360	<	}
6361	<	static swig_type_info _swigt__p_BossAdministratorSession = {"_p_BossAdministratorSession", "BossAdministratorSession *", 0, 0, (void*)0, 0};
6362	<	static swig_type_info _swigt__p_BossAttributeContainer = {"_p_BossAttributeContainer", "BossAttributeContainer *", 0, 0, (void*)0, 0};
6363	<	static swig_type_info _swigt__p_BossDatabase = {"_p_BossDatabase", "BossDatabase *", 0, 0, (void*)0, 0};
6364	<	static swig_type_info _swigt__p_BossJob = {"_p_BossJob", "BossJob *", 0, 0, (void*)0, 0};
6365	<	static swig_type_info _swigt__p_BossSession = {"_p_BossSession", "BossSession *", 0, 0, (void*)0, 0};
6366	<	static swig_type_info _swigt__p_BossTask = {"_p_BossTask", "BossTask *", 0, 0, (void*)0, 0};
6367	<	static swig_type_info _swigt__p_BossTaskException = {"_p_BossTaskException", "BossTaskException *", 0, 0, (void*)0, 0};
6368	<	static swig_type_info _swigt__p_XMLDoc = {"_p_XMLDoc", "XMLDoc *", 0, 0, (void*)0, 0};
6369	<	static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
6370	<	static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
6371	<	static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
6372	<	static swig_type_info _swigt__p_job_iterator = {"_p_job_iterator", "job_iterator *", 0, 0, (void*)0, 0};
6373	<	static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
6374	<	static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
6375	<	static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
6376	<	static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
6377	<	static swig_type_info _swigt__p_std__exception = {"_p_std__exception", "std::exception *", 0, 0, (void*)0, 0};
6378	<	static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
6379	<	static swig_type_info _swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_t_t_t = {"_p_std__mapTstd__string_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_t_t_t", "std::map<std::string,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >,std::less<std::string >,std::allocator<std::pair<std::string const,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > > > > *", 0, 0, (void*)0, 0};
6380	<	static swig_type_info _swigt__p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t = {"_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t", "std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > *", 0, 0, (void*)0, 0};
6381	<	static swig_type_info _swigt__p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t__allocator_type = {"_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t__allocator_type", "std::allocator<std::pair<std::string const,std::string > > *|std::map<std::string,std::string >::allocator_type *", 0, 0, (void*)0, 0};
6382	<	static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
6383	<	static swig_type_info _swigt__p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator = {"_p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator", "std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator *", 0, 0, (void*)0, 0};
6384	<	static swig_type_info _swigt__p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t = {"_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t", "std::vector<BossTask *,std::allocator<BossTask * > > *", 0, 0, (void*)0, 0};
6385	<	static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t = {"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t", "std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > > *", 0, 0, (void*)0, 0};
6386	<	static swig_type_info _swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t__const_iterator = {"_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t__const_iterator", "std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >::const_iterator *", 0, 0, (void*)0, 0};
6387	<	static swig_type_info _swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t = {"_p_std__vectorTstd__string_std__allocatorTstd__string_t_t", "std::vector<std::string,std::allocator<std::string > > *", 0, 0, (void*)0, 0};
6388	<	static swig_type_info _swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t__allocator_type = {"_p_std__vectorTstd__string_std__allocatorTstd__string_t_t__allocator_type", "std::allocator<std::string > *|std::vector<std::string >::allocator_type *", 0, 0, (void*)0, 0};
6389	<	static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
6390	<	static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
6391	<
6392	<	static swig_type_info *swig_type_initial[] = {
6393	<	&_swigt__p_BossAdministratorSession,
6394	<	&_swigt__p_BossAttributeContainer,
6395	<	&_swigt__p_BossDatabase,
6396	<	&_swigt__p_BossJob,
6397	<	&_swigt__p_BossSession,
6398	<	&_swigt__p_BossTask,
24258	<	&_swigt__p_BossTaskException,
24259	<	&_swigt__p_XMLDoc,
24260	<	&_swigt__p_allocator_type,
24261	<	&_swigt__p_char,
24262	<	&_swigt__p_difference_type,
24263	<	&_swigt__p_job_iterator,
24264	<	&_swigt__p_key_type,
24265	<	&_swigt__p_mapped_type,
24266	<	&_swigt__p_p_PyObject,
24267	<	&_swigt__p_size_type,
24268	<	&_swigt__p_std__exception,
24269	<	&_swigt__p_std__invalid_argument,
24270	<	&_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_t_t_t,
24271	<	&_swigt__p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t,
24272	<	&_swigt__p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t__allocator_type,
24273	<	&_swigt__p_std__ostream,
24274	<	&_swigt__p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator,
24275	<	&_swigt__p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t,
24276	<	&_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t,
24277	<	&_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t__const_iterator,
24278	<	&_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t,
24279	<	&_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t__allocator_type,
24280	<	&_swigt__p_swig__PySwigIterator,
24281	<	&_swigt__p_value_type,
24282	<	};
24283	<
24284	<	static swig_cast_info _swigc__p_BossAdministratorSession[] = {  {&_swigt__p_BossAdministratorSession, 0, 0, 0},{0, 0, 0, 0}};
24285	<	static swig_cast_info _swigc__p_BossAttributeContainer[] = {  {&_swigt__p_BossAttributeContainer, 0, 0, 0},{0, 0, 0, 0}};
24286	<	static swig_cast_info _swigc__p_BossDatabase[] = {  {&_swigt__p_BossDatabase, 0, 0, 0},{0, 0, 0, 0}};
24287	<	static swig_cast_info _swigc__p_BossJob[] = {  {&_swigt__p_BossJob, 0, 0, 0},{0, 0, 0, 0}};
24288	<	static swig_cast_info _swigc__p_BossSession[] = {  {&_swigt__p_BossSession, 0, 0, 0},{0, 0, 0, 0}};
24289	<	static swig_cast_info _swigc__p_BossTask[] = {  {&_swigt__p_BossTask, 0, 0, 0},{0, 0, 0, 0}};
24290	<	static swig_cast_info _swigc__p_BossTaskException[] = {  {&_swigt__p_BossTaskException, 0, 0, 0},{0, 0, 0, 0}};
24291	<	static swig_cast_info _swigc__p_XMLDoc[] = {  {&_swigt__p_XMLDoc, 0, 0, 0},{0, 0, 0, 0}};
24292	<	static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
24293	<	static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
24294	<	static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
24295	<	static swig_cast_info _swigc__p_job_iterator[] = {  {&_swigt__p_job_iterator, 0, 0, 0},{0, 0, 0, 0}};
24296	<	static swig_cast_info _swigc__p_key_type[] = {  {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
24297	<	static swig_cast_info _swigc__p_mapped_type[] = {  {&_swigt__p_mapped_type, 0, 0, 0},{0, 0, 0, 0}};
24298	<	static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
24299	<	static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
24300	<	static swig_cast_info _swigc__p_std__exception[] = {  {&_swigt__p_std__exception, 0, 0, 0},  {&_swigt__p_BossTaskException, _p_BossTaskExceptionTo_p_std__exception, 0, 0},{0, 0, 0, 0}};
24301	<	static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
24302	<	static swig_cast_info _swigc__p_std__mapTstd__string_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_t_t_t[] = {  {&_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
24303	<	static swig_cast_info _swigc__p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t[] = {  {&_swigt__p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
24304	<	static swig_cast_info _swigc__p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t__allocator_type[] = {  {&_swigt__p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
24305	<	static swig_cast_info _swigc__p_std__ostream[] = {  {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}};
24306	<	static swig_cast_info _swigc__p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator[] = {  {&_swigt__p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
24307	<	static swig_cast_info _swigc__p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t[] = {  {&_swigt__p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
24308	<	static swig_cast_info _swigc__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t[] = {  {&_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
24309	<	static swig_cast_info _swigc__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t__const_iterator[] = {  {&_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
24310	<	static swig_cast_info _swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t[] = {  {&_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
24311	<	static swig_cast_info _swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTstd__string_std__allocatorTstd__string_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
24312	<	static swig_cast_info _swigc__p_swig__PySwigIterator[] = {  {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
24313	<	static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
24314	<
24315	<	static swig_cast_info *swig_cast_initial[] = {
24316	<	_swigc__p_BossAdministratorSession,
24317	<	_swigc__p_BossAttributeContainer,
24318	<	_swigc__p_BossDatabase,
24319	<	_swigc__p_BossJob,
24320	<	_swigc__p_BossSession,
24321	<	_swigc__p_BossTask,
24322	<	_swigc__p_BossTaskException,
24323	<	_swigc__p_XMLDoc,
24324	<	_swigc__p_allocator_type,
24325	<	_swigc__p_char,
24326	<	_swigc__p_difference_type,
24327	<	_swigc__p_job_iterator,
24328	<	_swigc__p_key_type,
24329	<	_swigc__p_mapped_type,
24330	<	_swigc__p_p_PyObject,
24331	<	_swigc__p_size_type,
24332	<	_swigc__p_std__exception,
24333	<	_swigc__p_std__invalid_argument,
24334	<	_swigc__p_std__mapTstd__string_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_t_t_t,
24335	<	_swigc__p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t,
24336	<	_swigc__p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t__allocator_type,
24337	<	_swigc__p_std__ostream,
24338	<	_swigc__p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator,
24339	<	_swigc__p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t,
24340	<	_swigc__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t,
24341	<	_swigc__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t__const_iterator,
24342	<	_swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t,
24343	<	_swigc__p_std__vectorTstd__string_std__allocatorTstd__string_t_t__allocator_type,
24344	<	_swigc__p_swig__PySwigIterator,
24345	<	_swigc__p_value_type,
6358	>	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6359	>	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}};
6360	>	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}};
6361	>	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}};
6362	>	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}};
6363	>	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6364	>	static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6365	>	static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
6366	>	static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6367	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6368	>	static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6369	>	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6370	>	static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6371	>	static swig_type_info _swigt__p_std__vectorTstd__string_t[] = {{"_p_std__vectorTstd__string_t", 0, "std::vector<std::string > *", 0},{"_p_std__vectorTstd__string_t"},{0}};
6372	>	static swig_type_info _swigt__p_std__mapTstd__string_std__string_t[] = {{"_p_std__mapTstd__string_std__string_t", 0, "std::map<std::string,std::string > *", 0},{"_p_std__mapTstd__string_std__string_t"},{0}};
6373	>	static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
6374	>	static swig_type_info _swigt__p_std__vectorTBossJob_p_t__const_iterator[] = {{"_p_std__vectorTBossJob_p_t__const_iterator", 0, "std::vector<BossJob * >::const_iterator *", 0},{"_p_std__vectorTBossJob_p_t__const_iterator"},{"_p_BossTask__job_iterator"},{0}};
6375	>	static swig_type_info _swigt__p_BossTask__job_iterator[] = {{"_p_BossTask__job_iterator", 0, "BossTask::job_iterator const *", 0},{"_p_BossTask__job_iterator"},{"_p_std__vectorTBossJob_p_t__const_iterator"},{0}};
6376	>	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6377	>
6378	>	static swig_type_info *swig_types_initial[] = {
6379	>	_swigt__p_XMLDoc,
6380	>	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6381	>	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6382	>	_swigt__p_std__vectorTBossTask_p_t,
6383	>	_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6384	>	_swigt__p_std__ostream,
6385	>	_swigt__p_BossTask,
6386	>	_swigt__p_BossTaskException,
6387	>	_swigt__p_printOption,
6388	>	_swigt__p_BossAttributeContainer,
6389	>	_swigt__p_BossJob,
6390	>	_swigt__p_BossDatabase,
6391	>	_swigt__p_BossSession,
6392	>	_swigt__p_std__vectorTstd__string_t,
6393	>	_swigt__p_std__mapTstd__string_std__string_t,
6394	>	_swigt__p_BossAdministratorSession,
6395	>	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6396	>	_swigt__p_BossTask__job_iterator,
6397	>	_swigt__p_jobStates,
6398	>	0
6399		};
6400
6401
6402		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6403
6404		static swig_const_info swig_const_table[] = {
6405	<	{0, 0, 0, 0.0, 0, 0}};
6405	>	{ SWIG_PY_INT,     (char *)"RUNNING", (long) RUNNING, 0, 0, 0},
6406	>	{ SWIG_PY_INT,     (char *)"SCHEDULED", (long) SCHEDULED, 0, 0, 0},
6407	>	{ SWIG_PY_INT,     (char *)"SUBMITTED", (long) SUBMITTED, 0, 0, 0},
6408	>	{ SWIG_PY_INT,     (char *)"ALL", (long) ALL, 0, 0, 0},
6409	>	{ SWIG_PY_INT,     (char *)"STATUS_ONLY", (long) STATUS_ONLY, 0, 0, 0},
6410	>	{ SWIG_PY_INT,     (char *)"NORMAL", (long) NORMAL, 0, 0, 0},
6411	>	{ SWIG_PY_INT,     (char *)"SPECIFIC", (long) SPECIFIC, 0, 0, 0},
6412	>	{ SWIG_PY_INT,     (char *)"PROGRAMS", (long) PROGRAMS, 0, 0, 0},
6413	>	{ SWIG_PY_INT,     (char *)"FULL", (long) FULL, 0, 0, 0},
6414	>	{0}};
6415
6416		#ifdef __cplusplus
6417		}
6418		#endif
24357	–	/* -----------------------------------------------------------------------------
24358	–	* Type initialization:
24359	–	* This problem is tough by the requirement that no dynamic
24360	–	* memory is used. Also, since swig_type_info structures store pointers to
24361	–	* swig_cast_info structures and swig_cast_info structures store pointers back
24362	–	* to swig_type_info structures, we need some lookup code at initialization.
24363	–	* The idea is that swig generates all the structures that are needed.
24364	–	* The runtime then collects these partially filled structures.
24365	–	* The SWIG_InitializeModule function takes these initial arrays out of
24366	–	* swig_module, and does all the lookup, filling in the swig_module.types
24367	–	* array with the correct data and linking the correct swig_cast_info
24368	–	* structures together.
24369	–	*
24370	–	* The generated swig_type_info structures are assigned staticly to an initial
24371	–	* array. We just loop though that array, and handle each type individually.
24372	–	* First we lookup if this type has been already loaded, and if so, use the
24373	–	* loaded structure instead of the generated one. Then we have to fill in the
24374	–	* cast linked list. The cast data is initially stored in something like a
24375	–	* two-dimensional array. Each row corresponds to a type (there are the same
24376	–	* number of rows as there are in the swig_type_initial array). Each entry in
24377	–	* a column is one of the swig_cast_info structures for that type.
24378	–	* The cast_initial array is actually an array of arrays, because each row has
24379	–	* a variable number of columns. So to actually build the cast linked list,
24380	–	* we find the array of casts associated with the type, and loop through it
24381	–	* adding the casts to the list. The one last trick we need to do is making
24382	–	* sure the type pointer in the swig_cast_info struct is correct.
24383	–	*
24384	–	* First off, we lookup the cast->type name to see if it is already loaded.
24385	–	* There are three cases to handle:
24386	–	*  1) If the cast->type has already been loaded AND the type we are adding
24387	–	*     casting info to has not been loaded (it is in this module), THEN we
24388	–	*     replace the cast->type pointer with the type pointer that has already
24389	–	*     been loaded.
24390	–	*  2) If BOTH types (the one we are adding casting info to, and the
24391	–	*     cast->type) are loaded, THEN the cast info has already been loaded by
24392	–	*     the previous module so we just ignore it.
24393	–	*  3) Finally, if cast->type has not already been loaded, then we add that
24394	–	*     swig_cast_info to the linked list (because the cast->type) pointer will
24395	–	*     be correct.
24396	–	* ----------------------------------------------------------------------------- */
6419
6420		#ifdef __cplusplus
6421	<	extern "C" {
24400	<	#if 0
24401	<	} /* c-mode */
24402	<	#endif
24403	<	#endif
24404	<
24405	<	#if 0
24406	<	#define SWIGRUNTIME_DEBUG
24407	<	#endif
24408	<
24409	<	SWIGRUNTIME void
24410	<	SWIG_InitializeModule(void *clientdata) {
24411	<	size_t i;
24412	<	swig_module_info *module_head;
24413	<	static int init_run = 0;
24414	<
24415	<	clientdata = clientdata;
24416	<
24417	<	if (init_run) return;
24418	<	init_run = 1;
24419	<
24420	<	/* Initialize the swig_module */
24421	<	swig_module.type_initial = swig_type_initial;
24422	<	swig_module.cast_initial = swig_cast_initial;
24423	<
24424	<	/* Try and load any already created modules */
24425	<	module_head = SWIG_GetModule(clientdata);
24426	<	if (module_head) {
24427	<	swig_module.next = module_head->next;
24428	<	module_head->next = &swig_module;
24429	<	} else {
24430	<	/* This is the first module loaded */
24431	<	swig_module.next = &swig_module;
24432	<	SWIG_SetModule(clientdata, &swig_module);
24433	<	}
24434	<
24435	<	/* Now work on filling in swig_module.types */
24436	<	#ifdef SWIGRUNTIME_DEBUG
24437	<	printf("SWIG_InitializeModule: size %d\n", swig_module.size);
24438	<	#endif
24439	<	for (i = 0; i < swig_module.size; ++i) {
24440	<	swig_type_info *type = 0;
24441	<	swig_type_info *ret;
24442	<	swig_cast_info *cast;
24443	<
24444	<	#ifdef SWIGRUNTIME_DEBUG
24445	<	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
24446	<	#endif
24447	<
24448	<	/* if there is another module already loaded */
24449	<	if (swig_module.next != &swig_module) {
24450	<	type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
24451	<	}
24452	<	if (type) {
24453	<	/* Overwrite clientdata field */
24454	<	#ifdef SWIGRUNTIME_DEBUG
24455	<	printf("SWIG_InitializeModule: found type %s\n", type->name);
24456	<	#endif
24457	<	if (swig_module.type_initial[i]->clientdata) {
24458	<	type->clientdata = swig_module.type_initial[i]->clientdata;
24459	<	#ifdef SWIGRUNTIME_DEBUG
24460	<	printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
6421	>	extern "C"
6422		#endif
6423	<	}
6424	<	} else {
6425	<	type = swig_module.type_initial[i];
6426	<	}
6423	>	SWIGEXPORT(void) SWIG_init(void) {
6424	>	static PyObject *SWIG_globals = 0;
6425	>	static int       typeinit = 0;
6426	>	PyObject *m, *d;
6427	>	int       i;
6428	>	if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
6429	>	m = Py_InitModule((char *) SWIG_name, SwigMethods);
6430	>	d = PyModule_GetDict(m);
6431
6432	<	/* Insert casting types */
6433	<	cast = swig_module.cast_initial[i];
6434	<	while (cast->type) {
24470	<	/* Don't need to add information already in the list */
24471	<	ret = 0;
24472	<	#ifdef SWIGRUNTIME_DEBUG
24473	<	printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
24474	<	#endif
24475	<	if (swig_module.next != &swig_module) {
24476	<	ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
24477	<	#ifdef SWIGRUNTIME_DEBUG
24478	<	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
24479	<	#endif
24480	<	}
24481	<	if (ret) {
24482	<	if (type == swig_module.type_initial[i]) {
24483	<	#ifdef SWIGRUNTIME_DEBUG
24484	<	printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
24485	<	#endif
24486	<	cast->type = ret;
24487	<	ret = 0;
24488	<	} else {
24489	<	/* Check for casting already in the list */
24490	<	swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
24491	<	#ifdef SWIGRUNTIME_DEBUG
24492	<	if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
24493	<	#endif
24494	<	if (!ocast) ret = 0;
24495	<	}
24496	<	}
24497	<
24498	<	if (!ret) {
24499	<	#ifdef SWIGRUNTIME_DEBUG
24500	<	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
24501	<	#endif
24502	<	if (type->cast) {
24503	<	type->cast->prev = cast;
24504	<	cast->next = type->cast;
24505	<	}
24506	<	type->cast = cast;
24507	<	}
24508	<	cast++;
24509	<	}
24510	<	/* Set entry in modules->types array equal to the type */
24511	<	swig_module.types[i] = type;
24512	<	}
24513	<	swig_module.types[i] = 0;
24514	<
24515	<	#ifdef SWIGRUNTIME_DEBUG
24516	<	printf("**** SWIG_InitializeModule: Cast List ******\n");
24517	<	for (i = 0; i < swig_module.size; ++i) {
24518	<	int j = 0;
24519	<	swig_cast_info *cast = swig_module.cast_initial[i];
24520	<	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
24521	<	while (cast->type) {
24522	<	printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
24523	<	cast++;
24524	<	++j;
24525	<	}
24526	<	printf("---- Total casts: %d\n",j);
24527	<	}
24528	<	printf("**** SWIG_InitializeModule: Cast List ******\n");
24529	<	#endif
24530	<	}
24531	<
24532	<	/* This function will propagate the clientdata field of type to
24533	<	* any new swig_type_info structures that have been added into the list
24534	<	* of equivalent types.  It is like calling
24535	<	* SWIG_TypeClientData(type, clientdata) a second time.
24536	<	*/
24537	<	SWIGRUNTIME void
24538	<	SWIG_PropagateClientData(void) {
24539	<	size_t i;
24540	<	swig_cast_info *equiv;
24541	<	static int init_run = 0;
24542	<
24543	<	if (init_run) return;
24544	<	init_run = 1;
24545	<
24546	<	for (i = 0; i < swig_module.size; i++) {
24547	<	if (swig_module.types[i]->clientdata) {
24548	<	equiv = swig_module.types[i]->cast;
24549	<	while (equiv) {
24550	<	if (!equiv->converter) {
24551	<	if (equiv->type && !equiv->type->clientdata)
24552	<	SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6432	>	if (!typeinit) {
6433	>	for (i = 0; swig_types_initial[i]; i++) {
6434	>	swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
6435		}
6436	<	equiv = equiv->next;
24555	<	}
6436	>	typeinit = 1;
6437		}
6438	<	}
6439	<	}
6440	<
6441	<	#ifdef __cplusplus
6442	<	#if 0
6443	<	{
6444	<	/* c-mode */
6445	<	#endif
6446	<	}
6447	<	#endif
6448	<
6449	<
6450	<
6451	<	#ifdef __cplusplus
6452	<	extern "C" {
6453	<	#endif
6454	<
6455	<	/* Python-specific SWIG API */
24575	<	#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
24576	<	#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
24577	<	#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
24578	<
24579	<	/* -----------------------------------------------------------------------------
24580	<	* global variable support code.
24581	<	* ----------------------------------------------------------------------------- */
24582	<
24583	<	typedef struct swig_globalvar {
24584	<	char       *name;                  /* Name of global variable */
24585	<	PyObject *(*get_attr)(void);       /* Return the current value */
24586	<	int       (*set_attr)(PyObject *); /* Set the value */
24587	<	struct swig_globalvar *next;
24588	<	} swig_globalvar;
24589	<
24590	<	typedef struct swig_varlinkobject {
24591	<	PyObject_HEAD
24592	<	swig_globalvar *vars;
24593	<	} swig_varlinkobject;
24594	<
24595	<	SWIGINTERN PyObject *
24596	<	swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
24597	<	return PyString_FromString("<Swig global variables>");
24598	<	}
24599	<
24600	<	SWIGINTERN PyObject *
24601	<	swig_varlink_str(swig_varlinkobject *v) {
24602	<	PyObject *str = PyString_FromString("(");
24603	<	swig_globalvar  *var;
24604	<	for (var = v->vars; var; var=var->next) {
24605	<	PyString_ConcatAndDel(&str,PyString_FromString(var->name));
24606	<	if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
24607	<	}
24608	<	PyString_ConcatAndDel(&str,PyString_FromString(")"));
24609	<	return str;
24610	<	}
24611	<
24612	<	SWIGINTERN int
24613	<	swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
24614	<	PyObject *str = swig_varlink_str(v);
24615	<	fprintf(fp,"Swig global variables ");
24616	<	fprintf(fp,"%s\n", PyString_AsString(str));
24617	<	Py_DECREF(str);
24618	<	return 0;
24619	<	}
24620	<
24621	<	SWIGINTERN void
24622	<	swig_varlink_dealloc(swig_varlinkobject *v) {
24623	<	swig_globalvar *var = v->vars;
24624	<	while (var) {
24625	<	swig_globalvar *n = var->next;
24626	<	free(var->name);
24627	<	free(var);
24628	<	var = n;
24629	<	}
24630	<	}
24631	<
24632	<	SWIGINTERN PyObject *
24633	<	swig_varlink_getattr(swig_varlinkobject *v, char *n) {
24634	<	PyObject *res = NULL;
24635	<	swig_globalvar *var = v->vars;
24636	<	while (var) {
24637	<	if (strcmp(var->name,n) == 0) {
24638	<	res = (*var->get_attr)();
24639	<	break;
24640	<	}
24641	<	var = var->next;
24642	<	}
24643	<	if (res == NULL && !PyErr_Occurred()) {
24644	<	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
24645	<	}
24646	<	return res;
24647	<	}
24648	<
24649	<	SWIGINTERN int
24650	<	swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
24651	<	int res = 1;
24652	<	swig_globalvar *var = v->vars;
24653	<	while (var) {
24654	<	if (strcmp(var->name,n) == 0) {
24655	<	res = (*var->set_attr)(p);
24656	<	break;
24657	<	}
24658	<	var = var->next;
24659	<	}
24660	<	if (res == 1 && !PyErr_Occurred()) {
24661	<	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
24662	<	}
24663	<	return res;
24664	<	}
24665	<
24666	<	SWIGINTERN PyTypeObject*
24667	<	swig_varlink_type(void) {
24668	<	static char varlink__doc__[] = "Swig var link object";
24669	<	static PyTypeObject varlink_type;
24670	<	static int type_init = 0;
24671	<	if (!type_init) {
24672	<	const PyTypeObject tmp
24673	<	= {
24674	<	PyObject_HEAD_INIT(NULL)
24675	<	0,                                  /* Number of items in variable part (ob_size) */
24676	<	(char *)"swigvarlink",              /* Type name (tp_name) */
24677	<	sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
24678	<	0,                                  /* Itemsize (tp_itemsize) */
24679	<	(destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
24680	<	(printfunc) swig_varlink_print,     /* Print (tp_print) */
24681	<	(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
24682	<	(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
24683	<	0,                                  /* tp_compare */
24684	<	(reprfunc) swig_varlink_repr,       /* tp_repr */
24685	<	0,                                  /* tp_as_number */
24686	<	0,                                  /* tp_as_sequence */
24687	<	0,                                  /* tp_as_mapping */
24688	<	0,                                  /* tp_hash */
24689	<	0,                                  /* tp_call */
24690	<	(reprfunc)swig_varlink_str,        /* tp_str */
24691	<	0,                                  /* tp_getattro */
24692	<	0,                                  /* tp_setattro */
24693	<	0,                                  /* tp_as_buffer */
24694	<	0,                                  /* tp_flags */
24695	<	varlink__doc__,                     /* tp_doc */
24696	<	0,                                  /* tp_traverse */
24697	<	0,                                  /* tp_clear */
24698	<	0,                                  /* tp_richcompare */
24699	<	0,                                  /* tp_weaklistoffset */
24700	<	#if PY_VERSION_HEX >= 0x02020000
24701	<	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
24702	<	#endif
24703	<	#if PY_VERSION_HEX >= 0x02030000
24704	<	0,                                  /* tp_del */
24705	<	#endif
24706	<	#ifdef COUNT_ALLOCS
24707	<	0,0,0,0                             /* tp_alloc -> tp_next */
24708	<	#endif
24709	<	};
24710	<	varlink_type = tmp;
24711	<	varlink_type.ob_type = &PyType_Type;
24712	<	type_init = 1;
24713	<	}
24714	<	return &varlink_type;
24715	<	}
24716	<
24717	<	/* Create a variable linking object for use later */
24718	<	SWIGINTERN PyObject *
24719	<	SWIG_Python_newvarlink(void) {
24720	<	swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
24721	<	if (result) {
24722	<	result->vars = 0;
24723	<	}
24724	<	return ((PyObject*) result);
24725	<	}
24726	<
24727	<	SWIGINTERN void
24728	<	SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
24729	<	swig_varlinkobject *v = (swig_varlinkobject *) p;
24730	<	swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
24731	<	if (gv) {
24732	<	size_t size = strlen(name)+1;
24733	<	gv->name = (char *)malloc(size);
24734	<	if (gv->name) {
24735	<	strncpy(gv->name,name,size);
24736	<	gv->get_attr = get_attr;
24737	<	gv->set_attr = set_attr;
24738	<	gv->next = v->vars;
24739	<	}
24740	<	}
24741	<	v->vars = gv;
24742	<	}
24743	<
24744	<	SWIGINTERN PyObject *
24745	<	SWIG_globals() {
24746	<	static PyObject *_SWIG_globals = 0;
24747	<	if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
24748	<	return _SWIG_globals;
24749	<	}
24750	<
24751	<	/* -----------------------------------------------------------------------------
24752	<	* constants/methods manipulation
24753	<	* ----------------------------------------------------------------------------- */
24754	<
24755	<	/* Install Constants */
24756	<	SWIGINTERN void
24757	<	SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
24758	<	PyObject *obj = 0;
24759	<	size_t i;
24760	<	for (i = 0; constants[i].type; ++i) {
24761	<	switch(constants[i].type) {
24762	<	case SWIG_PY_POINTER:
24763	<	obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
24764	<	break;
24765	<	case SWIG_PY_BINARY:
24766	<	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
24767	<	break;
24768	<	default:
24769	<	obj = 0;
24770	<	break;
24771	<	}
24772	<	if (obj) {
24773	<	PyDict_SetItemString(d, constants[i].name, obj);
24774	<	Py_DECREF(obj);
24775	<	}
24776	<	}
24777	<	}
24778	<
24779	<	/* -----------------------------------------------------------------------------*/
24780	<	/* Fix SwigMethods to carry the callback ptrs when needed */
24781	<	/* -----------------------------------------------------------------------------*/
24782	<
24783	<	SWIGINTERN void
24784	<	SWIG_Python_FixMethods(PyMethodDef *methods,
24785	<	swig_const_info *const_table,
24786	<	swig_type_info **types,
24787	<	swig_type_info **types_initial) {
24788	<	size_t i;
24789	<	for (i = 0; methods[i].ml_name; ++i) {
24790	<	char *c = methods[i].ml_doc;
24791	<	if (c && (c = strstr(c, "swig_ptr: "))) {
24792	<	int j;
24793	<	swig_const_info *ci = 0;
24794	<	char *name = c + 10;
24795	<	for (j = 0; const_table[j].type; ++j) {
24796	<	if (strncmp(const_table[j].name, name,
24797	<	strlen(const_table[j].name)) == 0) {
24798	<	ci = &(const_table[j]);
24799	<	break;
24800	<	}
24801	<	}
24802	<	if (ci) {
24803	<	size_t shift = (ci->ptype) - types;
24804	<	swig_type_info *ty = types_initial[shift];
24805	<	size_t ldoc = (c - methods[i].ml_doc);
24806	<	size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
24807	<	char *ndoc = (char*)malloc(ldoc + lptr + 10);
24808	<	if (ndoc) {
24809	<	char *buff = ndoc;
24810	<	void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
24811	<	if (ptr) {
24812	<	strncpy(buff, methods[i].ml_doc, ldoc);
24813	<	buff += ldoc;
24814	<	strncpy(buff, "swig_ptr: ", 10);
24815	<	buff += 10;
24816	<	SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
24817	<	methods[i].ml_doc = ndoc;
24818	<	}
24819	<	}
24820	<	}
24821	<	}
24822	<	}
24823	<	}
24824	<
24825	<	#ifdef __cplusplus
24826	<	}
24827	<	#endif
24828	<
24829	<	/* -----------------------------------------------------------------------------*
24830	<	*  Partial Init method
24831	<	* -----------------------------------------------------------------------------*/
24832	<
24833	<	#ifdef __cplusplus
24834	<	extern "C"
24835	<	#endif
24836	<	SWIGEXPORT void SWIG_init(void) {
24837	<	PyObject *m, *d;
24838	<
24839	<	/* Fix SwigMethods to carry the callback ptrs when needed */
24840	<	SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
24841	<
24842	<	m = Py_InitModule((char *) SWIG_name, SwigMethods);
24843	<	d = PyModule_GetDict(m);
24844	<
24845	<	SWIG_InitializeModule(0);
24846	<	SWIG_InstallConstants(d,swig_const_table);
24847	<
24848	<
24849	<	SWIG_Python_SetConstant(d, "RUNNING",SWIG_From_int(static_cast< int >(RUNNING)));
24850	<	SWIG_Python_SetConstant(d, "SCHEDULED",SWIG_From_int(static_cast< int >(SCHEDULED)));
24851	<	SWIG_Python_SetConstant(d, "SUBMITTED",SWIG_From_int(static_cast< int >(SUBMITTED)));
24852	<	SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(ALL)));
24853	<	SWIG_Python_SetConstant(d, "STATUS_ONLY",SWIG_From_int(static_cast< int >(STATUS_ONLY)));
24854	<	SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(NORMAL)));
24855	<	SWIG_Python_SetConstant(d, "SPECIFIC",SWIG_From_int(static_cast< int >(SPECIFIC)));
24856	<	SWIG_Python_SetConstant(d, "PROGRAMS",SWIG_From_int(static_cast< int >(PROGRAMS)));
24857	<	SWIG_Python_SetConstant(d, "FULL",SWIG_From_int(static_cast< int >(FULL)));
6438	>	SWIG_InstallConstants(d,swig_const_table);
6439	>
6440	>
6441	>	// define custom exceptions
6442	>	PyObject *e;
6443	>	PyMethodDef tp_methods = {
6444	>	NULL, NULL, 0, NULL
6445	>	};
6446	>	e = Py_InitModule("BossSession", &tp_methods);
6447	>	// generic BOSS exception
6448	>	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6449	>	Py_INCREF(BossError);
6450	>	PyModule_AddObject(e, "BossError", BossError);
6451	>	// scheduler interaction BOSS exception
6452	>	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6453	>	Py_INCREF(SchedulerError);
6454	>	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6455	>
6456		}
6457

Diff Legend

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