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.21 by gcodispo, Tue Feb 20 09:57:08 2007 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);
223	<	}
224	<	}
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);
556	<	}
557	<	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];
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		}
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];
609	–	}
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;
226		}
227	+	equiv = equiv->next;
228		}
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
235		#endif
236
237	<	/* A crude PyExc_StopIteration exception for old Pythons */
238	<	#if PY_VERSION_HEX < 0x02020000
239	<	# ifndef PyExc_StopIteration
240	<	#  define PyExc_StopIteration PyExc_RuntimeError
241	<	# endif
242	<	# ifndef PyObject_GenericGetAttr
243	<	#  define PyObject_GenericGetAttr 0
244	<	# endif
245	<	#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
770	<	#endif
771	<
772	<
773	<	/* 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
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	<	/* -----------------------------------------------------------------------------
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 */
251		#endif
946	–	#endif
947	–
948	–	/* -----------------------------------------------------------------------------
949	–	* Constant declarations
950	–	* ----------------------------------------------------------------------------- */
252
253	<	/* 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;
965	<
966	<	#ifdef __cplusplus
967	<	#if 0
968	<	{ /* cc-mode */
969	<	#endif
970	<	}
971	<	#endif
972	<
259	>	/* Flags for pointer conversion */
260
261	<	/* -----------------------------------------------------------------------------
262	<	* See the LICENSE file for information on copyright, usage and redistribution
976	<	* of SWIG, and the README file for authors - http://www.swig.org/release.html.
977	<	*
978	<	* pyrun.swg
979	<	*
980	<	* This file contains the runtime support for Python modules
981	<	* and includes code for managing global variables and pointer
982	<	* 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)
261	>	#define SWIG_POINTER_EXCEPTION     0x1
262	>	#define SWIG_POINTER_DISOWN        0x2
263
264	<	#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
265	<	#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
264	>	/* Exception handling in wrappers */
265	>	#define SWIG_fail   goto fail
266
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	<	/* 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	<	}
1140	<
1141	<	/* 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	<	}
1346	<
1347	<	SWIGRUNTIME PyObject *
1348	<	#ifdef METH_NOARGS
1349	<	PySwigObject_repr(PySwigObject *v)
1350	<	#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	<	}
303	>	swig_globalvar *vars;
304	>	} swig_varlinkobject;
305
306	<	SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
307	<
308	<	SWIGRUNTIME PyTypeObject*
309	<	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);
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	<	PySwigObject_append(PyObject* v, PyObject* next)
314	<	{
315	<	PySwigObject *sobj = (PySwigObject *) v;
316	<	#ifndef METH_O
317	<	PyObject *tmp = 0;
318	<	if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
319	<	next = tmp;
1461	<	#endif
1462	<	if (!PySwigObject_Check(next)) {
1463	<	return NULL;
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	<	sobj->next = next;
322	<	Py_INCREF(next);
1467	<	return SWIG_Py_Void();
1468	<	}
1469	<
1470	<	SWIGRUNTIME PyObject*
1471	<	#ifdef METH_NOARGS
1472	<	PySwigObject_next(PyObject* v)
1473	<	#else
1474	<	PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475	<	#endif
1476	<	{
1477	<	PySwigObject *sobj = (PySwigObject *) v;
1478	<	if (sobj->next) {
1479	<	Py_INCREF(sobj->next);
1480	<	return sobj->next;
1481	<	} else {
1482	<	return SWIG_Py_Void();
1483	<	}
1484	<	}
1485	<
1486	<	SWIGINTERN PyObject*
1487	<	#ifdef METH_NOARGS
1488	<	PySwigObject_disown(PyObject *v)
1489	<	#else
1490	<	PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491	<	#endif
1492	<	{
1493	<	PySwigObject *sobj = (PySwigObject *)v;
1494	<	sobj->own = 0;
1495	<	return SWIG_Py_Void();
1496	<	}
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();
321	>	fprintf(fp," }\n");
322	>	return 0;
323		}
324
325	<	SWIGINTERN PyObject*
326	<	PySwigObject_own(PyObject *v, PyObject *args)
327	<	{
328	<	PyObject *val = 0;
329	<	#if (PY_VERSION_HEX < 0x02020000)
330	<	if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
331	<	#else
332	<	if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
333	<	#endif
334	<	{
335	<	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}
348	<	};
349	<	#else
350	<	static PyMethodDef
351	<	swigobject_methods[] = {
352	<	{(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
353	<	{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
354	<	{(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
355	<	{(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
356	<	{(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
357	<	{(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
358	<	{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		};
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	–	}
504
505	<	/* Convert a pointer value */
506	<
507	<	SWIGRUNTIME int
508	<	SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965	<	if (!obj) return SWIG_ERROR;
1966	<	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);
539	>	tc = SWIG_TypeCheck(c,ty);
540	>	if (!tc) goto type_error;
541		}
542	<	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;
2136	<	}
2137	<	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;
2369	–	}
2370	–	}
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;
594		}
595	+	return robj;
596		}
597
598	<	SWIGRUNTIMEINLINE const char *
599	<	PySwigObject_GetDesc(PyObject *self)
600	<	{
601	<	PySwigObject *v = (PySwigObject *)self;
602	<	swig_type_info *ty = v ? v->ty : 0;
603	<	return ty ? ty->str : (char*)"";
604	<	}
605	<
606	<	SWIGRUNTIME void
2394	<	SWIG_Python_TypeError(const char *type, PyObject *obj)
2395	<	{
2396	<	if (type) {
2397	<	#if defined(SWIG_COBJECT_TYPES)
2398	<	if (obj && PySwigObject_Check(obj)) {
2399	<	const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400	<	if (otype) {
2401	<	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,unsigned int timeout,bool keepfile){
961		std::vector<std::string> my_vec = self->listMatch( scheduler,
962		schclassad,
963		keepfile,
964		taskid,
965	<	jobid);
965	>	jobid,
966	>	timeout);
967		return BossSession_show( self, my_vec );
968		}
969	<	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){
969	>	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,unsigned int timeout,bool avoidCheck){
970		if ( !avoidCheck ) {
971		self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
972	<	type, user, after, before);
972	>	type, user, after, before, timeout );
973		}
974		PyObject * job_dict = PyList_New(0);
975		std::vector <std::string>
#	Line 4586 | Line 978 | SWIGINTERN PyObject *BossSession_queryTa
978		it!= taskList.end(); ++it ) {
979		PyList_Append( job_dict,  PyString_FromString(it->c_str() ) );
980		}
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	–	//       }
981		return  job_dict;
982		}
983	<
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){
983	>	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
984		std::string tmp;
985		BossAttributeContainer::const_iterator it_end = obj.end ();
986		for (BossAttributeContainer::const_iterator it = obj.begin ();
#	Line 4636 | Line 995 | SWIGINTERN PyObject *BossTask_appendToPy
995		}
996		return dict;
997		}
998	<	SWIGINTERN PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator &jit){
998	>	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
999
1000		PyObject * job_dict = PyDict_New();
1001		std::string tmp;
#	Line 4658 | Line 1017 | SWIGINTERN PyObject *BossTask_jobDict(Bo
1017		}
1018		return job_dict;
1019		}
1020	<	SWIGINTERN PyObject *BossTask_jobsDict(BossTask const *self){
1020	>	PyObject *BossTask_jobsDict(BossTask *self){
1021
1022		PyObject * job_dict = PyDict_New();
1023	+	if ( self->job_begin () == self->job_end ()) self->load(ALL);
1024		for (BossTask::job_iterator jit = self->job_begin ();
1025		jit != self->job_end (); ++jit) {
1026		std::string id = (*jit)->chainId();
#	Line 4670 | Line 1030 | SWIGINTERN PyObject *BossTask_jobsDict(B
1030		}
1031		return job_dict;
1032		}
1033	<	SWIGINTERN PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >::const_iterator &programs_it){
1033	>	PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator &programs_it){
1034
1035		PyObject * job_dict = PyDict_New();
1036
#	Line 4694 | Line 1054 | SWIGINTERN PyObject *BossTask_progDict(B
1054		}
1055		return job_dict;
1056		}
1057	<	SWIGINTERN PyObject *BossTask_jobPrograms(BossTask const *self,std::string const &jobid){
1057	>	PyObject *BossTask_jobPrograms(BossTask const *self,std::string const &jobid){
1058
1059		const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1060		std::map< std::string, std::map< std::string, std::string > > ret_val;
#	Line 4720 | Line 1080 | SWIGINTERN PyObject *BossTask_jobProgram
1080		#ifdef __cplusplus
1081		extern "C" {
1082		#endif
1083	<	SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1084	<	PyObject *resultobj = 0;
1085	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1086	<	void *argp1 = 0 ;
1087	<	int res1 = 0 ;
1088	<	PyObject * obj0 = 0 ;
1089	<
1090	<	if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
1091	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
1092	<	if (!SWIG_IsOK(res1)) {
1093	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1094	<	}
1095	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
1096	<	{
1097	<	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;
1083	>	static PyObject *_wrap_new_objectMap__SWIG_0(PyObject *self, PyObject *args) {
1084	>	PyObject *resultobj;
1085	>	std::map<std::string,std::string > *result;
1086	>
1087	>	if(!PyArg_ParseTuple(args,(char *)":new_objectMap")) goto fail;
1088	>	{
1089	>	try {
1090	>	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1091	>
1092	>	}catch (const BossSchedFailure & e) {
1093	>	PyErr_SetString ( SchedulerError, e.what() );
1094	>	return NULL;
1095	>	}catch (const std::exception& e) {
1096	>	PyErr_SetString ( BossError, e.what() );
1097	>	return NULL;
1098		}
4776	–	}
4777	–
4778	–	} catch (const std::exception& e) {
4779	–	SWIG_exception(SWIG_RuntimeError, e.what());
1099		}
1100	<	}
1101	<	resultobj = result;
1102	<	return resultobj;
1103	<	fail:
4785	<	return NULL;
1100	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
1101	>	return resultobj;
1102	>	fail:
1103	>	return NULL;
1104		}
1105
1106
1107	<	SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1108	<	PyObject *resultobj = 0;
1109	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1110	<	size_t arg2 ;
1111	<	swig::PySwigIterator *result = 0 ;
1112	<	void *argp1 = 0 ;
1113	<	int res1 = 0 ;
1114	<	size_t val2 ;
1115	<	int ecode2 = 0 ;
1116	<	PyObject * obj0 = 0 ;
1117	<	PyObject * obj1 = 0 ;
1118	<
1119	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
1120	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1121	<	if (!SWIG_IsOK(res1)) {
1122	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1123	<	}
1124	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
1125	<	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
1126	<	if (!SWIG_IsOK(ecode2)) {
1127	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
1128	<	}
1129	<	arg2 = static_cast< size_t >(val2);
1130	<	{
1131	<	try {
1132	<	try {
1133	<	result = (swig::PySwigIterator *)(arg1)->incr(arg2);
1134	<	}
1135	<	catch(swig::stop_iteration &_e) {
1136	<	{
1137	<	(void)_e;
1138	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
1139	<	SWIG_fail;
1107	>	static PyObject *_wrap_new_objectMap__SWIG_1(PyObject *self, PyObject *args) {
1108	>	PyObject *resultobj;
1109	>	std::map<std::string,std::string > *arg1 = 0 ;
1110	>	std::map<std::string,std::string > *result;
1111	>	std::map<std::string,std::string > temp1 ;
1112	>	std::map<std::string,std::string > *m1 ;
1113	>	PyObject * obj0 = 0 ;
1114	>
1115	>	if(!PyArg_ParseTuple(args,(char *)"O:new_objectMap",&obj0)) goto fail;
1116	>	{
1117	>	if (PyDict_Check(obj0)) {
1118	>	PyObject* items = PyMapping_Items(obj0);
1119	>	unsigned int size = PyList_Size(items);
1120	>	temp1 = std::map<std::string,std::string >();
1121	>	arg1 = &temp1;
1122	>	for (unsigned int i=0; i<size; i++) {
1123	>	PyObject* pair = PySequence_GetItem(items,i);
1124	>	PyObject* key = PySequence_GetItem(pair,0);
1125	>	PyObject* o = PySequence_GetItem(pair,1);
1126	>	if (PyString_Check(key) && PyString_Check(o)) {
1127	>	temp1[SwigString_AsString(key)] = SwigString_AsString(o);
1128	>	Py_DECREF(key);
1129	>	Py_DECREF(o);
1130	>	Py_DECREF(pair);
1131	>	}else {
1132	>	Py_DECREF(key);
1133	>	Py_DECREF(o);
1134	>	Py_DECREF(pair);
1135	>	Py_DECREF(items);
1136	>	PyErr_SetString(PyExc_TypeError,
1137	>	"map<""std::string"",""std::string""> expected");
1138	>	SWIG_fail;
1139	>	}
1140	>	}
1141	>	Py_DECREF(items);
1142	>	}else if (SWIG_ConvertPtr(obj0,(void **) &m1,
1143	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
1144	>	arg1 = m1;
1145	>	}else {
1146	>	PyErr_SetString(PyExc_TypeError,
1147	>	"map<""std::string"",""std::string""> expected");
1148	>	SWIG_fail;
1149		}
4823	–	}
4824	–
4825	–	} catch (const std::exception& e) {
4826	–	SWIG_exception(SWIG_RuntimeError, e.what());
1150		}
1151	<	}
1152	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1153	<	return resultobj;
1154	<	fail:
1155	<	return NULL;
1156	<	}
1157	<
1158	<
1159	<	SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1160	<	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;
1151	>	{
1152	>	try {
1153	>	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1154	>
1155	>	}catch (const BossSchedFailure & e) {
1156	>	PyErr_SetString ( SchedulerError, e.what() );
1157	>	return NULL;
1158	>	}catch (const std::exception& e) {
1159	>	PyErr_SetString ( BossError, e.what() );
1160	>	return NULL;
1161		}
4861	–	}
4862	–
4863	–	} catch (const std::exception& e) {
4864	–	SWIG_exception(SWIG_RuntimeError, e.what());
1162		}
1163	<	}
1164	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1165	<	return resultobj;
1166	<	fail:
4870	<	return NULL;
1163	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
1164	>	return resultobj;
1165	>	fail:
1166	>	return NULL;
1167		}
1168
1169
1170	<	SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
1171	<	int argc;
1172	<	PyObject *argv[3];
1173	<	int ii;
1174	<
1175	<	if (!PyTuple_Check(args)) SWIG_fail;
1176	<	argc = PyObject_Length(args);
1177	<	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);
1170	>	static PyObject *_wrap_new_objectMap(PyObject *self, PyObject *args) {
1171	>	int argc;
1172	>	PyObject *argv[2];
1173	>	int ii;
1174	>
1175	>	argc = PyObject_Length(args);
1176	>	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1177	>	argv[ii] = PyTuple_GetItem(args,ii);
1178		}
1179	<	}
1180	<	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	<	}
1179	>	if (argc == 0) {
1180	>	return _wrap_new_objectMap__SWIG_0(self,args);
1181		}
1182	<	}
1183	<
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) {
1182	>	if (argc == 1) {
1183	>	int _v;
1184		{
1185	<	(void)_e;
1186	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
1187	<	SWIG_fail;
1185	>	/* native sequence? */
1186	>	if (PyDict_Check(argv[0])) {
1187	>	PyObject* items = PyMapping_Items(argv[0]);
1188	>	unsigned int size = PyList_Size(items);
1189	>	if (size == 0) {
1190	>	/* an empty dictionary can be of any type */
1191	>	_v = 1;
1192	>	}else {
1193	>	/* check the first element only */
1194	>	PyObject* pair = PySequence_GetItem(items,0);
1195	>	PyObject* key = PySequence_GetItem(pair,0);
1196	>	PyObject* o = PySequence_GetItem(pair,1);
1197	>	if (PyString_Check(key) && PyString_Check(o))
1198	>	_v = 1;
1199	>	else
1200	>	_v = 0;
1201	>	Py_DECREF(key);
1202	>	Py_DECREF(o);
1203	>	Py_DECREF(pair);
1204	>	}
1205	>	Py_DECREF(items);
1206	>	}else {
1207	>	/* wrapped map? */
1208	>	std::map<std::string,std::string >* m;
1209	>	if (SWIG_ConvertPtr(argv[0],(void **) &m,
1210	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1)
1211	>	_v = 1;
1212	>	else
1213	>	_v = 0;
1214	>	}
1215		}
1216	<	}
1217	<
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;
1216	>	if (_v) {
1217	>	return _wrap_new_objectMap__SWIG_1(self,args);
1218		}
5186	–	}
5187	–
5188	–	} catch (const std::exception& e) {
5189	–	SWIG_exception(SWIG_RuntimeError, e.what());
1219		}
1220	<	}
1221	<	resultobj = result;
1222	<	return resultobj;
5194	<	fail:
5195	<	return NULL;
1220	>
1221	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_objectMap'");
1222	>	return NULL;
1223		}
1224
1225
1226	<	SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1227	<	PyObject *resultobj = 0;
1228	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1229	<	PyObject *result = 0 ;
1230	<	void *argp1 = 0 ;
1231	<	int res1 = 0 ;
1232	<	PyObject * obj0 = 0 ;
1233	<
1234	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
1235	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1236	<	if (!SWIG_IsOK(res1)) {
1237	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1238	<	}
1239	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
1240	<	{
1241	<	try {
1242	<	try {
1243	<	result = (PyObject *)(arg1)->previous();
1244	<	}
1245	<	catch(swig::stop_iteration &_e) {
1246	<	{
1247	<	(void)_e;
1248	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
1249	<	SWIG_fail;
1226	>	static PyObject *_wrap_objectMap___len__(PyObject *self, PyObject *args) {
1227	>	PyObject *resultobj;
1228	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1229	>	unsigned int result;
1230	>	std::map<std::string,std::string > temp1 ;
1231	>	std::map<std::string,std::string > *m1 ;
1232	>	PyObject * obj0 = 0 ;
1233	>
1234	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___len__",&obj0)) goto fail;
1235	>	{
1236	>	if (PyDict_Check(obj0)) {
1237	>	PyObject* items = PyMapping_Items(obj0);
1238	>	unsigned int size = PyList_Size(items);
1239	>	temp1 = std::map<std::string,std::string >();
1240	>	arg1 = &temp1;
1241	>	for (unsigned int i=0; i<size; i++) {
1242	>	PyObject* pair = PySequence_GetItem(items,i);
1243	>	PyObject* key = PySequence_GetItem(pair,0);
1244	>	PyObject* o = PySequence_GetItem(pair,1);
1245	>	if (PyString_Check(key) && PyString_Check(o)) {
1246	>	temp1[SwigString_AsString(key)] = SwigString_AsString(o);
1247	>	Py_DECREF(key);
1248	>	Py_DECREF(o);
1249	>	Py_DECREF(pair);
1250	>	}else {
1251	>	Py_DECREF(key);
1252	>	Py_DECREF(o);
1253	>	Py_DECREF(pair);
1254	>	Py_DECREF(items);
1255	>	PyErr_SetString(PyExc_TypeError,
1256	>	"map<""std::string"",""std::string""> expected");
1257	>	SWIG_fail;
1258	>	}
1259	>	}
1260	>	Py_DECREF(items);
1261	>	}else if (SWIG_ConvertPtr(obj0,(void **) &m1,
1262	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
1263	>	arg1 = m1;
1264	>	}else {
1265	>	PyErr_SetString(PyExc_TypeError,
1266	>	"map<""std::string"",""std::string""> expected");
1267	>	SWIG_fail;
1268		}
5224	–	}
5225	–
5226	–	} catch (const std::exception& e) {
5227	–	SWIG_exception(SWIG_RuntimeError, e.what());
1269		}
1270	<	}
1271	<	resultobj = result;
1272	<	return resultobj;
1273	<	fail:
1274	<	return NULL;
1275	<	}
1276	<
1277	<
1278	<	SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1279	<	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;
1270	>	{
1271	>	try {
1272	>	result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1273	>
1274	>	}catch (const BossSchedFailure & e) {
1275	>	PyErr_SetString ( SchedulerError, e.what() );
1276	>	return NULL;
1277	>	}catch (const std::exception& e) {
1278	>	PyErr_SetString ( BossError, e.what() );
1279	>	return NULL;
1280		}
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());
1281		}
1282	<	}
1283	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
1284	<	return resultobj;
1285	<	fail:
5360	<	return NULL;
1282	>	resultobj = PyInt_FromLong((long)result);
1283	>	return resultobj;
1284	>	fail:
1285	>	return NULL;
1286		}
1287
1288
1289	<	SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1290	<	PyObject *resultobj = 0;
1291	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1292	<	ptrdiff_t arg2 ;
1293	<	swig::PySwigIterator *result = 0 ;
1294	<	void *argp1 = 0 ;
1295	<	int res1 = 0 ;
1296	<	ptrdiff_t val2 ;
1297	<	int ecode2 = 0 ;
1298	<	PyObject * obj0 = 0 ;
1299	<	PyObject * obj1 = 0 ;
1300	<
1301	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
1302	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
1303	<	if (!SWIG_IsOK(res1)) {
1304	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1305	<	}
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;
1289	>	static PyObject *_wrap_objectMap_clear(PyObject *self, PyObject *args) {
1290	>	PyObject *resultobj;
1291	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1292	>	PyObject * obj0 = 0 ;
1293	>
1294	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_clear",&obj0)) goto fail;
1295	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1296	>	{
1297	>	try {
1298	>	(arg1)->clear();
1299	>
1300	>	}catch (const BossSchedFailure & e) {
1301	>	PyErr_SetString ( SchedulerError, e.what() );
1302	>	return NULL;
1303	>	}catch (const std::exception& e) {
1304	>	PyErr_SetString ( BossError, e.what() );
1305	>	return NULL;
1306		}
5401	–	}
5402	–
5403	–	} catch (const std::exception& e) {
5404	–	SWIG_exception(SWIG_RuntimeError, e.what());
1307		}
1308	<	}
1309	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
1310	<	return resultobj;
1311	<	fail:
5410	<	return NULL;
1308	>	Py_INCREF(Py_None); resultobj = Py_None;
1309	>	return resultobj;
1310	>	fail:
1311	>	return NULL;
1312		}
1313
1314
1315	<	SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1316	<	PyObject *resultobj = 0;
1317	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1318	<	ptrdiff_t arg2 ;
1319	<	swig::PySwigIterator *result = 0 ;
1320	<	void *argp1 = 0 ;
1321	<	int res1 = 0 ;
1322	<	ptrdiff_t val2 ;
1323	<	int ecode2 = 0 ;
1324	<	PyObject * obj0 = 0 ;
1325	<	PyObject * obj1 = 0 ;
1326	<
1327	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
1328	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
1329	<	if (!SWIG_IsOK(res1)) {
1330	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1331	<	}
1332	<	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;
1315	>	static PyObject *_wrap_objectMap___nonzero__(PyObject *self, PyObject *args) {
1316	>	PyObject *resultobj;
1317	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1318	>	bool result;
1319	>	PyObject * obj0 = 0 ;
1320	>
1321	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___nonzero__",&obj0)) goto fail;
1322	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1323	>	{
1324	>	try {
1325	>	result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1326	>
1327	>	}catch (const BossSchedFailure & e) {
1328	>	PyErr_SetString ( SchedulerError, e.what() );
1329	>	return NULL;
1330	>	}catch (const std::exception& e) {
1331	>	PyErr_SetString ( BossError, e.what() );
1332	>	return NULL;
1333		}
5451	–	}
5452	–
5453	–	} catch (const std::exception& e) {
5454	–	SWIG_exception(SWIG_RuntimeError, e.what());
1334		}
1335	<	}
1336	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
1337	<	return resultobj;
1338	<	fail:
5460	<	return NULL;
1335	>	resultobj = PyInt_FromLong((long)result);
1336	>	return resultobj;
1337	>	fail:
1338	>	return NULL;
1339		}
1340
1341
1342	<	SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1343	<	PyObject *resultobj = 0;
1344	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1345	<	ptrdiff_t arg2 ;
1346	<	swig::PySwigIterator *result = 0 ;
1347	<	void *argp1 = 0 ;
1348	<	int res1 = 0 ;
1349	<	ptrdiff_t val2 ;
1350	<	int ecode2 = 0 ;
1351	<	PyObject * obj0 = 0 ;
1352	<	PyObject * obj1 = 0 ;
1353	<
1354	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
1355	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1356	<	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());
1342	>	static PyObject *_wrap_objectMap___getitem__(PyObject *self, PyObject *args) {
1343	>	PyObject *resultobj;
1344	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1345	>	std::string arg2 ;
1346	>	std::string result;
1347	>	PyObject * obj0 = 0 ;
1348	>	PyObject * obj1 = 0 ;
1349	>
1350	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___getitem__",&obj0,&obj1)) goto fail;
1351	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1352	>	{
1353	>	if (PyString_Check(obj1))
1354	>	arg2 = std::string(PyString_AsString(obj1));
1355	>	else
1356	>	SWIG_exception(SWIG_TypeError, "string expected");
1357		}
1358	<	}
1359	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
1360	<	return resultobj;
1361	<	fail:
1362	<	return NULL;
1363	<	}
1364	<
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;
1358	>	{
1359	>	try {
1360	>	result = std_maplstd_stringcstd_string_g___getitem_____(arg1,arg2);
1361	>
1362	>	}catch (std::out_of_range& e) {
1363	>	PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
1364	>	SWIG_fail;
1365		}
5545	–	}
5546	–
5547	–	} catch (const std::exception& e) {
5548	–	SWIG_exception(SWIG_RuntimeError, e.what());
1366		}
1367	<	}
1368	<	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 &""'");
5872	<	}
5873	<	if (!ptr) {
5874	<	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());
1367	>	{
1368	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1369		}
1370	<	}
1371	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
1372	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6387	<	return resultobj;
6388	<	fail:
6389	<	return NULL;
1370	>	return resultobj;
1371	>	fail:
1372	>	return NULL;
1373		}
1374
1375
1376	<	SWIGINTERN PyObject *_wrap_objectMap_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1377	<	PyObject *resultobj = 0;
1378	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1379	<	std::map<std::string,std::string >::const_iterator result;
1380	<	void *argp1 = 0 ;
1381	<	int res1 = 0 ;
1382	<	PyObject * obj0 = 0 ;
1383	<
1384	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_begin",&obj0)) SWIG_fail;
1385	<	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 );
1386	<	if (!SWIG_IsOK(res1)) {
1387	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_begin" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
1388	<	}
1389	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1390	<	{
1391	<	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());
1376	>	static PyObject *_wrap_objectMap___setitem__(PyObject *self, PyObject *args) {
1377	>	PyObject *resultobj;
1378	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1379	>	std::string arg2 ;
1380	>	std::string arg3 ;
1381	>	PyObject * obj0 = 0 ;
1382	>	PyObject * obj1 = 0 ;
1383	>	PyObject * obj2 = 0 ;
1384	>
1385	>	if(!PyArg_ParseTuple(args,(char *)"OOO:objectMap___setitem__",&obj0,&obj1,&obj2)) goto fail;
1386	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1387	>	{
1388	>	if (PyString_Check(obj1))
1389	>	arg2 = std::string(PyString_AsString(obj1));
1390	>	else
1391	>	SWIG_exception(SWIG_TypeError, "string expected");
1392		}
1393	<	}
1394	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
1395	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1396	<	return resultobj;
1397	<	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);
1393	>	{
1394	>	if (PyString_Check(obj2))
1395	>	arg3 = std::string(PyString_AsString(obj2));
1396	>	else
1397	>	SWIG_exception(SWIG_TypeError, "string expected");
1398		}
1399	<	}
1400	<	if (argc == 1) {
1401	<	int _v;
1402	<	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));
1403	<	_v = SWIG_CheckState(res);
1404	<	if (_v) {
1405	<	return _wrap_objectMap_begin__SWIG_1(self, args);
1399	>	{
1400	>	try {
1401	>	std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1402	>
1403	>	}catch (const BossSchedFailure & e) {
1404	>	PyErr_SetString ( SchedulerError, e.what() );
1405	>	return NULL;
1406	>	}catch (const std::exception& e) {
1407	>	PyErr_SetString ( BossError, e.what() );
1408	>	return NULL;
1409	>	}
1410		}
1411	<	}
1412	<
1413	<	fail:
1414	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_begin'");
6451	<	return NULL;
1411	>	Py_INCREF(Py_None); resultobj = Py_None;
1412	>	return resultobj;
1413	>	fail:
1414	>	return NULL;
1415		}
1416
1417
1418	<	SWIGINTERN PyObject *_wrap_objectMap_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1419	<	PyObject *resultobj = 0;
1420	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1421	<	std::map<std::string,std::string >::iterator result;
1422	<	void *argp1 = 0 ;
1423	<	int res1 = 0 ;
1424	<	PyObject * obj0 = 0 ;
1425	<
1426	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_end",&obj0)) SWIG_fail;
1427	<	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 );
1428	<	if (!SWIG_IsOK(res1)) {
1429	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_end" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1430	<	}
1431	<	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());
1418	>	static PyObject *_wrap_objectMap___delitem__(PyObject *self, PyObject *args) {
1419	>	PyObject *resultobj;
1420	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1421	>	std::string arg2 ;
1422	>	PyObject * obj0 = 0 ;
1423	>	PyObject * obj1 = 0 ;
1424	>
1425	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___delitem__",&obj0,&obj1)) goto fail;
1426	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1427	>	{
1428	>	if (PyString_Check(obj1))
1429	>	arg2 = std::string(PyString_AsString(obj1));
1430	>	else
1431	>	SWIG_exception(SWIG_TypeError, "string expected");
1432		}
1433	<	}
1434	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
1435	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1436	<	return resultobj;
1437	<	fail:
1438	<	return NULL;
1439	<	}
1440	<
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());
1433	>	{
1434	>	try {
1435	>	std_maplstd_stringcstd_string_g___delitem_____(arg1,arg2);
1436	>
1437	>	}catch (std::out_of_range& e) {
1438	>	PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
1439	>	SWIG_fail;
1440	>	}
1441		}
1442	<	}
1443	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
1444	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1445	<	return resultobj;
6508	<	fail:
6509	<	return NULL;
1442	>	Py_INCREF(Py_None); resultobj = Py_None;
1443	>	return resultobj;
1444	>	fail:
1445	>	return NULL;
1446		}
1447
1448
1449	<	SWIGINTERN PyObject *_wrap_objectMap_end(PyObject *self, PyObject *args) {
1450	<	int argc;
1451	<	PyObject *argv[2];
1452	<	int ii;
1453	<
1454	<	if (!PyTuple_Check(args)) SWIG_fail;
1455	<	argc = PyObject_Length(args);
1456	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1457	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1458	<	}
1459	<	if (argc == 1) {
1460	<	int _v;
1461	<	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));
1462	<	_v = SWIG_CheckState(res);
1463	<	if (_v) {
6528	<	return _wrap_objectMap_end__SWIG_0(self, args);
1449	>	static PyObject *_wrap_objectMap_has_key(PyObject *self, PyObject *args) {
1450	>	PyObject *resultobj;
1451	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1452	>	std::string arg2 ;
1453	>	bool result;
1454	>	PyObject * obj0 = 0 ;
1455	>	PyObject * obj1 = 0 ;
1456	>
1457	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap_has_key",&obj0,&obj1)) goto fail;
1458	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1459	>	{
1460	>	if (PyString_Check(obj1))
1461	>	arg2 = std::string(PyString_AsString(obj1));
1462	>	else
1463	>	SWIG_exception(SWIG_TypeError, "string expected");
1464		}
1465	<	}
1466	<	if (argc == 1) {
1467	<	int _v;
1468	<	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));
1469	<	_v = SWIG_CheckState(res);
1470	<	if (_v) {
1471	<	return _wrap_objectMap_end__SWIG_1(self, args);
1465	>	{
1466	>	try {
1467	>	result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1468	>
1469	>	}catch (const BossSchedFailure & e) {
1470	>	PyErr_SetString ( SchedulerError, e.what() );
1471	>	return NULL;
1472	>	}catch (const std::exception& e) {
1473	>	PyErr_SetString ( BossError, e.what() );
1474	>	return NULL;
1475	>	}
1476		}
1477	<	}
1478	<
1479	<	fail:
1480	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_end'");
6542	<	return NULL;
1477	>	resultobj = PyInt_FromLong((long)result);
1478	>	return resultobj;
1479	>	fail:
1480	>	return NULL;
1481		}
1482
1483
1484	<	SWIGINTERN PyObject *_wrap_objectMap_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1485	<	PyObject *resultobj = 0;
1486	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1487	<	std::map<std::string,std::string >::reverse_iterator result;
1488	<	void *argp1 = 0 ;
1489	<	int res1 = 0 ;
1490	<	PyObject * obj0 = 0 ;
1491	<
1492	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rbegin",&obj0)) SWIG_fail;
1493	<	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 );
1494	<	if (!SWIG_IsOK(res1)) {
1495	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rbegin" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1496	<	}
1497	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1498	<	{
1499	<	try {
1500	<	result = (arg1)->rbegin();
1501	<	} catch (const std::exception& e) {
1502	<	SWIG_exception(SWIG_RuntimeError, e.what());
1484	>	static PyObject *_wrap_objectMap_keys(PyObject *self, PyObject *args) {
1485	>	PyObject *resultobj;
1486	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1487	>	PyObject *result;
1488	>	PyObject * obj0 = 0 ;
1489	>
1490	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_keys",&obj0)) goto fail;
1491	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1492	>	{
1493	>	try {
1494	>	result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1495	>
1496	>	}catch (const BossSchedFailure & e) {
1497	>	PyErr_SetString ( SchedulerError, e.what() );
1498	>	return NULL;
1499	>	}catch (const std::exception& e) {
1500	>	PyErr_SetString ( BossError, e.what() );
1501	>	return NULL;
1502	>	}
1503		}
1504	<	}
1505	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::reverse_iterator & >(result)),
1506	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1507	<	return resultobj;
6570	<	fail:
6571	<	return NULL;
1504	>	resultobj = result;
1505	>	return resultobj;
1506	>	fail:
1507	>	return NULL;
1508		}
1509
1510
1511	<	SWIGINTERN PyObject *_wrap_objectMap_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1512	<	PyObject *resultobj = 0;
1513	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1514	<	std::map<std::string,std::string >::const_reverse_iterator result;
1515	<	void *argp1 = 0 ;
1516	<	int res1 = 0 ;
1517	<	PyObject * obj0 = 0 ;
1518	<
1519	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rbegin",&obj0)) SWIG_fail;
1520	<	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 );
1521	<	if (!SWIG_IsOK(res1)) {
1522	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rbegin" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
1523	<	}
1524	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1525	<	{
1526	<	try {
1527	<	result = ((std::map<std::string,std::string > const *)arg1)->rbegin();
1528	<	} catch (const std::exception& e) {
1529	<	SWIG_exception(SWIG_RuntimeError, e.what());
1511	>	static PyObject *_wrap_objectMap_values(PyObject *self, PyObject *args) {
1512	>	PyObject *resultobj;
1513	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1514	>	PyObject *result;
1515	>	PyObject * obj0 = 0 ;
1516	>
1517	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_values",&obj0)) goto fail;
1518	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1519	>	{
1520	>	try {
1521	>	result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1522	>
1523	>	}catch (const BossSchedFailure & e) {
1524	>	PyErr_SetString ( SchedulerError, e.what() );
1525	>	return NULL;
1526	>	}catch (const std::exception& e) {
1527	>	PyErr_SetString ( BossError, e.what() );
1528	>	return NULL;
1529	>	}
1530		}
1531	<	}
1532	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_reverse_iterator & >(result)),
1533	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1534	<	return resultobj;
6599	<	fail:
6600	<	return NULL;
1531	>	resultobj = result;
1532	>	return resultobj;
1533	>	fail:
1534	>	return NULL;
1535		}
1536
1537
1538	<	SWIGINTERN PyObject *_wrap_objectMap_rbegin(PyObject *self, PyObject *args) {
1539	<	int argc;
1540	<	PyObject *argv[2];
1541	<	int ii;
1542	<
1543	<	if (!PyTuple_Check(args)) SWIG_fail;
1544	<	argc = PyObject_Length(args);
1545	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1546	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1547	<	}
1548	<	if (argc == 1) {
1549	<	int _v;
1550	<	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));
1551	<	_v = SWIG_CheckState(res);
1552	<	if (_v) {
1553	<	return _wrap_objectMap_rbegin__SWIG_0(self, args);
1554	<	}
1555	<	}
1556	<	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);
1538	>	static PyObject *_wrap_objectMap_items(PyObject *self, PyObject *args) {
1539	>	PyObject *resultobj;
1540	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1541	>	PyObject *result;
1542	>	PyObject * obj0 = 0 ;
1543	>
1544	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_items",&obj0)) goto fail;
1545	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1546	>	{
1547	>	try {
1548	>	result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1549	>
1550	>	}catch (const BossSchedFailure & e) {
1551	>	PyErr_SetString ( SchedulerError, e.what() );
1552	>	return NULL;
1553	>	}catch (const std::exception& e) {
1554	>	PyErr_SetString ( BossError, e.what() );
1555	>	return NULL;
1556	>	}
1557		}
1558	<	}
1559	<
1560	<	fail:
1561	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_rbegin'");
6633	<	return NULL;
1558	>	resultobj = result;
1559	>	return resultobj;
1560	>	fail:
1561	>	return NULL;
1562		}
1563
1564
1565	<	SWIGINTERN PyObject *_wrap_objectMap_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1566	<	PyObject *resultobj = 0;
1567	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1568	<	std::map<std::string,std::string >::reverse_iterator result;
1569	<	void *argp1 = 0 ;
1570	<	int res1 = 0 ;
1571	<	PyObject * obj0 = 0 ;
1572	<
1573	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rend",&obj0)) SWIG_fail;
1574	<	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 );
1575	<	if (!SWIG_IsOK(res1)) {
1576	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rend" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1577	<	}
1578	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1579	<	{
6652	<	try {
6653	<	result = (arg1)->rend();
6654	<	} catch (const std::exception& e) {
6655	<	SWIG_exception(SWIG_RuntimeError, e.what());
1565	>	static PyObject *_wrap_objectMap___contains__(PyObject *self, PyObject *args) {
1566	>	PyObject *resultobj;
1567	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1568	>	std::string arg2 ;
1569	>	bool result;
1570	>	PyObject * obj0 = 0 ;
1571	>	PyObject * obj1 = 0 ;
1572	>
1573	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___contains__",&obj0,&obj1)) goto fail;
1574	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1575	>	{
1576	>	if (PyString_Check(obj1))
1577	>	arg2 = std::string(PyString_AsString(obj1));
1578	>	else
1579	>	SWIG_exception(SWIG_TypeError, "string expected");
1580		}
1581	<	}
1582	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::reverse_iterator & >(result)),
1583	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1584	<	return resultobj;
1585	<	fail:
1586	<	return NULL;
1587	<	}
1588	<
1589	<
1590	<	SWIGINTERN PyObject *_wrap_objectMap_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1591	<	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());
1581	>	{
1582	>	try {
1583	>	result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1584	>
1585	>	}catch (const BossSchedFailure & e) {
1586	>	PyErr_SetString ( SchedulerError, e.what() );
1587	>	return NULL;
1588	>	}catch (const std::exception& e) {
1589	>	PyErr_SetString ( BossError, e.what() );
1590	>	return NULL;
1591	>	}
1592		}
1593	<	}
1594	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_reverse_iterator & >(result)),
1595	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1596	<	return resultobj;
6690	<	fail:
6691	<	return NULL;
1593	>	resultobj = PyInt_FromLong((long)result);
1594	>	return resultobj;
1595	>	fail:
1596	>	return NULL;
1597		}
1598
1599
1600	<	SWIGINTERN PyObject *_wrap_objectMap_rend(PyObject *self, PyObject *args) {
1601	<	int argc;
1602	<	PyObject *argv[2];
1603	<	int ii;
1604	<
1605	<	if (!PyTuple_Check(args)) SWIG_fail;
1606	<	argc = PyObject_Length(args);
1607	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1608	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1609	<	}
1610	<	if (argc == 1) {
1611	<	int _v;
1612	<	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));
1613	<	_v = SWIG_CheckState(res);
1614	<	if (_v) {
1615	<	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);
1600	>	static PyObject *_wrap_objectMap___iter__(PyObject *self, PyObject *args) {
1601	>	PyObject *resultobj;
1602	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1603	>	PyObject *result;
1604	>	PyObject * obj0 = 0 ;
1605	>
1606	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___iter__",&obj0)) goto fail;
1607	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1608	>	{
1609	>	try {
1610	>	result = (PyObject *)std_maplstd_stringcstd_string_g___iter_____(arg1);
1611	>
1612	>	}catch (std::runtime_error& e) {
1613	>	PyErr_SetString(PyExc_RuntimeError,const_cast<char*>(e.what()));
1614	>	SWIG_fail;
1615	>	}
1616		}
1617	<	}
1618	<
1619	<	fail:
1620	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_rend'");
6724	<	return NULL;
1617	>	resultobj = result;
1618	>	return resultobj;
1619	>	fail:
1620	>	return NULL;
1621		}
1622
1623
1624	<	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1625	<	PyObject *resultobj = 0;
1626	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1627	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
1628	<	std::map<std::string,std::string >::size_type result;
1629	<	void *argp1 = 0 ;
1630	<	int res1 = 0 ;
1631	<	int res2 = SWIG_OLDOBJ ;
1632	<	PyObject * obj0 = 0 ;
1633	<	PyObject * obj1 = 0 ;
1634	<
1635	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_erase",&obj0,&obj1)) SWIG_fail;
1636	<	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 );
1637	<	if (!SWIG_IsOK(res1)) {
1638	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1639	<	}
1640	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1641	<	{
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());
1624	>	static PyObject *_wrap_delete_objectMap(PyObject *self, PyObject *args) {
1625	>	PyObject *resultobj;
1626	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1627	>	PyObject * obj0 = 0 ;
1628	>
1629	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_objectMap",&obj0)) goto fail;
1630	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1631	>	{
1632	>	try {
1633	>	delete arg1;
1634	>
1635	>	}catch (const BossSchedFailure & e) {
1636	>	PyErr_SetString ( SchedulerError, e.what() );
1637	>	return NULL;
1638	>	}catch (const std::exception& e) {
1639	>	PyErr_SetString ( BossError, e.what() );
1640	>	return NULL;
1641	>	}
1642		}
1643	<	}
1644	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
1645	<	if (SWIG_IsNewObj(res2)) delete arg2;
1646	<	return resultobj;
6766	<	fail:
6767	<	if (SWIG_IsNewObj(res2)) delete arg2;
6768	<	return NULL;
1643	>	Py_INCREF(Py_None); resultobj = Py_None;
1644	>	return resultobj;
1645	>	fail:
1646	>	return NULL;
1647		}
1648
1649
1650	<	SWIGINTERN PyObject *_wrap_objectMap_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1651	<	PyObject *resultobj = 0;
1652	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1653	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
1654	<	std::map<std::string,std::string >::size_type result;
1655	<	void *argp1 = 0 ;
1656	<	int res1 = 0 ;
1657	<	int res2 = SWIG_OLDOBJ ;
1658	<	PyObject * obj0 = 0 ;
1659	<	PyObject * obj1 = 0 ;
1660	<
1661	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_count",&obj0,&obj1)) SWIG_fail;
1662	<	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 );
1663	<	if (!SWIG_IsOK(res1)) {
1664	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_count" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
1665	<	}
1666	<	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 &""'");
1650	>	static PyObject * objectMap_swigregister(PyObject *self, PyObject *args) {
1651	>	PyObject *obj;
1652	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
1653	>	SWIG_TypeClientData(SWIGTYPE_p_std__mapTstd__string_std__string_t, obj);
1654	>	Py_INCREF(obj);
1655	>	return Py_BuildValue((char *)"");
1656	>	}
1657	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1658	>	PyObject *resultobj;
1659	>	unsigned int arg1 = (unsigned int) 0 ;
1660	>	std::vector<std::string > *result;
1661	>	PyObject * obj0 = 0 ;
1662	>
1663	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1664	>	if (obj0) {
1665	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1666	>	if (PyErr_Occurred()) SWIG_fail;
1667		}
1668	<	arg2 = ptr;
1669	<	}
1670	<	{
1671	<	try {
1672	<	result = ((std::map<std::string,std::string > const *)arg1)->count((std::map<std::string,std::string >::key_type const &)*arg2);
1673	<	} catch (const std::exception& e) {
1674	<	SWIG_exception(SWIG_RuntimeError, e.what());
1668	>	{
1669	>	try {
1670	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1671	>
1672	>	}catch (const BossSchedFailure & e) {
1673	>	PyErr_SetString ( SchedulerError, e.what() );
1674	>	return NULL;
1675	>	}catch (const std::exception& e) {
1676	>	PyErr_SetString ( BossError, e.what() );
1677	>	return NULL;
1678	>	}
1679		}
1680	<	}
1681	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
1682	<	if (SWIG_IsNewObj(res2)) delete arg2;
1683	<	return resultobj;
6810	<	fail:
6811	<	if (SWIG_IsNewObj(res2)) delete arg2;
6812	<	return NULL;
1680	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1681	>	return resultobj;
1682	>	fail:
1683	>	return NULL;
1684		}
1685
1686
1687	<	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1688	<	PyObject *resultobj = 0;
1689	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1690	<	std::map<std::string,std::string >::iterator arg2 ;
1691	<	void *argp1 = 0 ;
1692	<	int res1 = 0 ;
1693	<	swig::PySwigIterator *iter2 = 0 ;
1694	<	int res2 ;
1695	<	PyObject * obj0 = 0 ;
1696	<	PyObject * obj1 = 0 ;
1697	<
1698	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_erase",&obj0,&obj1)) SWIG_fail;
1699	<	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 );
1700	<	if (!SWIG_IsOK(res1)) {
1701	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1702	<	}
1703	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1704	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
1705	<	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""'");
1687	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1688	>	PyObject *resultobj;
1689	>	unsigned int arg1 ;
1690	>	std::string *arg2 = 0 ;
1691	>	std::vector<std::string > *result;
1692	>	std::string temp2 ;
1693	>	PyObject * obj0 = 0 ;
1694	>	PyObject * obj1 = 0 ;
1695	>
1696	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1697	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1698	>	if (PyErr_Occurred()) SWIG_fail;
1699	>	{
1700	>	if (PyString_Check(obj1)) {
1701	>	temp2 = std::string(PyString_AsString(obj1));
1702	>	arg2 = &temp2;
1703	>	}else {
1704	>	SWIG_exception(SWIG_TypeError, "string expected");
1705	>	}
1706		}
1707	<	}
1708	<	{
1709	<	try {
1710	<	(arg1)->erase(arg2);
1711	<	} catch (const std::exception& e) {
1712	<	SWIG_exception(SWIG_RuntimeError, e.what());
1707	>	{
1708	>	try {
1709	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1710	>
1711	>	}catch (const BossSchedFailure & e) {
1712	>	PyErr_SetString ( SchedulerError, e.what() );
1713	>	return NULL;
1714	>	}catch (const std::exception& e) {
1715	>	PyErr_SetString ( BossError, e.what() );
1716	>	return NULL;
1717	>	}
1718		}
1719	<	}
1720	<	resultobj = SWIG_Py_Void();
1721	<	return resultobj;
1722	<	fail:
6854	<	return NULL;
1719	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1720	>	return resultobj;
1721	>	fail:
1722	>	return NULL;
1723		}
1724
1725
1726	<	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1727	<	PyObject *resultobj = 0;
1728	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1729	<	std::map<std::string,std::string >::iterator arg2 ;
1730	<	std::map<std::string,std::string >::iterator arg3 ;
1731	<	void *argp1 = 0 ;
1732	<	int res1 = 0 ;
1733	<	swig::PySwigIterator *iter2 = 0 ;
1734	<	int res2 ;
1735	<	swig::PySwigIterator *iter3 = 0 ;
1736	<	int res3 ;
1737	<	PyObject * obj0 = 0 ;
1738	<	PyObject * obj1 = 0 ;
1739	<	PyObject * obj2 = 0 ;
1740	<
1741	<	if (!PyArg_ParseTuple(args,(char *)"OOO:objectMap_erase",&obj0,&obj1,&obj2)) SWIG_fail;
1742	<	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 );
1743	<	if (!SWIG_IsOK(res1)) {
1744	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1745	<	}
1746	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1747	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
1748	<	if (!SWIG_IsOK(res2) || !iter2) {
1749	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::iterator""'");
1750	<	} else {
1751	<	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);
1752	<	if (iter_t) {
1753	<	arg2 = iter_t->get_current();
1754	<	} else {
1755	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::iterator""'");
1756	<	}
1757	<	}
1758	<	res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
1759	<	if (!SWIG_IsOK(res3) || !iter3) {
1760	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "3"" of type '" "std::map<std::string,std::string >::iterator""'");
1761	<	} 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""'");
1726	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1727	>	PyObject *resultobj;
1728	>	std::vector<std::string > *arg1 = 0 ;
1729	>	std::vector<std::string > *result;
1730	>	std::vector<std::string > temp1 ;
1731	>	std::vector<std::string > *v1 ;
1732	>	PyObject * obj0 = 0 ;
1733	>
1734	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1735	>	{
1736	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1737	>	unsigned int size = (PyTuple_Check(obj0) ?
1738	>	PyTuple_Size(obj0) :
1739	>	PyList_Size(obj0));
1740	>	temp1 = std::vector<std::string >(size);
1741	>	arg1 = &temp1;
1742	>	for (unsigned int i=0; i<size; i++) {
1743	>	PyObject* o = PySequence_GetItem(obj0,i);
1744	>	if (PyString_Check(o)) {
1745	>	temp1[i] = (std::string)(\
1746	>	SwigString_AsString(o));
1747	>	Py_DECREF(o);
1748	>	}else {
1749	>	Py_DECREF(o);
1750	>	PyErr_SetString(PyExc_TypeError,
1751	>	"vector<""std::string""> expected");
1752	>	SWIG_fail;
1753	>	}
1754	>	}
1755	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1756	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1757	>	arg1 = v1;
1758	>	}else {
1759	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1760	>	SWIG_fail;
1761	>	}
1762		}
1763	<	}
1764	<	{
1765	<	try {
1766	<	(arg1)->erase(arg2,arg3);
1767	<	} catch (const std::exception& e) {
1768	<	SWIG_exception(SWIG_RuntimeError, e.what());
1763	>	{
1764	>	try {
1765	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1766	>
1767	>	}catch (const BossSchedFailure & e) {
1768	>	PyErr_SetString ( SchedulerError, e.what() );
1769	>	return NULL;
1770	>	}catch (const std::exception& e) {
1771	>	PyErr_SetString ( BossError, e.what() );
1772	>	return NULL;
1773	>	}
1774		}
1775	<	}
1776	<	resultobj = SWIG_Py_Void();
1777	<	return resultobj;
1778	<	fail:
6911	<	return NULL;
1775	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1776	>	return resultobj;
1777	>	fail:
1778	>	return NULL;
1779		}
1780
1781
1782	<	SWIGINTERN PyObject *_wrap_objectMap_erase(PyObject *self, PyObject *args) {
1783	<	int argc;
1784	<	PyObject *argv[4];
1785	<	int ii;
1786	<
1787	<	if (!PyTuple_Check(args)) SWIG_fail;
1788	<	argc = PyObject_Length(args);
1789	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
1790	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1791	<	}
1792	<	if (argc == 2) {
1793	<	int _v;
1794	<	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));
1795	<	_v = SWIG_CheckState(res);
1796	<	if (_v) {
1797	<	swig::PySwigIterator *iter = 0;
1798	<	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));
1782	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1783	>	int argc;
1784	>	PyObject *argv[3];
1785	>	int ii;
1786	>
1787	>	argc = PyObject_Length(args);
1788	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1789	>	argv[ii] = PyTuple_GetItem(args,ii);
1790	>	}
1791	>	if ((argc >= 0) && (argc <= 1)) {
1792	>	int _v;
1793	>	if (argc <= 0) {
1794	>	return _wrap_new_vector_string__SWIG_0(self,args);
1795	>	}
1796	>	{
1797	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1798	>	}
1799		if (_v) {
1800	<	return _wrap_objectMap_erase__SWIG_2(self, args);
1800	>	return _wrap_new_vector_string__SWIG_0(self,args);
1801		}
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	–	}
1802		}
1803	<	}
1804	<
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 &""'");
7617	<	}
7618	<	arg4 = ptr;
7619	<	}
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 {
1803	>	if (argc == 1) {
1804	>	int _v;
1805		{
1806	<	std::vector<std::string >::value_type const &_result_ref = std_vector_Sl_std_string_Sg____getitem__((std::vector<std::string > const *)arg1,arg2);
1807	<	result = (std::vector<std::string >::value_type *) &_result_ref;
1806	>	/* native sequence? */
1807	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1808	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1809	>	PyTuple_Size(argv[0]) :
1810	>	PyList_Size(argv[0]));
1811	>	if (size == 0) {
1812	>	/* an empty sequence can be of any type */
1813	>	_v = 1;
1814	>	}else {
1815	>	/* check the first element only */
1816	>	PyObject* o = PySequence_GetItem(argv[0],0);
1817	>	if (PyString_Check(o))
1818	>	_v = 1;
1819	>	else
1820	>	_v = 0;
1821	>	Py_DECREF(o);
1822	>	}
1823	>	}else {
1824	>	/* wrapped vector? */
1825	>	std::vector<std::string >* v;
1826	>	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1827	>	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1828	>	_v = 1;
1829	>	else
1830	>	_v = 0;
1831	>	}
1832	>	}
1833	>	if (_v) {
1834	>	return _wrap_new_vector_string__SWIG_2(self,args);
1835		}
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);
1836		}
1837	<	}
1838	<
1839	<	fail:
1840	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_rend'");
1841	<	return NULL;
1842	<	}
1843	<
1844	<
1845	<	SWIGINTERN PyObject *_wrap_new_vector_string__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1846	<	PyObject *resultobj = 0;
1847	<	std::vector<std::string >::size_type arg1 ;
1848	<	std::vector<std::string > *result = 0 ;
1849	<	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());
1837	>	if (argc == 2) {
1838	>	int _v;
1839	>	{
1840	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1841	>	}
1842	>	if (_v) {
1843	>	{
1844	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1845	>	}
1846	>	if (_v) {
1847	>	return _wrap_new_vector_string__SWIG_1(self,args);
1848	>	}
1849	>	}
1850		}
1851	<	}
1852	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
1853	<	return resultobj;
8476	<	fail:
8477	<	return NULL;
1851	>
1852	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1853	>	return NULL;
1854		}
1855
1856
1857	<	SWIGINTERN PyObject *_wrap_vector_string_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1858	<	PyObject *resultobj = 0;
1859	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1860	<	void *argp1 = 0 ;
1861	<	int res1 = 0 ;
1862	<	PyObject * obj0 = 0 ;
1863	<
1864	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_pop_back",&obj0)) SWIG_fail;
1865	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
1866	<	if (!SWIG_IsOK(res1)) {
1867	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_pop_back" "', argument " "1"" of type '" "std::vector<std::string > *""'");
1868	<	}
1869	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
1870	<	{
1871	<	try {
1872	<	(arg1)->pop_back();
1873	<	} catch (const std::exception& e) {
1874	<	SWIG_exception(SWIG_RuntimeError, e.what());
1857	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1858	>	PyObject *resultobj;
1859	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1860	>	unsigned int result;
1861	>	std::vector<std::string > temp1 ;
1862	>	std::vector<std::string > *v1 ;
1863	>	PyObject * obj0 = 0 ;
1864	>
1865	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1866	>	{
1867	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1868	>	unsigned int size = (PyTuple_Check(obj0) ?
1869	>	PyTuple_Size(obj0) :
1870	>	PyList_Size(obj0));
1871	>	temp1 = std::vector<std::string >(size);
1872	>	arg1 = &temp1;
1873	>	for (unsigned int i=0; i<size; i++) {
1874	>	PyObject* o = PySequence_GetItem(obj0,i);
1875	>	if (PyString_Check(o)) {
1876	>	temp1[i] = (std::string)(\
1877	>	SwigString_AsString(o));
1878	>	Py_DECREF(o);
1879	>	}else {
1880	>	Py_DECREF(o);
1881	>	PyErr_SetString(PyExc_TypeError,
1882	>	"vector<""std::string""> expected");
1883	>	SWIG_fail;
1884	>	}
1885	>	}
1886	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1887	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1888	>	arg1 = v1;
1889	>	}else {
1890	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1891	>	SWIG_fail;
1892	>	}
1893		}
1894	<	}
1895	<	resultobj = SWIG_Py_Void();
1896	<	return resultobj;
1897	<	fail:
1898	<	return NULL;
1899	<	}
1900	<
1901	<
1902	<	SWIGINTERN PyObject *_wrap_vector_string_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1903	<	PyObject *resultobj = 0;
1904	<	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());
1894	>	{
1895	>	try {
1896	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1897	>
1898	>	}catch (const BossSchedFailure & e) {
1899	>	PyErr_SetString ( SchedulerError, e.what() );
1900	>	return NULL;
1901	>	}catch (const std::exception& e) {
1902	>	PyErr_SetString ( BossError, e.what() );
1903	>	return NULL;
1904	>	}
1905		}
1906	<	}
1907	<	resultobj = SWIG_Py_Void();
1908	<	return resultobj;
1909	<	fail:
8540	<	return NULL;
1906	>	resultobj = PyInt_FromLong((long)result);
1907	>	return resultobj;
1908	>	fail:
1909	>	return NULL;
1910		}
1911
1912
1913	<	SWIGINTERN PyObject *_wrap_vector_string_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1914	<	PyObject *resultobj = 0;
1915	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1916	<	std::vector<std::string >::iterator arg2 ;
1917	<	std::vector<std::string >::iterator result;
1918	<	void *argp1 = 0 ;
1919	<	int res1 = 0 ;
1920	<	swig::PySwigIterator *iter2 = 0 ;
1921	<	int res2 ;
1922	<	PyObject * obj0 = 0 ;
1923	<	PyObject * obj1 = 0 ;
1924	<
1925	<	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_erase",&obj0,&obj1)) SWIG_fail;
1926	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
1927	<	if (!SWIG_IsOK(res1)) {
1928	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_erase" "', argument " "1"" of type '" "std::vector<std::string > *""'");
1929	<	}
1930	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
1931	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
1932	<	if (!SWIG_IsOK(res2) || !iter2) {
1933	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_erase" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
1934	<	} else {
1935	<	swig::PySwigIterator_T<std::vector<std::string >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter2);
1936	<	if (iter_t) {
1937	<	arg2 = iter_t->get_current();
1938	<	} else {
1939	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_erase" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
1913	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1914	>	PyObject *resultobj;
1915	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1916	>	bool result;
1917	>	std::vector<std::string > temp1 ;
1918	>	std::vector<std::string > *v1 ;
1919	>	PyObject * obj0 = 0 ;
1920	>
1921	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1922	>	{
1923	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1924	>	unsigned int size = (PyTuple_Check(obj0) ?
1925	>	PyTuple_Size(obj0) :
1926	>	PyList_Size(obj0));
1927	>	temp1 = std::vector<std::string >(size);
1928	>	arg1 = &temp1;
1929	>	for (unsigned int i=0; i<size; i++) {
1930	>	PyObject* o = PySequence_GetItem(obj0,i);
1931	>	if (PyString_Check(o)) {
1932	>	temp1[i] = (std::string)(\
1933	>	SwigString_AsString(o));
1934	>	Py_DECREF(o);
1935	>	}else {
1936	>	Py_DECREF(o);
1937	>	PyErr_SetString(PyExc_TypeError,
1938	>	"vector<""std::string""> expected");
1939	>	SWIG_fail;
1940	>	}
1941	>	}
1942	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1943	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1944	>	arg1 = v1;
1945	>	}else {
1946	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1947	>	SWIG_fail;
1948	>	}
1949		}
1950	<	}
1951	<	{
1952	<	try {
1953	<	result = (arg1)->erase(arg2);
1954	<	} catch (const std::exception& e) {
1955	<	SWIG_exception(SWIG_RuntimeError, e.what());
1950	>	{
1951	>	try {
1952	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1953	>
1954	>	}catch (const BossSchedFailure & e) {
1955	>	PyErr_SetString ( SchedulerError, e.what() );
1956	>	return NULL;
1957	>	}catch (const std::exception& e) {
1958	>	PyErr_SetString ( BossError, e.what() );
1959	>	return NULL;
1960	>	}
1961		}
1962	<	}
1963	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
1964	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1965	<	return resultobj;
8583	<	fail:
8584	<	return NULL;
1962	>	resultobj = PyInt_FromLong((long)result);
1963	>	return resultobj;
1964	>	fail:
1965	>	return NULL;
1966		}
1967
1968
1969	<	SWIGINTERN PyObject *_wrap_vector_string_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1970	<	PyObject *resultobj = 0;
1971	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1972	<	std::vector<std::string >::iterator arg2 ;
1973	<	std::vector<std::string >::iterator arg3 ;
1974	<	std::vector<std::string >::iterator result;
1975	<	void *argp1 = 0 ;
1976	<	int res1 = 0 ;
1977	<	swig::PySwigIterator *iter2 = 0 ;
1978	<	int res2 ;
1979	<	swig::PySwigIterator *iter3 = 0 ;
1980	<	int res3 ;
1981	<	PyObject * obj0 = 0 ;
1982	<	PyObject * obj1 = 0 ;
1983	<	PyObject * obj2 = 0 ;
1984	<
1985	<	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_erase",&obj0,&obj1,&obj2)) SWIG_fail;
1986	<	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());
1969	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1970	>	PyObject *resultobj;
1971	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1972	>	PyObject * obj0 = 0 ;
1973	>
1974	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1975	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1976	>	{
1977	>	try {
1978	>	(arg1)->clear();
1979	>
1980	>	}catch (const BossSchedFailure & e) {
1981	>	PyErr_SetString ( SchedulerError, e.what() );
1982	>	return NULL;
1983	>	}catch (const std::exception& e) {
1984	>	PyErr_SetString ( BossError, e.what() );
1985	>	return NULL;
1986	>	}
1987		}
1988	<	}
1989	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
1990	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1991	<	return resultobj;
8642	<	fail:
8643	<	return NULL;
1988	>	Py_INCREF(Py_None); resultobj = Py_None;
1989	>	return resultobj;
1990	>	fail:
1991	>	return NULL;
1992		}
1993
1994
1995	<	SWIGINTERN PyObject *_wrap_vector_string_erase(PyObject *self, PyObject *args) {
1996	<	int argc;
1997	<	PyObject *argv[4];
1998	<	int ii;
1999	<
2000	<	if (!PyTuple_Check(args)) SWIG_fail;
2001	<	argc = PyObject_Length(args);
2002	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
2003	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2004	<	}
2005	<	if (argc == 2) {
2006	<	int _v;
2007	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2008	<	_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	<	}
1995	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1996	>	PyObject *resultobj;
1997	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1998	>	std::string arg2 ;
1999	>	PyObject * obj0 = 0 ;
2000	>	PyObject * obj1 = 0 ;
2001	>
2002	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
2003	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2004	>	{
2005	>	if (PyString_Check(obj1))
2006	>	arg2 = std::string(PyString_AsString(obj1));
2007	>	else
2008	>	SWIG_exception(SWIG_TypeError, "string expected");
2009		}
2010	<	}
2011	<	if (argc == 3) {
2012	<	int _v;
2013	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2014	<	_v = SWIG_CheckState(res);
2015	<	if (_v) {
2016	<	swig::PySwigIterator *iter = 0;
2017	<	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
2018	<	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter) != 0));
2019	<	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);
2010	>	{
2011	>	try {
2012	>	(arg1)->push_back(arg2);
2013	>
2014	>	}catch (const BossSchedFailure & e) {
2015	>	PyErr_SetString ( SchedulerError, e.what() );
2016	>	return NULL;
2017	>	}catch (const std::exception& e) {
2018	>	PyErr_SetString ( BossError, e.what() );
2019	>	return NULL;
2020		}
8685	–	}
2021		}
2022	<	}
2023	<
2024	<	fail:
2025	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_erase'");
8691	<	return NULL;
2022	>	Py_INCREF(Py_None); resultobj = Py_None;
2023	>	return resultobj;
2024	>	fail:
2025	>	return NULL;
2026		}
2027
2028
2029	<	SWIGINTERN PyObject *_wrap_new_vector_string__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2030	<	PyObject *resultobj = 0;
2031	<	std::vector<std::string >::size_type arg1 ;
2032	<	std::vector<std::string >::value_type *arg2 = 0 ;
2033	<	std::vector<std::string > *result = 0 ;
2034	<	size_t val1 ;
2035	<	int ecode1 = 0 ;
2036	<	int res2 = SWIG_OLDOBJ ;
2037	<	PyObject * obj0 = 0 ;
2038	<	PyObject * obj1 = 0 ;
2039	<
2040	<	if (!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) SWIG_fail;
2041	<	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
2042	<	if (!SWIG_IsOK(ecode1)) {
2043	<	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 &""'");
2029	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
2030	>	PyObject *resultobj;
2031	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2032	>	std::string result;
2033	>	PyObject * obj0 = 0 ;
2034	>
2035	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
2036	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2037	>	{
2038	>	try {
2039	>	result = std_vectorlstd_string_g_pop___(arg1);
2040	>
2041	>	}catch (std::out_of_range& e) {
2042	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2043	>	}
2044		}
2045	<	arg2 = ptr;
2046	<	}
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());
2045	>	{
2046	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2047		}
2048	<	}
2049	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
2050	<	if (SWIG_IsNewObj(res2)) delete arg2;
8732	<	return resultobj;
8733	<	fail:
8734	<	if (SWIG_IsNewObj(res2)) delete arg2;
8735	<	return NULL;
2048	>	return resultobj;
2049	>	fail:
2050	>	return NULL;
2051		}
2052
2053
2054	<	SWIGINTERN PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
2055	<	int argc;
2056	<	PyObject *argv[3];
2057	<	int ii;
2058	<
2059	<	if (!PyTuple_Check(args)) SWIG_fail;
2060	<	argc = PyObject_Length(args);
2061	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
2062	<	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;
2054	>	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
2055	>	PyObject *resultobj;
2056	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2057	>	int arg2 ;
2058	>	std::string result;
2059	>	PyObject * obj0 = 0 ;
2060	>
2061	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
2062	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2063		{
2064	<	int res = SWIG_AsVal_size_t(argv[0], NULL);
2065	<	_v = SWIG_CheckState(res);
2066	<	}
2067	<	if (_v) {
2068	<	return _wrap_new_vector_string__SWIG_2(self, args);
2069	<	}
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);
2064	>	try {
2065	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
2066	>
2067	>	}catch (std::out_of_range& e) {
2068	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2069	>	}
2070		}
8769	–	}
8770	–	if (argc == 2) {
8771	–	int _v;
2071		{
2072	<	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	<	}
2072	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2073		}
2074	<	}
2075	<
2076	<	fail:
8786	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_vector_string'");
8787	<	return NULL;
2074	>	return resultobj;
2075	>	fail:
2076	>	return NULL;
2077		}
2078
2079
2080	<	SWIGINTERN PyObject *_wrap_vector_string_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2081	<	PyObject *resultobj = 0;
2082	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2083	<	std::vector<std::string >::value_type *arg2 = 0 ;
2084	<	void *argp1 = 0 ;
2085	<	int res1 = 0 ;
2086	<	int res2 = SWIG_OLDOBJ ;
2087	<	PyObject * obj0 = 0 ;
2088	<	PyObject * obj1 = 0 ;
2089	<
2090	<	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_push_back",&obj0,&obj1)) SWIG_fail;
2091	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2092	<	if (!SWIG_IsOK(res1)) {
2093	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_push_back" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2094	<	}
2095	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2096	<	{
2097	<	std::string *ptr = (std::string *)0;
2098	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
2099	<	if (!SWIG_IsOK(res2)) {
2100	<	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 &""'");
2080	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2081	>	PyObject *resultobj;
2082	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2083	>	int arg2 ;
2084	>	int arg3 ;
2085	>	std::vector<std::string > result;
2086	>	PyObject * obj0 = 0 ;
2087	>
2088	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2089	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2090	>	{
2091	>	try {
2092	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2093	>
2094	>	}catch (const BossSchedFailure & e) {
2095	>	PyErr_SetString ( SchedulerError, e.what() );
2096	>	return NULL;
2097	>	}catch (const std::exception& e) {
2098	>	PyErr_SetString ( BossError, e.what() );
2099	>	return NULL;
2100	>	}
2101		}
2102	<	arg2 = ptr;
2103	<	}
2104	<	{
2105	<	try {
2106	<	(arg1)->push_back((std::vector<std::string >::value_type const &)*arg2);
8821	<	} catch (const std::exception& e) {
8822	<	SWIG_exception(SWIG_RuntimeError, e.what());
2102	>	{
2103	>	resultobj = PyTuple_New((&result)->size());
2104	>	for (unsigned int i=0; i<(&result)->size(); i++)
2105	>	PyTuple_SetItem(resultobj,i,
2106	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2107		}
2108	<	}
2109	<	resultobj = SWIG_Py_Void();
2110	<	if (SWIG_IsNewObj(res2)) delete arg2;
8827	<	return resultobj;
8828	<	fail:
8829	<	if (SWIG_IsNewObj(res2)) delete arg2;
8830	<	return NULL;
2108	>	return resultobj;
2109	>	fail:
2110	>	return NULL;
2111		}
2112
2113
2114	<	SWIGINTERN PyObject *_wrap_vector_string_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2115	<	PyObject *resultobj = 0;
2116	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2117	<	std::vector<std::string >::value_type *result = 0 ;
2118	<	void *argp1 = 0 ;
2119	<	int res1 = 0 ;
2120	<	PyObject * obj0 = 0 ;
2121	<
2122	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_front",&obj0)) SWIG_fail;
2123	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2124	<	if (!SWIG_IsOK(res1)) {
2125	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_front" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
2126	<	}
2127	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2128	<	{
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());
2114	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2115	>	PyObject *resultobj;
2116	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2117	>	int arg2 ;
2118	>	std::string arg3 ;
2119	>	PyObject * obj0 = 0 ;
2120	>	PyObject * obj2 = 0 ;
2121	>
2122	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2123	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2124	>	{
2125	>	if (PyString_Check(obj2))
2126	>	arg3 = std::string(PyString_AsString(obj2));
2127	>	else
2128	>	SWIG_exception(SWIG_TypeError, "string expected");
2129		}
2130	<	}
2131	<	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
2132	<	return resultobj;
2133	<	fail:
2134	<	return NULL;
2135	<	}
2136	<
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());
2130	>	{
2131	>	try {
2132	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2133	>
2134	>	}catch (std::out_of_range& e) {
2135	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2136	>	}
2137		}
2138	<	}
2139	<	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
2140	<	return resultobj;
2141	<	fail:
8892	<	return NULL;
2138	>	Py_INCREF(Py_None); resultobj = Py_None;
2139	>	return resultobj;
2140	>	fail:
2141	>	return NULL;
2142		}
2143
2144
2145	<	SWIGINTERN PyObject *_wrap_vector_string_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2146	<	PyObject *resultobj = 0;
2147	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2148	<	std::vector<std::string >::size_type arg2 ;
2149	<	std::vector<std::string >::value_type *arg3 = 0 ;
2150	<	void *argp1 = 0 ;
2151	<	int res1 = 0 ;
2152	<	size_t val2 ;
2153	<	int ecode2 = 0 ;
2154	<	int res3 = SWIG_OLDOBJ ;
2155	<	PyObject * obj0 = 0 ;
2156	<	PyObject * obj1 = 0 ;
2157	<	PyObject * obj2 = 0 ;
2158	<
2159	<	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_assign",&obj0,&obj1,&obj2)) SWIG_fail;
2160	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2161	<	if (!SWIG_IsOK(res1)) {
2162	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_assign" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2163	<	}
2164	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2165	<	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
2166	<	if (!SWIG_IsOK(ecode2)) {
2167	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string_assign" "', argument " "2"" of type '" "std::vector<std::string >::size_type""'");
2168	<	}
2169	<	arg2 = static_cast< std::vector<std::string >::size_type >(val2);
2170	<	{
2171	<	std::string *ptr = (std::string *)0;
2172	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
2173	<	if (!SWIG_IsOK(res3)) {
2174	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_string_assign" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
2175	<	}
2176	<	if (!ptr) {
2177	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_assign" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
2145	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2146	>	PyObject *resultobj;
2147	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2148	>	int arg2 ;
2149	>	int arg3 ;
2150	>	std::vector<std::string > *arg4 = 0 ;
2151	>	std::vector<std::string > temp4 ;
2152	>	std::vector<std::string > *v4 ;
2153	>	PyObject * obj0 = 0 ;
2154	>	PyObject * obj3 = 0 ;
2155	>
2156	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2157	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2158	>	{
2159	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2160	>	unsigned int size = (PyTuple_Check(obj3) ?
2161	>	PyTuple_Size(obj3) :
2162	>	PyList_Size(obj3));
2163	>	temp4 = std::vector<std::string >(size);
2164	>	arg4 = &temp4;
2165	>	for (unsigned int i=0; i<size; i++) {
2166	>	PyObject* o = PySequence_GetItem(obj3,i);
2167	>	if (PyString_Check(o)) {
2168	>	temp4[i] = (std::string)(\
2169	>	SwigString_AsString(o));
2170	>	Py_DECREF(o);
2171	>	}else {
2172	>	Py_DECREF(o);
2173	>	PyErr_SetString(PyExc_TypeError,
2174	>	"vector<""std::string""> expected");
2175	>	SWIG_fail;
2176	>	}
2177	>	}
2178	>	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2179	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2180	>	arg4 = v4;
2181	>	}else {
2182	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2183	>	SWIG_fail;
2184	>	}
2185		}
2186	<	arg3 = ptr;
2187	<	}
2188	<	{
2189	<	try {
2190	<	(arg1)->assign(arg2,(std::vector<std::string >::value_type const &)*arg3);
2191	<	} catch (const std::exception& e) {
2192	<	SWIG_exception(SWIG_RuntimeError, e.what());
2186	>	{
2187	>	try {
2188	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2189	>
2190	>	}catch (const BossSchedFailure & e) {
2191	>	PyErr_SetString ( SchedulerError, e.what() );
2192	>	return NULL;
2193	>	}catch (const std::exception& e) {
2194	>	PyErr_SetString ( BossError, e.what() );
2195	>	return NULL;
2196	>	}
2197		}
2198	<	}
2199	<	resultobj = SWIG_Py_Void();
2200	<	if (SWIG_IsNewObj(res3)) delete arg3;
2201	<	return resultobj;
8942	<	fail:
8943	<	if (SWIG_IsNewObj(res3)) delete arg3;
8944	<	return NULL;
2198	>	Py_INCREF(Py_None); resultobj = Py_None;
2199	>	return resultobj;
2200	>	fail:
2201	>	return NULL;
2202		}
2203
2204
2205	<	SWIGINTERN PyObject *_wrap_vector_string_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2206	<	PyObject *resultobj = 0;
2207	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2208	<	std::vector<std::string >::size_type arg2 ;
2209	<	std::vector<std::string >::value_type *arg3 = 0 ;
2210	<	void *argp1 = 0 ;
2211	<	int res1 = 0 ;
2212	<	size_t val2 ;
2213	<	int ecode2 = 0 ;
2214	<	int res3 = SWIG_OLDOBJ ;
2215	<	PyObject * obj0 = 0 ;
2216	<	PyObject * obj1 = 0 ;
2217	<	PyObject * obj2 = 0 ;
2218	<
2219	<	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());
2205	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2206	>	PyObject *resultobj;
2207	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2208	>	int arg2 ;
2209	>	PyObject * obj0 = 0 ;
2210	>
2211	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2212	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2213	>	{
2214	>	try {
2215	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2216	>
2217	>	}catch (std::out_of_range& e) {
2218	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2219	>	}
2220		}
2221	<	}
2222	<	resultobj = SWIG_Py_Void();
2223	<	if (SWIG_IsNewObj(res3)) delete arg3;
2224	<	return resultobj;
8994	<	fail:
8995	<	if (SWIG_IsNewObj(res3)) delete arg3;
8996	<	return NULL;
2221	>	Py_INCREF(Py_None); resultobj = Py_None;
2222	>	return resultobj;
2223	>	fail:
2224	>	return NULL;
2225		}
2226
2227
2228	<	SWIGINTERN PyObject *_wrap_vector_string_resize(PyObject *self, PyObject *args) {
2229	<	int argc;
2230	<	PyObject *argv[4];
2231	<	int ii;
2232	<
2233	<	if (!PyTuple_Check(args)) SWIG_fail;
2234	<	argc = PyObject_Length(args);
2235	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
2236	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2237	<	}
2238	<	if (argc == 2) {
2239	<	int _v;
2240	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2241	<	_v = SWIG_CheckState(res);
2242	<	if (_v) {
2243	<	{
2244	<	int res = SWIG_AsVal_size_t(argv[1], NULL);
2245	<	_v = SWIG_CheckState(res);
2246	<	}
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);
2228	>	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2229	>	PyObject *resultobj;
2230	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2231	>	int arg2 ;
2232	>	int arg3 ;
2233	>	PyObject * obj0 = 0 ;
2234	>
2235	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2236	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2237	>	{
2238	>	try {
2239	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2240	>
2241	>	}catch (const BossSchedFailure & e) {
2242	>	PyErr_SetString ( SchedulerError, e.what() );
2243	>	return NULL;
2244	>	}catch (const std::exception& e) {
2245	>	PyErr_SetString ( BossError, e.what() );
2246	>	return NULL;
2247		}
9039	–	}
2248		}
2249	<	}
2250	<
2251	<	fail:
2252	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_resize'");
9045	<	return NULL;
2249	>	Py_INCREF(Py_None); resultobj = Py_None;
2250	>	return resultobj;
2251	>	fail:
2252	>	return NULL;
2253		}
2254
2255
2256	<	SWIGINTERN PyObject *_wrap_vector_string_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2257	<	PyObject *resultobj = 0;
2258	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2259	<	std::vector<std::string >::iterator arg2 ;
2260	<	std::vector<std::string >::value_type *arg3 = 0 ;
2261	<	std::vector<std::string >::iterator result;
2262	<	void *argp1 = 0 ;
2263	<	int res1 = 0 ;
2264	<	swig::PySwigIterator *iter2 = 0 ;
2265	<	int res2 ;
2266	<	int res3 = SWIG_OLDOBJ ;
2267	<	PyObject * obj0 = 0 ;
2268	<	PyObject * obj1 = 0 ;
2269	<	PyObject * obj2 = 0 ;
2270	<
2271	<	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_insert",&obj0,&obj1,&obj2)) SWIG_fail;
2272	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2273	<	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());
2256	>	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2257	>	PyObject *resultobj;
2258	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2259	>	PyObject * obj0 = 0 ;
2260	>
2261	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2262	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2263	>	{
2264	>	try {
2265	>	delete arg1;
2266	>
2267	>	}catch (const BossSchedFailure & e) {
2268	>	PyErr_SetString ( SchedulerError, e.what() );
2269	>	return NULL;
2270	>	}catch (const std::exception& e) {
2271	>	PyErr_SetString ( BossError, e.what() );
2272	>	return NULL;
2273	>	}
2274		}
2275	<	}
2276	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
2277	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
2278	<	if (SWIG_IsNewObj(res3)) delete arg3;
9102	<	return resultobj;
9103	<	fail:
9104	<	if (SWIG_IsNewObj(res3)) delete arg3;
9105	<	return NULL;
2275	>	Py_INCREF(Py_None); resultobj = Py_None;
2276	>	return resultobj;
2277	>	fail:
2278	>	return NULL;
2279		}
2280
2281
2282	<	SWIGINTERN PyObject *_wrap_vector_string_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2283	<	PyObject *resultobj = 0;
2284	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2285	<	std::vector<std::string >::iterator arg2 ;
2286	<	std::vector<std::string >::size_type arg3 ;
2287	<	std::vector<std::string >::value_type *arg4 = 0 ;
2288	<	void *argp1 = 0 ;
2289	<	int res1 = 0 ;
2290	<	swig::PySwigIterator *iter2 = 0 ;
2291	<	int res2 ;
2292	<	size_t val3 ;
2293	<	int ecode3 = 0 ;
2294	<	int res4 = SWIG_OLDOBJ ;
2295	<	PyObject * obj0 = 0 ;
2296	<	PyObject * obj1 = 0 ;
2297	<	PyObject * obj2 = 0 ;
2298	<	PyObject * obj3 = 0 ;
2299	<
2300	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
2301	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2302	<	if (!SWIG_IsOK(res1)) {
2303	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_insert" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2304	<	}
2305	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2306	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
2307	<	if (!SWIG_IsOK(res2) || !iter2) {
2308	<	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 &""'");
2282	>	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2283	>	PyObject *obj;
2284	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2285	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2286	>	Py_INCREF(obj);
2287	>	return Py_BuildValue((char *)"");
2288	>	}
2289	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2290	>	PyObject *resultobj;
2291	>	std::string arg1 = (std::string) "" ;
2292	>	std::string arg2 = (std::string) "2" ;
2293	>	std::string arg3 = (std::string) "" ;
2294	>	std::string arg4 = (std::string) "" ;
2295	>	BossSession *result;
2296	>	PyObject * obj0 = 0 ;
2297	>	PyObject * obj1 = 0 ;
2298	>	PyObject * obj2 = 0 ;
2299	>	PyObject * obj3 = 0 ;
2300	>
2301	>	if(!PyArg_ParseTuple(args,(char *)"|OOOO:new_BossSession",&obj0,&obj1,&obj2,&obj3)) goto fail;
2302	>	if (obj0) {
2303	>	{
2304	>	if (PyString_Check(obj0))
2305	>	arg1 = std::string(PyString_AsString(obj0));
2306	>	else
2307	>	SWIG_exception(SWIG_TypeError, "string expected");
2308	>	}
2309		}
2310	<	arg4 = ptr;
2311	<	}
2312	<	{
2313	<	try {
2314	<	(arg1)->insert(arg2,arg3,(std::vector<std::string >::value_type const &)*arg4);
2315	<	} catch (const std::exception& e) {
2316	<	SWIG_exception(SWIG_RuntimeError, e.what());
2310	>	if (obj1) {
2311	>	{
2312	>	if (PyString_Check(obj1))
2313	>	arg2 = std::string(PyString_AsString(obj1));
2314	>	else
2315	>	SWIG_exception(SWIG_TypeError, "string expected");
2316	>	}
2317		}
2318	<	}
2319	<	resultobj = SWIG_Py_Void();
2320	<	if (SWIG_IsNewObj(res4)) delete arg4;
2321	<	return resultobj;
2322	<	fail:
2323	<	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);
2318	>	if (obj2) {
2319	>	{
2320	>	if (PyString_Check(obj2))
2321	>	arg3 = std::string(PyString_AsString(obj2));
2322	>	else
2323	>	SWIG_exception(SWIG_TypeError, "string expected");
2324		}
9200	–	}
2325		}
2326	<	}
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) {
2326	>	if (obj3) {
2327		{
2328	<	int res = SWIG_AsVal_size_t(argv[2], NULL);
2329	<	_v = SWIG_CheckState(res);
2328	>	if (PyString_Check(obj3))
2329	>	arg4 = std::string(PyString_AsString(obj3));
2330	>	else
2331	>	SWIG_exception(SWIG_TypeError, "string expected");
2332		}
2333	<	if (_v) {
2334	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
2335	<	_v = SWIG_CheckState(res);
2336	<	if (_v) {
2337	<	return _wrap_vector_string_insert__SWIG_1(self, args);
2338	<	}
2333	>	}
2334	>	{
2335	>	try {
2336	>	result = (BossSession *)new BossSession(arg1,arg2,arg3,arg4);
2337	>
2338	>	}catch (const BossSchedFailure & e) {
2339	>	PyErr_SetString ( SchedulerError, e.what() );
2340	>	return NULL;
2341	>	}catch (const std::exception& e) {
2342	>	PyErr_SetString ( BossError, e.what() );
2343	>	return NULL;
2344		}
9223	–	}
2345		}
2346	<	}
2347	<
2348	<	fail:
2349	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_insert'");
9229	<	return NULL;
2346	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2347	>	return resultobj;
2348	>	fail:
2349	>	return NULL;
2350		}
2351
2352
2353	<	SWIGINTERN PyObject *_wrap_vector_string_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2354	<	PyObject *resultobj = 0;
2355	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2356	<	std::vector<std::string >::size_type arg2 ;
2357	<	void *argp1 = 0 ;
2358	<	int res1 = 0 ;
2359	<	size_t val2 ;
2360	<	int ecode2 = 0 ;
2361	<	PyObject * obj0 = 0 ;
2362	<	PyObject * obj1 = 0 ;
2363	<
2364	<	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_reserve",&obj0,&obj1)) SWIG_fail;
2365	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2366	<	if (!SWIG_IsOK(res1)) {
2367	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_reserve" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2368	<	}
2369	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2370	<	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());
2353	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2354	>	PyObject *resultobj;
2355	>	BossSession *arg1 = (BossSession *) 0 ;
2356	>	PyObject * obj0 = 0 ;
2357	>
2358	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2359	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2360	>	{
2361	>	try {
2362	>	delete arg1;
2363	>
2364	>	}catch (const BossSchedFailure & e) {
2365	>	PyErr_SetString ( SchedulerError, e.what() );
2366	>	return NULL;
2367	>	}catch (const std::exception& e) {
2368	>	PyErr_SetString ( BossError, e.what() );
2369	>	return NULL;
2370	>	}
2371		}
2372	<	}
2373	<	resultobj = SWIG_Py_Void();
2374	<	return resultobj;
2375	<	fail:
9265	<	return NULL;
2372	>	Py_INCREF(Py_None); resultobj = Py_None;
2373	>	return resultobj;
2374	>	fail:
2375	>	return NULL;
2376		}
2377
2378
2379	<	SWIGINTERN PyObject *_wrap_vector_string_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2380	<	PyObject *resultobj = 0;
2381	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2382	<	std::vector<std::string >::size_type result;
2383	<	void *argp1 = 0 ;
2384	<	int res1 = 0 ;
2385	<	PyObject * obj0 = 0 ;
2386	<
2387	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_capacity",&obj0)) SWIG_fail;
2388	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2389	<	if (!SWIG_IsOK(res1)) {
2390	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_capacity" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
2391	<	}
2392	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2393	<	{
2394	<	try {
2395	<	result = ((std::vector<std::string > const *)arg1)->capacity();
2396	<	} catch (const std::exception& e) {
9287	<	SWIG_exception(SWIG_RuntimeError, e.what());
2379	>	static PyObject *_wrap_BossSession_resetDB(PyObject *self, PyObject *args) {
2380	>	PyObject *resultobj;
2381	>	BossSession *arg1 = (BossSession *) 0 ;
2382	>	PyObject * obj0 = 0 ;
2383	>
2384	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_resetDB",&obj0)) goto fail;
2385	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2386	>	{
2387	>	try {
2388	>	(arg1)->resetDB();
2389	>
2390	>	}catch (const BossSchedFailure & e) {
2391	>	PyErr_SetString ( SchedulerError, e.what() );
2392	>	return NULL;
2393	>	}catch (const std::exception& e) {
2394	>	PyErr_SetString ( BossError, e.what() );
2395	>	return NULL;
2396	>	}
2397		}
2398	<	}
2399	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
2400	<	return resultobj;
2401	<	fail:
9293	<	return NULL;
2398	>	Py_INCREF(Py_None); resultobj = Py_None;
2399	>	return resultobj;
2400	>	fail:
2401	>	return NULL;
2402		}
2403
2404
2405	<	SWIGINTERN PyObject *_wrap_delete_vector_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2406	<	PyObject *resultobj = 0;
2407	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2408	<	void *argp1 = 0 ;
2409	<	int res1 = 0 ;
2410	<	PyObject * obj0 = 0 ;
2411	<
2412	<	if (!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) SWIG_fail;
2413	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_DISOWN |  0 );
2414	<	if (!SWIG_IsOK(res1)) {
2415	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vector_string" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2416	<	}
2417	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2418	<	{
2419	<	try {
2420	<	delete arg1;
2421	<
2422	<	} catch (const std::exception& e) {
9315	<	SWIG_exception(SWIG_RuntimeError, e.what());
2405	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2406	>	PyObject *resultobj;
2407	>	BossSession *arg1 = (BossSession *) 0 ;
2408	>	PyObject * obj0 = 0 ;
2409	>
2410	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2411	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2412	>	{
2413	>	try {
2414	>	(arg1)->clear();
2415	>
2416	>	}catch (const BossSchedFailure & e) {
2417	>	PyErr_SetString ( SchedulerError, e.what() );
2418	>	return NULL;
2419	>	}catch (const std::exception& e) {
2420	>	PyErr_SetString ( BossError, e.what() );
2421	>	return NULL;
2422	>	}
2423		}
2424	<	}
2425	<	resultobj = SWIG_Py_Void();
2426	<	return resultobj;
2427	<	fail:
9321	<	return NULL;
2424	>	Py_INCREF(Py_None); resultobj = Py_None;
2425	>	return resultobj;
2426	>	fail:
2427	>	return NULL;
2428		}
2429
2430
2431	<	SWIGINTERN PyObject *vector_string_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2432	<	PyObject *obj;
2433	<	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
2434	<	SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_NewClientData(obj));
2435	<	return SWIG_Py_Void();
2436	<	}
2437	<
2438	<	SWIGINTERN PyObject *_wrap_new_BossSession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2439	<	PyObject *resultobj = 0;
2440	<	std::string arg1 ;
2441	<	BossSession *result = 0 ;
2442	<	PyObject * obj0 = 0 ;
2443	<
2444	<	if (!PyArg_ParseTuple(args,(char *)"O:new_BossSession",&obj0)) SWIG_fail;
2445	<	{
2446	<	std::string *ptr = (std::string *)0;
2447	<	int res = SWIG_AsPtr_std_string(obj0, &ptr);
2448	<	if (!SWIG_IsOK(res) || !ptr) {
2449	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BossSession" "', argument " "1"" of type '" "std::string""'");
2450	<	}
2451	<	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());
2431	>	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2432	>	PyObject *resultobj;
2433	>	BossSession *arg1 = (BossSession *) 0 ;
2434	>	std::string const &arg2_defvalue = "" ;
2435	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
2436	>	BossTask *result;
2437	>	std::string temp2 ;
2438	>	PyObject * obj0 = 0 ;
2439	>	PyObject * obj1 = 0 ;
2440	>
2441	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2442	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2443	>	if (obj1) {
2444	>	{
2445	>	if (PyString_Check(obj1)) {
2446	>	temp2 = std::string(PyString_AsString(obj1));
2447	>	arg2 = &temp2;
2448	>	}else {
2449	>	SWIG_exception(SWIG_TypeError, "string expected");
2450	>	}
2451	>	}
2452		}
2453	<	}
2454	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossSession, SWIG_POINTER_NEW |  0 );
2455	<	return resultobj;
2456	<	fail:
2457	<	return NULL;
2458	<	}
2459	<
2460	<
2461	<	SWIGINTERN PyObject *_wrap_new_BossSession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2462	<	PyObject *resultobj = 0;
2463	<	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());
2453	>	{
2454	>	try {
2455	>	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2456	>
2457	>	}catch (const BossSchedFailure & e) {
2458	>	PyErr_SetString ( SchedulerError, e.what() );
2459	>	return NULL;
2460	>	}catch (const std::exception& e) {
2461	>	PyErr_SetString ( BossError, e.what() );
2462	>	return NULL;
2463	>	}
2464		}
2465	<	}
2466	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossSession, SWIG_POINTER_NEW |  0 );
2467	<	return resultobj;
2468	<	fail:
9377	<	return NULL;
2465	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2466	>	return resultobj;
2467	>	fail:
2468	>	return NULL;
2469		}
2470
2471
2472	<	SWIGINTERN PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2473	<	int argc;
2474	<	PyObject *argv[2];
2475	<	int ii;
2476	<
2477	<	if (!PyTuple_Check(args)) SWIG_fail;
2478	<	argc = PyObject_Length(args);
2479	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2480	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2481	<	}
2482	<	if (argc == 0) {
2483	<	return _wrap_new_BossSession__SWIG_1(self, args);
2484	<	}
2485	<	if (argc == 1) {
2486	<	int _v;
2487	<	int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
2488	<	_v = SWIG_CheckState(res);
2489	<	if (_v) {
2490	<	return _wrap_new_BossSession__SWIG_0(self, args);
2472	>	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2473	>	PyObject *resultobj;
2474	>	BossSession *arg1 = (BossSession *) 0 ;
2475	>	BossTask *arg2 = (BossTask *) 0 ;
2476	>	PyObject * obj0 = 0 ;
2477	>	PyObject * obj1 = 0 ;
2478	>
2479	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2480	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2481	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2482	>	{
2483	>	try {
2484	>	(arg1)->destroyBossTask(arg2);
2485	>
2486	>	}catch (const BossSchedFailure & e) {
2487	>	PyErr_SetString ( SchedulerError, e.what() );
2488	>	return NULL;
2489	>	}catch (const std::exception& e) {
2490	>	PyErr_SetString ( BossError, e.what() );
2491	>	return NULL;
2492	>	}
2493		}
2494	<	}
2495	<
2496	<	fail:
2497	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BossSession'");
9405	<	return NULL;
2494	>	Py_INCREF(Py_None); resultobj = Py_None;
2495	>	return resultobj;
2496	>	fail:
2497	>	return NULL;
2498		}
2499
2500
2501	<	SWIGINTERN PyObject *_wrap_delete_BossSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2502	<	PyObject *resultobj = 0;
2503	<	BossSession *arg1 = (BossSession *) 0 ;
2504	<	void *argp1 = 0 ;
2505	<	int res1 = 0 ;
2506	<	PyObject * obj0 = 0 ;
2507	<
2508	<	if (!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) SWIG_fail;
2509	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, SWIG_POINTER_DISOWN |  0 );
2510	<	if (!SWIG_IsOK(res1)) {
2511	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BossSession" "', argument " "1"" of type '" "BossSession *""'");
2512	<	}
2513	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2514	<	{
2515	<	try {
2516	<	delete arg1;
2517	<
2518	<	} catch (const std::exception& e) {
2519	<	SWIG_exception(SWIG_RuntimeError, e.what());
2501	>	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
2502	>	PyObject *resultobj;
2503	>	BossSession *arg1 = (BossSession *) 0 ;
2504	>	std::vector<std::string > result;
2505	>	PyObject * obj0 = 0 ;
2506	>
2507	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
2508	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2509	>	{
2510	>	try {
2511	>	result = (arg1)->showCHTools();
2512	>
2513	>	}catch (const BossSchedFailure & e) {
2514	>	PyErr_SetString ( SchedulerError, e.what() );
2515	>	return NULL;
2516	>	}catch (const std::exception& e) {
2517	>	PyErr_SetString ( BossError, e.what() );
2518	>	return NULL;
2519	>	}
2520		}
2521	<	}
2522	<	resultobj = SWIG_Py_Void();
2523	<	return resultobj;
2524	<	fail:
2525	<	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());
2521	>	{
2522	>	resultobj = PyTuple_New((&result)->size());
2523	>	for (unsigned int i=0; i<(&result)->size(); i++)
2524	>	PyTuple_SetItem(resultobj,i,
2525	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2526		}
2527	<	}
2528	<	resultobj = SWIG_Py_Void();
2529	<	return resultobj;
9459	<	fail:
9460	<	return NULL;
2527	>	return resultobj;
2528	>	fail:
2529	>	return NULL;
2530		}
2531
2532
2533	<	SWIGINTERN PyObject *_wrap_BossSession_makeBossTask__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2534	<	PyObject *resultobj = 0;
2535	<	BossSession *arg1 = (BossSession *) 0 ;
2536	<	std::string *arg2 = 0 ;
2537	<	BossTask *result = 0 ;
2538	<	void *argp1 = 0 ;
2539	<	int res1 = 0 ;
2540	<	int res2 = SWIG_OLDOBJ ;
2541	<	PyObject * obj0 = 0 ;
2542	<	PyObject * obj1 = 0 ;
2543	<
2544	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_makeBossTask",&obj0,&obj1)) SWIG_fail;
2545	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2546	<	if (!SWIG_IsOK(res1)) {
2547	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_makeBossTask" "', argument " "1"" of type '" "BossSession *""'");
2548	<	}
2549	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2550	<	{
2551	<	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());
2533	>	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
2534	>	PyObject *resultobj;
2535	>	BossSession *arg1 = (BossSession *) 0 ;
2536	>	std::vector<std::string > result;
2537	>	PyObject * obj0 = 0 ;
2538	>
2539	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
2540	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2541	>	{
2542	>	try {
2543	>	result = (arg1)->showProgramTypes();
2544	>
2545	>	}catch (const BossSchedFailure & e) {
2546	>	PyErr_SetString ( SchedulerError, e.what() );
2547	>	return NULL;
2548	>	}catch (const std::exception& e) {
2549	>	PyErr_SetString ( BossError, e.what() );
2550	>	return NULL;
2551	>	}
2552		}
2553	<	}
2554	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, 0 |  0 );
2555	<	if (SWIG_IsNewObj(res2)) delete arg2;
2556	<	return resultobj;
2557	<	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());
2553	>	{
2554	>	resultobj = PyTuple_New((&result)->size());
2555	>	for (unsigned int i=0; i<(&result)->size(); i++)
2556	>	PyTuple_SetItem(resultobj,i,
2557	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2558		}
2559	<	}
2560	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, 0 |  0 );
2561	<	return resultobj;
9531	<	fail:
9532	<	return NULL;
2559	>	return resultobj;
2560	>	fail:
2561	>	return NULL;
2562		}
2563
2564
2565	<	SWIGINTERN PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2566	<	int argc;
2567	<	PyObject *argv[3];
2568	<	int ii;
2569	<
2570	<	if (!PyTuple_Check(args)) SWIG_fail;
2571	<	argc = PyObject_Length(args);
2572	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
2573	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2574	<	}
2575	<	if (argc == 1) {
2576	<	int _v;
2577	<	void *vptr = 0;
2578	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2579	<	_v = SWIG_CheckState(res);
2580	<	if (_v) {
2581	<	return _wrap_BossSession_makeBossTask__SWIG_1(self, args);
2582	<	}
2583	<	}
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	<	}
2565	>	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
2566	>	PyObject *resultobj;
2567	>	BossSession *arg1 = (BossSession *) 0 ;
2568	>	std::vector<std::string > result;
2569	>	PyObject * obj0 = 0 ;
2570	>
2571	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
2572	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2573	>	{
2574	>	try {
2575	>	result = (arg1)->showRTMon();
2576	>
2577	>	}catch (const BossSchedFailure & e) {
2578	>	PyErr_SetString ( SchedulerError, e.what() );
2579	>	return NULL;
2580	>	}catch (const std::exception& e) {
2581	>	PyErr_SetString ( BossError, e.what() );
2582	>	return NULL;
2583	>	}
2584		}
2585	<	}
2586	<
2587	<	fail:
2588	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_makeBossTask'");
2589	<	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());
2585	>	{
2586	>	resultobj = PyTuple_New((&result)->size());
2587	>	for (unsigned int i=0; i<(&result)->size(); i++)
2588	>	PyTuple_SetItem(resultobj,i,
2589	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2590		}
2591	<	}
2592	<	resultobj = SWIG_Py_Void();
2593	<	return resultobj;
9606	<	fail:
9607	<	return NULL;
2591	>	return resultobj;
2592	>	fail:
2593	>	return NULL;
2594		}
2595
2596
2597	<	SWIGINTERN PyObject *_wrap_BossSession_defaultCHTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2598	<	PyObject *resultobj = 0;
2599	<	BossSession *arg1 = (BossSession *) 0 ;
2600	<	std::string result;
2601	<	void *argp1 = 0 ;
2602	<	int res1 = 0 ;
2603	<	PyObject * obj0 = 0 ;
2604	<
2605	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) SWIG_fail;
2606	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2607	<	if (!SWIG_IsOK(res1)) {
2608	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultCHTool" "', argument " "1"" of type '" "BossSession *""'");
2609	<	}
2610	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2611	<	{
2612	<	try {
2613	<	result = (arg1)->defaultCHTool();
2614	<	} catch (const std::exception& e) {
2615	<	SWIG_exception(SWIG_RuntimeError, e.what());
2597	>	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
2598	>	PyObject *resultobj;
2599	>	BossSession *arg1 = (BossSession *) 0 ;
2600	>	std::vector<std::string > result;
2601	>	PyObject * obj0 = 0 ;
2602	>
2603	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
2604	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2605	>	{
2606	>	try {
2607	>	result = (arg1)->showSchedulers();
2608	>
2609	>	}catch (const BossSchedFailure & e) {
2610	>	PyErr_SetString ( SchedulerError, e.what() );
2611	>	return NULL;
2612	>	}catch (const std::exception& e) {
2613	>	PyErr_SetString ( BossError, e.what() );
2614	>	return NULL;
2615	>	}
2616		}
2617	<	}
2618	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2619	<	return resultobj;
2620	<	fail:
2621	<	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());
2617	>	{
2618	>	resultobj = PyTuple_New((&result)->size());
2619	>	for (unsigned int i=0; i<(&result)->size(); i++)
2620	>	PyTuple_SetItem(resultobj,i,
2621	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2622		}
2623	<	}
2624	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2625	<	return resultobj;
9662	<	fail:
9663	<	return NULL;
2623	>	return resultobj;
2624	>	fail:
2625	>	return NULL;
2626		}
2627
2628
2629	<	SWIGINTERN PyObject *_wrap_BossSession_defaultRTMon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2630	<	PyObject *resultobj = 0;
2631	<	BossSession *arg1 = (BossSession *) 0 ;
2632	<	std::string result;
2633	<	void *argp1 = 0 ;
2634	<	int res1 = 0 ;
2635	<	PyObject * obj0 = 0 ;
2636	<
2637	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) SWIG_fail;
2638	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2639	<	if (!SWIG_IsOK(res1)) {
2640	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultRTMon" "', argument " "1"" of type '" "BossSession *""'");
2641	<	}
2642	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2643	<	{
2644	<	try {
2645	<	result = (arg1)->defaultRTMon();
2646	<	} catch (const std::exception& e) {
2647	<	SWIG_exception(SWIG_RuntimeError, e.what());
2629	>	static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
2630	>	PyObject *resultobj;
2631	>	BossSession *arg1 = (BossSession *) 0 ;
2632	>	std::string result;
2633	>	PyObject * obj0 = 0 ;
2634	>
2635	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) goto fail;
2636	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2637	>	{
2638	>	try {
2639	>	result = (arg1)->defaultCHTool();
2640	>
2641	>	}catch (const BossSchedFailure & e) {
2642	>	PyErr_SetString ( SchedulerError, e.what() );
2643	>	return NULL;
2644	>	}catch (const std::exception& e) {
2645	>	PyErr_SetString ( BossError, e.what() );
2646	>	return NULL;
2647	>	}
2648		}
2649	<	}
2650	<	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());
2649	>	{
2650	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2651		}
2652	<	}
2653	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2654	<	return resultobj;
9718	<	fail:
9719	<	return NULL;
2652	>	return resultobj;
2653	>	fail:
2654	>	return NULL;
2655		}
2656
2657
2658	<	SWIGINTERN PyObject *_wrap_BossSession_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2659	<	PyObject *resultobj = 0;
2660	<	BossSession *arg1 = (BossSession *) 0 ;
2661	<	std::string result;
2662	<	void *argp1 = 0 ;
2663	<	int res1 = 0 ;
2664	<	PyObject * obj0 = 0 ;
2665	<
2666	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) SWIG_fail;
2667	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2668	<	if (!SWIG_IsOK(res1)) {
2669	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_version" "', argument " "1"" of type '" "BossSession *""'");
2670	<	}
2671	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2672	<	{
2673	<	try {
2674	<	result = (arg1)->version();
2675	<	} catch (const std::exception& e) {
2676	<	SWIG_exception(SWIG_RuntimeError, e.what());
2658	>	static PyObject *_wrap_BossSession_defaultProgramType(PyObject *self, PyObject *args) {
2659	>	PyObject *resultobj;
2660	>	BossSession *arg1 = (BossSession *) 0 ;
2661	>	std::string result;
2662	>	PyObject * obj0 = 0 ;
2663	>
2664	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) goto fail;
2665	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2666	>	{
2667	>	try {
2668	>	result = (arg1)->defaultProgramType();
2669	>
2670	>	}catch (const BossSchedFailure & e) {
2671	>	PyErr_SetString ( SchedulerError, e.what() );
2672	>	return NULL;
2673	>	}catch (const std::exception& e) {
2674	>	PyErr_SetString ( BossError, e.what() );
2675	>	return NULL;
2676	>	}
2677		}
2678	<	}
2679	<	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());
2678	>	{
2679	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2680		}
2681	<	}
2682	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2683	<	return resultobj;
9774	<	fail:
9775	<	return NULL;
2681	>	return resultobj;
2682	>	fail:
2683	>	return NULL;
2684		}
2685
2686
2687	<	SWIGINTERN PyObject *_wrap_BossSession_showConfigs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2688	<	PyObject *resultobj = 0;
2689	<	BossSession *arg1 = (BossSession *) 0 ;
2690	<	bool arg2 ;
2691	<	int result;
2692	<	void *argp1 = 0 ;
2693	<	int res1 = 0 ;
2694	<	bool val2 ;
2695	<	int ecode2 = 0 ;
2696	<	PyObject * obj0 = 0 ;
2697	<	PyObject * obj1 = 0 ;
2698	<
2699	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_showConfigs",&obj0,&obj1)) SWIG_fail;
2700	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2701	<	if (!SWIG_IsOK(res1)) {
2702	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_showConfigs" "', argument " "1"" of type '" "BossSession *""'");
2703	<	}
2704	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2705	<	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());
2687	>	static PyObject *_wrap_BossSession_defaultRTMon(PyObject *self, PyObject *args) {
2688	>	PyObject *resultobj;
2689	>	BossSession *arg1 = (BossSession *) 0 ;
2690	>	std::string result;
2691	>	PyObject * obj0 = 0 ;
2692	>
2693	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) goto fail;
2694	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2695	>	{
2696	>	try {
2697	>	result = (arg1)->defaultRTMon();
2698	>
2699	>	}catch (const BossSchedFailure & e) {
2700	>	PyErr_SetString ( SchedulerError, e.what() );
2701	>	return NULL;
2702	>	}catch (const std::exception& e) {
2703	>	PyErr_SetString ( BossError, e.what() );
2704	>	return NULL;
2705	>	}
2706		}
2707	<	}
2708	<	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());
2707	>	{
2708	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2709		}
2710	<	}
2711	<	resultobj = SWIG_From_int(static_cast< int >(result));
2712	<	return resultobj;
9839	<	fail:
9840	<	return NULL;
2710	>	return resultobj;
2711	>	fail:
2712	>	return NULL;
2713		}
2714
2715
2716	<	SWIGINTERN PyObject *_wrap_BossSession_showConfigs(PyObject *self, PyObject *args) {
2717	<	int argc;
2718	<	PyObject *argv[3];
2719	<	int ii;
2720	<
2721	<	if (!PyTuple_Check(args)) SWIG_fail;
2722	<	argc = PyObject_Length(args);
2723	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
2724	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2725	<	}
2726	<	if (argc == 1) {
2727	<	int _v;
2728	<	void *vptr = 0;
2729	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2730	<	_v = SWIG_CheckState(res);
2731	<	if (_v) {
2732	<	return _wrap_BossSession_showConfigs__SWIG_1(self, args);
2716	>	static PyObject *_wrap_BossSession_defaultScheduler(PyObject *self, PyObject *args) {
2717	>	PyObject *resultobj;
2718	>	BossSession *arg1 = (BossSession *) 0 ;
2719	>	std::string result;
2720	>	PyObject * obj0 = 0 ;
2721	>
2722	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) goto fail;
2723	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2724	>	{
2725	>	try {
2726	>	result = (arg1)->defaultScheduler();
2727	>
2728	>	}catch (const BossSchedFailure & e) {
2729	>	PyErr_SetString ( SchedulerError, e.what() );
2730	>	return NULL;
2731	>	}catch (const std::exception& e) {
2732	>	PyErr_SetString ( BossError, e.what() );
2733	>	return NULL;
2734	>	}
2735		}
2736	<	}
2737	<	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	<	}
2736	>	{
2737	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2738		}
2739	<	}
2740	<
2741	<	fail:
9880	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_showConfigs'");
9881	<	return NULL;
2739	>	return resultobj;
2740	>	fail:
2741	>	return NULL;
2742		}
2743
2744
2745	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2746	<	PyObject *resultobj = 0;
2747	<	BossSession *arg1 = (BossSession *) 0 ;
2748	<	std::string arg2 ;
2749	<	std::string arg3 ;
2750	<	std::string arg4 ;
2751	<	int result;
2752	<	void *argp1 = 0 ;
2753	<	int res1 = 0 ;
2754	<	PyObject * obj0 = 0 ;
2755	<	PyObject * obj1 = 0 ;
2756	<	PyObject * obj2 = 0 ;
2757	<	PyObject * obj3 = 0 ;
2758	<
2759	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
2760	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2761	<	if (!SWIG_IsOK(res1)) {
2762	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTupdate" "', argument " "1"" of type '" "BossSession *""'");
2763	<	}
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""'");
2745	>	static PyObject *_wrap_BossSession_version(PyObject *self, PyObject *args) {
2746	>	PyObject *resultobj;
2747	>	BossSession *arg1 = (BossSession *) 0 ;
2748	>	std::string result;
2749	>	PyObject * obj0 = 0 ;
2750	>
2751	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) goto fail;
2752	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2753	>	{
2754	>	try {
2755	>	result = (arg1)->version();
2756	>
2757	>	}catch (const BossSchedFailure & e) {
2758	>	PyErr_SetString ( SchedulerError, e.what() );
2759	>	return NULL;
2760	>	}catch (const std::exception& e) {
2761	>	PyErr_SetString ( BossError, e.what() );
2762	>	return NULL;
2763	>	}
2764		}
2765	<	arg4 = *ptr;
2766	<	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());
2765	>	{
2766	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2767		}
2768	<	}
2769	<	resultobj = SWIG_From_int(static_cast< int >(result));
2770	<	return resultobj;
9941	<	fail:
9942	<	return NULL;
2768	>	return resultobj;
2769	>	fail:
2770	>	return NULL;
2771		}
2772
2773
2774	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2775	<	PyObject *resultobj = 0;
2776	<	BossSession *arg1 = (BossSession *) 0 ;
2777	<	std::string arg2 ;
2778	<	std::string arg3 ;
2779	<	int result;
2780	<	void *argp1 = 0 ;
2781	<	int res1 = 0 ;
2782	<	PyObject * obj0 = 0 ;
2783	<	PyObject * obj1 = 0 ;
2784	<	PyObject * obj2 = 0 ;
2785	<
2786	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_RTupdate",&obj0,&obj1,&obj2)) SWIG_fail;
2787	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2788	<	if (!SWIG_IsOK(res1)) {
2789	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTupdate" "', argument " "1"" of type '" "BossSession *""'");
2790	<	}
2791	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2792	<	{
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""'");
2774	>	static PyObject *_wrap_BossSession_clientID(PyObject *self, PyObject *args) {
2775	>	PyObject *resultobj;
2776	>	BossSession *arg1 = (BossSession *) 0 ;
2777	>	std::string result;
2778	>	PyObject * obj0 = 0 ;
2779	>
2780	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) goto fail;
2781	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2782	>	{
2783	>	try {
2784	>	result = (arg1)->clientID();
2785	>
2786	>	}catch (const BossSchedFailure & e) {
2787	>	PyErr_SetString ( SchedulerError, e.what() );
2788	>	return NULL;
2789	>	}catch (const std::exception& e) {
2790	>	PyErr_SetString ( BossError, e.what() );
2791	>	return NULL;
2792	>	}
2793		}
2794	<	arg3 = *ptr;
2795	<	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());
2794	>	{
2795	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2796		}
2797	<	}
2798	<	resultobj = SWIG_From_int(static_cast< int >(result));
2799	<	return resultobj;
9991	<	fail:
9992	<	return NULL;
2797	>	return resultobj;
2798	>	fail:
2799	>	return NULL;
2800		}
2801
2802
2803	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2804	<	PyObject *resultobj = 0;
2805	<	BossSession *arg1 = (BossSession *) 0 ;
2806	<	std::string arg2 ;
2807	<	int result;
2808	<	void *argp1 = 0 ;
2809	<	int res1 = 0 ;
2810	<	PyObject * obj0 = 0 ;
2811	<	PyObject * obj1 = 0 ;
2812	<
2813	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_RTupdate",&obj0,&obj1)) SWIG_fail;
2814	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2815	<	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());
2803	>	static PyObject *_wrap_BossSession_showConfigs(PyObject *self, PyObject *args) {
2804	>	PyObject *resultobj;
2805	>	BossSession *arg1 = (BossSession *) 0 ;
2806	>	bool arg2 = (bool) false ;
2807	>	int result;
2808	>	PyObject * obj0 = 0 ;
2809	>	PyObject * obj1 = 0 ;
2810	>
2811	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_showConfigs",&obj0,&obj1)) goto fail;
2812	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2813	>	if (obj1) {
2814	>	arg2 = PyInt_AsLong(obj1) ? true : false;
2815	>	if (PyErr_Occurred()) SWIG_fail;
2816		}
2817	<	}
2818	<	resultobj = SWIG_From_int(static_cast< int >(result));
2819	<	return resultobj;
2820	<	fail:
2821	<	return NULL;
2822	<	}
2823	<
2824	<
2825	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2826	<	PyObject *resultobj = 0;
2827	<	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());
2817	>	{
2818	>	try {
2819	>	result = (int)(arg1)->showConfigs(arg2);
2820	>
2821	>	}catch (const BossSchedFailure & e) {
2822	>	PyErr_SetString ( SchedulerError, e.what() );
2823	>	return NULL;
2824	>	}catch (const std::exception& e) {
2825	>	PyErr_SetString ( BossError, e.what() );
2826	>	return NULL;
2827	>	}
2828		}
2829	<	}
2830	<	resultobj = SWIG_From_int(static_cast< int >(result));
2831	<	return resultobj;
2832	<	fail:
10059	<	return NULL;
2829	>	resultobj = PyInt_FromLong((long)result);
2830	>	return resultobj;
2831	>	fail:
2832	>	return NULL;
2833		}
2834
2835
2836	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2837	<	int argc;
2838	<	PyObject *argv[5];
2839	<	int ii;
2840	<
2841	<	if (!PyTuple_Check(args)) SWIG_fail;
2842	<	argc = PyObject_Length(args);
2843	<	for (ii = 0; (ii < argc) && (ii < 4); ii++) {
2844	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2845	<	}
2846	<	if (argc == 1) {
2847	<	int _v;
2848	<	void *vptr = 0;
2849	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2850	<	_v = SWIG_CheckState(res);
2851	<	if (_v) {
2852	<	return _wrap_BossSession_RTupdate__SWIG_3(self, args);
2853	<	}
2854	<	}
2855	<	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);
2836	>	static PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2837	>	PyObject *resultobj;
2838	>	BossSession *arg1 = (BossSession *) 0 ;
2839	>	std::string arg2 = (std::string) "all" ;
2840	>	std::string arg3 = (std::string) "all" ;
2841	>	std::string arg4 = (std::string) "" ;
2842	>	int result;
2843	>	PyObject * obj0 = 0 ;
2844	>	PyObject * obj1 = 0 ;
2845	>	PyObject * obj2 = 0 ;
2846	>	PyObject * obj3 = 0 ;
2847	>
2848	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
2849	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2850	>	if (obj1) {
2851	>	{
2852	>	if (PyString_Check(obj1))
2853	>	arg2 = std::string(PyString_AsString(obj1));
2854	>	else
2855	>	SWIG_exception(SWIG_TypeError, "string expected");
2856		}
10109	–	}
2857		}
2858	<	}
2859	<	if (argc == 4) {
2860	<	int _v;
2861	<	void *vptr = 0;
2862	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2863	<	_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	<	}
2858	>	if (obj2) {
2859	>	{
2860	>	if (PyString_Check(obj2))
2861	>	arg3 = std::string(PyString_AsString(obj2));
2862	>	else
2863	>	SWIG_exception(SWIG_TypeError, "string expected");
2864		}
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 &""'");
2865		}
2866	<	arg3 = ptr;
2867	<	}
2868	<	ecode4 = SWIG_AsVal_bool(obj3, &val4);
2869	<	if (!SWIG_IsOK(ecode4)) {
2870	<	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossSession_listMatch" "', argument " "4"" of type '" "bool""'");
2871	<	}
2872	<	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 &""'");
10358	<	}
10359	<	arg2 = ptr;
10360	<	}
10361	<	{
10362	<	std::string *ptr = (std::string *)0;
10363	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10364	<	if (!SWIG_IsOK(res3)) {
10365	<	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 &""'");
2866	>	if (obj3) {
2867	>	{
2868	>	if (PyString_Check(obj3))
2869	>	arg4 = std::string(PyString_AsString(obj3));
2870	>	else
2871	>	SWIG_exception(SWIG_TypeError, "string expected");
2872	>	}
2873		}
2874	<	arg3 = ptr;
2875	<	}
2876	<	{
2877	<	try {
2878	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3);
2879	<	} catch (const std::exception& e) {
2880	<	SWIG_exception(SWIG_RuntimeError, e.what());
2874	>	{
2875	>	try {
2876	>	result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2877	>
2878	>	}catch (const BossSchedFailure & e) {
2879	>	PyErr_SetString ( SchedulerError, e.what() );
2880	>	return NULL;
2881	>	}catch (const std::exception& e) {
2882	>	PyErr_SetString ( BossError, e.what() );
2883	>	return NULL;
2884	>	}
2885		}
2886	<	}
2887	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
2888	<	if (SWIG_IsNewObj(res2)) delete arg2;
2889	<	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;
2886	>	resultobj = PyInt_FromLong((long)result);
2887	>	return resultobj;
2888	>	fail:
2889	>	return NULL;
2890		}
2891
2892
2893	<	SWIGINTERN PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
2894	<	int argc;
2895	<	PyObject *argv[7];
2896	<	int ii;
2897	<
2898	<	if (!PyTuple_Check(args)) SWIG_fail;
2899	<	argc = PyObject_Length(args);
2900	<	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
2901	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2902	<	}
2903	<	if (argc == 3) {
2904	<	int _v;
2905	<	void *vptr = 0;
2906	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2907	<	_v = SWIG_CheckState(res);
2908	<	if (_v) {
2909	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
2910	<	_v = SWIG_CheckState(res);
2911	<	if (_v) {
2912	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
2913	<	_v = SWIG_CheckState(res);
2914	<	if (_v) {
2915	<	return _wrap_BossSession_listMatch__SWIG_3(self, args);
2893	>	static PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
2894	>	PyObject *resultobj;
2895	>	BossSession *arg1 = (BossSession *) 0 ;
2896	>	std::string *arg2 = 0 ;
2897	>	std::string *arg3 = 0 ;
2898	>	bool arg4 = (bool) false ;
2899	>	std::string const &arg5_defvalue = "" ;
2900	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2901	>	std::string const &arg6_defvalue = "" ;
2902	>	std::string *arg6 = (std::string *) &arg6_defvalue ;
2903	>	unsigned int arg7 = (unsigned int) 0 ;
2904	>	std::vector<std::string > result;
2905	>	std::string temp2 ;
2906	>	std::string temp3 ;
2907	>	std::string temp5 ;
2908	>	std::string temp6 ;
2909	>	PyObject * obj0 = 0 ;
2910	>	PyObject * obj1 = 0 ;
2911	>	PyObject * obj2 = 0 ;
2912	>	PyObject * obj3 = 0 ;
2913	>	PyObject * obj4 = 0 ;
2914	>	PyObject * obj5 = 0 ;
2915	>	PyObject * obj6 = 0 ;
2916	>
2917	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
2918	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2919	>	{
2920	>	if (PyString_Check(obj1)) {
2921	>	temp2 = std::string(PyString_AsString(obj1));
2922	>	arg2 = &temp2;
2923	>	}else {
2924	>	SWIG_exception(SWIG_TypeError, "string expected");
2925		}
10479	–	}
2926		}
2927	<	}
2928	<	if (argc == 4) {
2929	<	int _v;
2930	<	void *vptr = 0;
2931	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2932	<	_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	<	}
2927	>	{
2928	>	if (PyString_Check(obj2)) {
2929	>	temp3 = std::string(PyString_AsString(obj2));
2930	>	arg3 = &temp3;
2931	>	}else {
2932	>	SWIG_exception(SWIG_TypeError, "string expected");
2933		}
10502	–	}
2934		}
2935	<	}
2936	<	if (argc == 5) {
2937	<	int _v;
2938	<	void *vptr = 0;
2939	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2940	<	_v = SWIG_CheckState(res);
2941	<	if (_v) {
2942	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
2943	<	_v = SWIG_CheckState(res);
2944	<	if (_v) {
2945	<	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);
2935	>	if (obj3) {
2936	>	arg4 = PyInt_AsLong(obj3) ? true : false;
2937	>	if (PyErr_Occurred()) SWIG_fail;
2938	>	}
2939	>	if (obj4) {
2940	>	{
2941	>	if (PyString_Check(obj4)) {
2942	>	temp5 = std::string(PyString_AsString(obj4));
2943	>	arg5 = &temp5;
2944	>	}else {
2945	>	SWIG_exception(SWIG_TypeError, "string expected");
2946		}
10527	–	}
2947		}
10529	–	}
2948		}
2949	<	}
2950	<	if (argc == 6) {
2951	<	int _v;
2952	<	void *vptr = 0;
2953	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2954	<	_v = SWIG_CheckState(res);
2955	<	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	<	}
2949	>	if (obj5) {
2950	>	{
2951	>	if (PyString_Check(obj5)) {
2952	>	temp6 = std::string(PyString_AsString(obj5));
2953	>	arg6 = &temp6;
2954	>	}else {
2955	>	SWIG_exception(SWIG_TypeError, "string expected");
2956		}
10558	–	}
2957		}
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 &""'");
2958		}
2959	<	arg5 = ptr;
2960	<	}
2961	<	{
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""'");
2959	>	if (obj6) {
2960	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
2961	>	if (PyErr_Occurred()) SWIG_fail;
2962		}
2963	<	arg6 = *ptr;
2964	<	if (SWIG_IsNewObj(res)) delete ptr;
2965	<	}
2966	<	{
2967	<	std::string *ptr = (std::string *)0;
2968	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
2969	<	if (!SWIG_IsOK(res) || !ptr) {
2970	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "7"" of type '" "std::string""'");
2971	<	}
2972	<	arg7 = *ptr;
2973	<	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""'");
10897	<	}
10898	<	arg7 = *ptr;
10899	<	if (SWIG_IsNewObj(res)) delete ptr;
10900	<	}
10901	<	{
10902	<	try {
10903	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
10904	<	} catch (const std::exception& e) {
10905	<	SWIG_exception(SWIG_RuntimeError, e.what());
10906	<	}
10907	<	}
10908	<	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 &""'");
2963	>	{
2964	>	try {
2965	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
2966	>
2967	>	}catch (const BossSchedFailure & e) {
2968	>	PyErr_SetString ( SchedulerError, e.what() );
2969	>	return NULL;
2970	>	}catch (const std::exception& e) {
2971	>	PyErr_SetString ( BossError, e.what() );
2972	>	return NULL;
2973	>	}
2974		}
2975	<	arg5 = ptr;
2976	<	}
2977	<	{
2978	<	try {
2979	<	(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());
2975	>	{
2976	>	resultobj = PyTuple_New((&result)->size());
2977	>	for (unsigned int i=0; i<(&result)->size(); i++)
2978	>	PyTuple_SetItem(resultobj,i,
2979	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2980		}
2981	<	}
2982	<	resultobj = SWIG_Py_Void();
2983	<	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;
2981	>	return resultobj;
2982	>	fail:
2983	>	return NULL;
2984		}
2985
2986
2987	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2988	<	PyObject *resultobj = 0;
2989	<	BossSession *arg1 = (BossSession *) 0 ;
2990	<	int arg2 ;
2991	<	std::string *arg3 = 0 ;
2992	<	std::string *arg4 = 0 ;
2993	<	void *argp1 = 0 ;
2994	<	int res1 = 0 ;
2995	<	int val2 ;
2996	<	int ecode2 = 0 ;
2997	<	int res3 = SWIG_OLDOBJ ;
2998	<	int res4 = SWIG_OLDOBJ ;
2999	<	PyObject * obj0 = 0 ;
3000	<	PyObject * obj1 = 0 ;
3001	<	PyObject * obj2 = 0 ;
3002	<	PyObject * obj3 = 0 ;
3003	<
3004	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3005	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3006	<	if (!SWIG_IsOK(res1)) {
3007	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
3008	<	}
3009	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3010	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
3011	<	if (!SWIG_IsOK(ecode2)) {
3012	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
3013	<	}
3014	<	arg2 = static_cast< int >(val2);
3015	<	{
3016	<	std::string *ptr = (std::string *)0;
3017	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
3018	<	if (!SWIG_IsOK(res3)) {
3019	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
3020	<	}
3021	<	if (!ptr) {
3022	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
2987	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
2988	>	PyObject *resultobj;
2989	>	BossSession *arg1 = (BossSession *) 0 ;
2990	>	int arg2 = (int) SCHEDULED ;
2991	>	std::string const &arg3_defvalue = "all" ;
2992	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
2993	>	std::string const &arg4_defvalue = "all" ;
2994	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
2995	>	std::string const &arg5_defvalue = "" ;
2996	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2997	>	std::string arg6 = (std::string) "" ;
2998	>	std::string arg7 = (std::string) "" ;
2999	>	std::string arg8 = (std::string) "" ;
3000	>	std::string arg9 = (std::string) "" ;
3001	>	unsigned int arg10 = (unsigned int) 0 ;
3002	>	std::string temp3 ;
3003	>	std::string temp4 ;
3004	>	std::string temp5 ;
3005	>	PyObject * obj0 = 0 ;
3006	>	PyObject * obj2 = 0 ;
3007	>	PyObject * obj3 = 0 ;
3008	>	PyObject * obj4 = 0 ;
3009	>	PyObject * obj5 = 0 ;
3010	>	PyObject * obj6 = 0 ;
3011	>	PyObject * obj7 = 0 ;
3012	>	PyObject * obj8 = 0 ;
3013	>	PyObject * obj9 = 0 ;
3014	>
3015	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3016	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3017	>	if (obj2) {
3018	>	{
3019	>	if (PyString_Check(obj2)) {
3020	>	temp3 = std::string(PyString_AsString(obj2));
3021	>	arg3 = &temp3;
3022	>	}else {
3023	>	SWIG_exception(SWIG_TypeError, "string expected");
3024	>	}
3025	>	}
3026		}
3027	<	arg3 = ptr;
3028	<	}
3029	<	{
3030	<	std::string *ptr = (std::string *)0;
3031	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
3032	<	if (!SWIG_IsOK(res4)) {
3033	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
3027	>	if (obj3) {
3028	>	{
3029	>	if (PyString_Check(obj3)) {
3030	>	temp4 = std::string(PyString_AsString(obj3));
3031	>	arg4 = &temp4;
3032	>	}else {
3033	>	SWIG_exception(SWIG_TypeError, "string expected");
3034	>	}
3035	>	}
3036		}
3037	<	if (!ptr) {
3038	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
3037	>	if (obj4) {
3038	>	{
3039	>	if (PyString_Check(obj4)) {
3040	>	temp5 = std::string(PyString_AsString(obj4));
3041	>	arg5 = &temp5;
3042	>	}else {
3043	>	SWIG_exception(SWIG_TypeError, "string expected");
3044	>	}
3045	>	}
3046		}
3047	<	arg4 = ptr;
3048	<	}
3049	<	{
3050	<	try {
3051	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
3052	<	} catch (const std::exception& e) {
3053	<	SWIG_exception(SWIG_RuntimeError, e.what());
3047	>	if (obj5) {
3048	>	{
3049	>	if (PyString_Check(obj5))
3050	>	arg6 = std::string(PyString_AsString(obj5));
3051	>	else
3052	>	SWIG_exception(SWIG_TypeError, "string expected");
3053	>	}
3054		}
3055	<	}
3056	<	resultobj = SWIG_Py_Void();
3057	<	if (SWIG_IsNewObj(res3)) delete arg3;
3058	<	if (SWIG_IsNewObj(res4)) delete arg4;
3059	<	return resultobj;
3060	<	fail:
3061	<	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 &""'");
3055	>	if (obj6) {
3056	>	{
3057	>	if (PyString_Check(obj6))
3058	>	arg7 = std::string(PyString_AsString(obj6));
3059	>	else
3060	>	SWIG_exception(SWIG_TypeError, "string expected");
3061	>	}
3062		}
3063	<	if (!ptr) {
3064	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
3063	>	if (obj7) {
3064	>	{
3065	>	if (PyString_Check(obj7))
3066	>	arg8 = std::string(PyString_AsString(obj7));
3067	>	else
3068	>	SWIG_exception(SWIG_TypeError, "string expected");
3069	>	}
3070		}
3071	<	arg3 = ptr;
3072	<	}
3073	<	{
3074	<	try {
3075	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3);
3076	<	} catch (const std::exception& e) {
3077	<	SWIG_exception(SWIG_RuntimeError, e.what());
3071	>	if (obj8) {
3072	>	{
3073	>	if (PyString_Check(obj8))
3074	>	arg9 = std::string(PyString_AsString(obj8));
3075	>	else
3076	>	SWIG_exception(SWIG_TypeError, "string expected");
3077	>	}
3078		}
3079	<	}
3080	<	resultobj = SWIG_Py_Void();
3081	<	if (SWIG_IsNewObj(res3)) delete arg3;
11213	<	return resultobj;
11214	<	fail:
11215	<	if (SWIG_IsNewObj(res3)) delete arg3;
11216	<	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());
3079	>	if (obj9) {
3080	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3081	>	if (PyErr_Occurred()) SWIG_fail;
3082		}
3083	<	}
3084	<	resultobj = SWIG_Py_Void();
3085	<	return resultobj;
3086	<	fail:
3087	<	return NULL;
3088	<	}
3089	<
3090	<
3091	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3092	<	PyObject *resultobj = 0;
3093	<	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());
3083	>	{
3084	>	try {
3085	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3086	>
3087	>	}catch (const BossSchedFailure & e) {
3088	>	PyErr_SetString ( SchedulerError, e.what() );
3089	>	return NULL;
3090	>	}catch (const std::exception& e) {
3091	>	PyErr_SetString ( BossError, e.what() );
3092	>	return NULL;
3093	>	}
3094		}
3095	<	}
3096	<	resultobj = SWIG_Py_Void();
3097	<	return resultobj;
3098	<	fail:
11279	<	return NULL;
3095	>	Py_INCREF(Py_None); resultobj = Py_None;
3096	>	return resultobj;
3097	>	fail:
3098	>	return NULL;
3099		}
3100
3101
3102	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
3103	<	int argc;
3104	<	PyObject *argv[10];
3105	<	int ii;
3106	<
3107	<	if (!PyTuple_Check(args)) SWIG_fail;
3108	<	argc = PyObject_Length(args);
3109	<	for (ii = 0; (ii < argc) && (ii < 9); ii++) {
3110	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3111	<	}
3112	<	if (argc == 1) {
3113	<	int _v;
3114	<	void *vptr = 0;
3115	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3116	<	_v = SWIG_CheckState(res);
3117	<	if (_v) {
3118	<	return _wrap_BossSession_schedulerQuery__SWIG_8(self, args);
3119	<	}
3120	<	}
3121	<	if (argc == 2) {
3122	<	int _v;
3123	<	void *vptr = 0;
3124	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3125	<	_v = SWIG_CheckState(res);
3126	<	if (_v) {
3127	<	{
3128	<	int res = SWIG_AsVal_int(argv[1], NULL);
3129	<	_v = SWIG_CheckState(res);
3130	<	}
3131	<	if (_v) {
3132	<	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);
3102	>	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3103	>	PyObject *resultobj;
3104	>	BossSession *arg1 = (BossSession *) 0 ;
3105	>	std::string const &arg2_defvalue = "all" ;
3106	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3107	>	std::string const &arg3_defvalue = "" ;
3108	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3109	>	std::string const &arg4_defvalue = "" ;
3110	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3111	>	std::string const &arg5_defvalue = "" ;
3112	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3113	>	std::vector<std::string > result;
3114	>	std::string temp2 ;
3115	>	std::string temp3 ;
3116	>	std::string temp4 ;
3117	>	std::string temp5 ;
3118	>	PyObject * obj0 = 0 ;
3119	>	PyObject * obj1 = 0 ;
3120	>	PyObject * obj2 = 0 ;
3121	>	PyObject * obj3 = 0 ;
3122	>	PyObject * obj4 = 0 ;
3123	>
3124	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3125	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3126	>	if (obj1) {
3127	>	{
3128	>	if (PyString_Check(obj1)) {
3129	>	temp2 = std::string(PyString_AsString(obj1));
3130	>	arg2 = &temp2;
3131	>	}else {
3132	>	SWIG_exception(SWIG_TypeError, "string expected");
3133		}
11381	–	}
3134		}
11383	–	}
3135		}
3136	<	}
3137	<	if (argc == 6) {
3138	<	int _v;
3139	<	void *vptr = 0;
3140	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3141	<	_v = SWIG_CheckState(res);
3142	<	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	<	}
3136	>	if (obj2) {
3137	>	{
3138	>	if (PyString_Check(obj2)) {
3139	>	temp3 = std::string(PyString_AsString(obj2));
3140	>	arg3 = &temp3;
3141	>	}else {
3142	>	SWIG_exception(SWIG_TypeError, "string expected");
3143		}
11412	–	}
3144		}
11414	–	}
3145		}
3146	<	}
3147	<	if (argc == 7) {
3148	<	int _v;
3149	<	void *vptr = 0;
3150	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3151	<	_v = SWIG_CheckState(res);
3152	<	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	<	}
3146	>	if (obj3) {
3147	>	{
3148	>	if (PyString_Check(obj3)) {
3149	>	temp4 = std::string(PyString_AsString(obj3));
3150	>	arg4 = &temp4;
3151	>	}else {
3152	>	SWIG_exception(SWIG_TypeError, "string expected");
3153		}
11447	–	}
3154		}
11449	–	}
3155		}
3156	<	}
3157	<	if (argc == 8) {
3158	<	int _v;
3159	<	void *vptr = 0;
3160	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3161	<	_v = SWIG_CheckState(res);
3162	<	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	<	}
3156	>	if (obj4) {
3157	>	{
3158	>	if (PyString_Check(obj4)) {
3159	>	temp5 = std::string(PyString_AsString(obj4));
3160	>	arg5 = &temp5;
3161	>	}else {
3162	>	SWIG_exception(SWIG_TypeError, "string expected");
3163		}
11486	–	}
3164		}
11488	–	}
3165		}
3166	<	}
3167	<	if (argc == 9) {
3168	<	int _v;
3169	<	void *vptr = 0;
3170	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3171	<	_v = SWIG_CheckState(res);
3172	<	if (_v) {
3173	<	{
3174	<	int res = SWIG_AsVal_int(argv[1], NULL);
3175	<	_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	<	}
3166	>	{
3167	>	try {
3168	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3169	>
3170	>	}catch (const BossSchedFailure & e) {
3171	>	PyErr_SetString ( SchedulerError, e.what() );
3172	>	return NULL;
3173	>	}catch (const std::exception& e) {
3174	>	PyErr_SetString ( BossError, e.what() );
3175	>	return NULL;
3176		}
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 &""'");
11586	–	}
11587	–	arg3 = ptr;
11588	–	}
11589	–	{
11590	–	std::string *ptr = (std::string *)0;
11591	–	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 &""'");
3177		}
3178	<	arg3 = ptr;
3179	<	}
3180	<	{
3181	<	std::string *ptr = (std::string *)0;
3182	<	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());
3178	>	{
3179	>	resultobj = PyTuple_New((&result)->size());
3180	>	for (unsigned int i=0; i<(&result)->size(); i++)
3181	>	PyTuple_SetItem(resultobj,i,
3182	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3183		}
3184	<	}
3185	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
3186	<	return resultobj;
11836	<	fail:
11837	<	return NULL;
3184	>	return resultobj;
3185	>	fail:
3186	>	return NULL;
3187		}
3188
3189
3190	<	SWIGINTERN PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3191	<	int argc;
3192	<	PyObject *argv[6];
3193	<	int ii;
3194	<
3195	<	if (!PyTuple_Check(args)) SWIG_fail;
3196	<	argc = PyObject_Length(args);
3197	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
3198	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3199	<	}
3200	<	if (argc == 1) {
3201	<	int _v;
3202	<	void *vptr = 0;
3203	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3204	<	_v = SWIG_CheckState(res);
3205	<	if (_v) {
3206	<	return _wrap_BossSession_selectTasks__SWIG_4(self, args);
3207	<	}
3208	<	}
3209	<	if (argc == 2) {
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));
3216	<	_v = SWIG_CheckState(res);
3217	<	if (_v) {
3218	<	return _wrap_BossSession_selectTasks__SWIG_3(self, args);
3219	<	}
3220	<	}
3221	<	}
3222	<	if (argc == 3) {
3223	<	int _v;
3224	<	void *vptr = 0;
3225	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3226	<	_v = SWIG_CheckState(res);
3227	<	if (_v) {
3228	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3229	<	_v = SWIG_CheckState(res);
3230	<	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);
3190	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3191	>	PyObject *resultobj;
3192	>	BossSession *arg1 = (BossSession *) 0 ;
3193	>	int arg2 = (int) SCHEDULED ;
3194	>	std::string const &arg3_defvalue = "all" ;
3195	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3196	>	std::string const &arg4_defvalue = "all" ;
3197	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3198	>	std::string const &arg5_defvalue = "" ;
3199	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3200	>	std::string arg6 = (std::string) "" ;
3201	>	std::string arg7 = (std::string) "" ;
3202	>	std::string arg8 = (std::string) "" ;
3203	>	std::string arg9 = (std::string) "" ;
3204	>	unsigned int arg10 = (unsigned int) 0 ;
3205	>	bool arg11 = (bool) false ;
3206	>	SwigValueWrapper< std::vector<BossTask * > > result;
3207	>	std::string temp3 ;
3208	>	std::string temp4 ;
3209	>	std::string temp5 ;
3210	>	PyObject * obj0 = 0 ;
3211	>	PyObject * obj2 = 0 ;
3212	>	PyObject * obj3 = 0 ;
3213	>	PyObject * obj4 = 0 ;
3214	>	PyObject * obj5 = 0 ;
3215	>	PyObject * obj6 = 0 ;
3216	>	PyObject * obj7 = 0 ;
3217	>	PyObject * obj8 = 0 ;
3218	>	PyObject * obj9 = 0 ;
3219	>	PyObject * obj10 = 0 ;
3220	>
3221	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3222	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3223	>	if (obj2) {
3224	>	{
3225	>	if (PyString_Check(obj2)) {
3226	>	temp3 = std::string(PyString_AsString(obj2));
3227	>	arg3 = &temp3;
3228	>	}else {
3229	>	SWIG_exception(SWIG_TypeError, "string expected");
3230	>	}
3231		}
11887	–	}
3232		}
3233	<	}
3234	<	if (argc == 4) {
3235	<	int _v;
3236	<	void *vptr = 0;
3237	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3238	<	_v = SWIG_CheckState(res);
3239	<	if (_v) {
3240	<	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	<	}
3233	>	if (obj3) {
3234	>	{
3235	>	if (PyString_Check(obj3)) {
3236	>	temp4 = std::string(PyString_AsString(obj3));
3237	>	arg4 = &temp4;
3238	>	}else {
3239	>	SWIG_exception(SWIG_TypeError, "string expected");
3240	>	}
3241		}
11908	–	}
3242		}
3243	<	}
3244	<	if (argc == 5) {
3245	<	int _v;
3246	<	void *vptr = 0;
3247	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3248	<	_v = SWIG_CheckState(res);
3249	<	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);
3243	>	if (obj4) {
3244	>	{
3245	>	if (PyString_Check(obj4)) {
3246	>	temp5 = std::string(PyString_AsString(obj4));
3247	>	arg5 = &temp5;
3248	>	}else {
3249	>	SWIG_exception(SWIG_TypeError, "string expected");
3250		}
11931	–	}
3251		}
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 &""'");
3252		}
3253	<	if (!ptr) {
3254	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
3255	<	}
3256	<	arg3 = ptr;
3257	<	}
3258	<	{
3259	<	std::string *ptr = (std::string *)0;
12000	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
12001	<	if (!SWIG_IsOK(res4)) {
12002	<	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 &""'");
3253	>	if (obj5) {
3254	>	{
3255	>	if (PyString_Check(obj5))
3256	>	arg6 = std::string(PyString_AsString(obj5));
3257	>	else
3258	>	SWIG_exception(SWIG_TypeError, "string expected");
3259	>	}
3260		}
3261	<	arg4 = ptr;
3262	<	}
3263	<	{
3264	<	std::string *ptr = (std::string *)0;
3265	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
3266	<	if (!SWIG_IsOK(res5)) {
3267	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
3261	>	if (obj6) {
3262	>	{
3263	>	if (PyString_Check(obj6))
3264	>	arg7 = std::string(PyString_AsString(obj6));
3265	>	else
3266	>	SWIG_exception(SWIG_TypeError, "string expected");
3267	>	}
3268		}
3269	<	if (!ptr) {
3270	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
3269	>	if (obj7) {
3270	>	{
3271	>	if (PyString_Check(obj7))
3272	>	arg8 = std::string(PyString_AsString(obj7));
3273	>	else
3274	>	SWIG_exception(SWIG_TypeError, "string expected");
3275	>	}
3276		}
3277	<	arg5 = ptr;
3278	<	}
3279	<	{
3280	<	std::string *ptr = (std::string *)0;
3281	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
3282	<	if (!SWIG_IsOK(res) || !ptr) {
3283	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "6"" of type '" "std::string""'");
3277	>	if (obj8) {
3278	>	{
3279	>	if (PyString_Check(obj8))
3280	>	arg9 = std::string(PyString_AsString(obj8));
3281	>	else
3282	>	SWIG_exception(SWIG_TypeError, "string expected");
3283	>	}
3284		}
3285	<	arg6 = *ptr;
3286	<	if (SWIG_IsNewObj(res)) delete ptr;
3287	<	}
12029	<	{
12030	<	std::string *ptr = (std::string *)0;
12031	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
12032	<	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""'");
3285	>	if (obj9) {
3286	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3287	>	if (PyErr_Occurred()) SWIG_fail;
3288		}
3289	<	arg7 = *ptr;
3290	<	if (SWIG_IsNewObj(res)) delete ptr;
3291	<	}
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""'");
3289	>	if (obj10) {
3290	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3291	>	if (PyErr_Occurred()) SWIG_fail;
3292		}
3293	<	arg8 = *ptr;
3294	<	if (SWIG_IsNewObj(res)) delete ptr;
3295	<	}
3296	<	{
3297	<	std::string *ptr = (std::string *)0;
3298	<	int res = SWIG_AsPtr_std_string(obj8, &ptr);
3299	<	if (!SWIG_IsOK(res) || !ptr) {
3300	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "9"" of type '" "std::string""'");
3293	>	{
3294	>	try {
3295	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3296	>
3297	>	}catch (const BossSchedFailure & e) {
3298	>	PyErr_SetString ( SchedulerError, e.what() );
3299	>	return NULL;
3300	>	}catch (const std::exception& e) {
3301	>	PyErr_SetString ( BossError, e.what() );
3302	>	return NULL;
3303	>	}
3304		}
3305	<	arg9 = *ptr;
3306	<	if (SWIG_IsNewObj(res)) delete ptr;
3307	<	}
3308	<	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());
3305	>	{
3306	>	std::vector<BossTask * > * resultptr;
3307	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3308	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3309		}
3310	<	}
3311	<	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 );
3312	<	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;
3310	>	return resultobj;
3311	>	fail:
3312	>	return NULL;
3313		}
3314
3315
3316	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3317	<	PyObject *resultobj = 0;
3318	<	BossSession *arg1 = (BossSession *) 0 ;
3319	<	int arg2 ;
3320	<	std::string *arg3 = 0 ;
3321	<	std::string *arg4 = 0 ;
3322	<	std::string *arg5 = 0 ;
3323	<	std::string arg6 ;
3324	<	std::string arg7 ;
3325	<	std::string arg8 ;
3326	<	std::string arg9 ;
3327	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3328	<	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""'");
3316	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
3317	>	PyObject *resultobj;
3318	>	BossSession *arg1 = (BossSession *) 0 ;
3319	>	std::vector<std::string > *arg2 = 0 ;
3320	>	PyObject *result;
3321	>	PyObject * obj0 = 0 ;
3322	>	PyObject * obj1 = 0 ;
3323	>
3324	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
3325	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3326	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3327	>	if (arg2 == NULL) {
3328	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3329		}
3330	<	arg9 = *ptr;
3331	<	if (SWIG_IsNewObj(res)) delete ptr;
3332	<	}
3333	<	{
3334	<	try {
3335	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3336	<	} catch (const std::exception& e) {
3337	<	SWIG_exception(SWIG_RuntimeError, e.what());
3330	>	{
3331	>	try {
3332	>	result = (PyObject *)BossSession_show(arg1,*arg2);
3333	>
3334	>	}catch (const BossSchedFailure & e) {
3335	>	PyErr_SetString ( SchedulerError, e.what() );
3336	>	return NULL;
3337	>	}catch (const std::exception& e) {
3338	>	PyErr_SetString ( BossError, e.what() );
3339	>	return NULL;
3340	>	}
3341		}
3342	<	}
3343	<	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 );
3344	<	if (SWIG_IsNewObj(res3)) delete arg3;
3345	<	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;
3342	>	resultobj = result;
3343	>	return resultobj;
3344	>	fail:
3345	>	return NULL;
3346		}
3347
3348
3349	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3350	<	PyObject *resultobj = 0;
3351	<	BossSession *arg1 = (BossSession *) 0 ;
3352	<	int arg2 ;
3353	<	std::string *arg3 = 0 ;
3354	<	std::string *arg4 = 0 ;
3355	<	std::string *arg5 = 0 ;
3356	<	std::string arg6 ;
3357	<	std::string arg7 ;
3358	<	std::string arg8 ;
3359	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3360	<	void *argp1 = 0 ;
3361	<	int res1 = 0 ;
3362	<	int val2 ;
3363	<	int ecode2 = 0 ;
3364	<	int res3 = SWIG_OLDOBJ ;
3365	<	int res4 = SWIG_OLDOBJ ;
3366	<	int res5 = SWIG_OLDOBJ ;
3367	<	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());
3349	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
3350	>	PyObject *resultobj;
3351	>	BossSession *arg1 = (BossSession *) 0 ;
3352	>	PyObject *result;
3353	>	PyObject * obj0 = 0 ;
3354	>
3355	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
3356	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3357	>	{
3358	>	try {
3359	>	result = (PyObject *)BossSession_CHTools(arg1);
3360	>
3361	>	}catch (const BossSchedFailure & e) {
3362	>	PyErr_SetString ( SchedulerError, e.what() );
3363	>	return NULL;
3364	>	}catch (const std::exception& e) {
3365	>	PyErr_SetString ( BossError, e.what() );
3366	>	return NULL;
3367	>	}
3368		}
3369	<	}
3370	<	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 );
3371	<	if (SWIG_IsNewObj(res3)) delete arg3;
3372	<	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;
3369	>	resultobj = result;
3370	>	return resultobj;
3371	>	fail:
3372	>	return NULL;
3373		}
3374
3375
3376	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3377	<	PyObject *resultobj = 0;
3378	<	BossSession *arg1 = (BossSession *) 0 ;
3379	<	int arg2 ;
3380	<	std::string *arg3 = 0 ;
3381	<	std::string *arg4 = 0 ;
3382	<	std::string *arg5 = 0 ;
3383	<	std::string arg6 ;
3384	<	std::string arg7 ;
3385	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3386	<	void *argp1 = 0 ;
3387	<	int res1 = 0 ;
3388	<	int val2 ;
3389	<	int ecode2 = 0 ;
3390	<	int res3 = SWIG_OLDOBJ ;
3391	<	int res4 = SWIG_OLDOBJ ;
3392	<	int res5 = SWIG_OLDOBJ ;
3393	<	PyObject * obj0 = 0 ;
3394	<	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());
3376	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
3377	>	PyObject *resultobj;
3378	>	BossSession *arg1 = (BossSession *) 0 ;
3379	>	PyObject *result;
3380	>	PyObject * obj0 = 0 ;
3381	>
3382	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
3383	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3384	>	{
3385	>	try {
3386	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
3387	>
3388	>	}catch (const BossSchedFailure & e) {
3389	>	PyErr_SetString ( SchedulerError, e.what() );
3390	>	return NULL;
3391	>	}catch (const std::exception& e) {
3392	>	PyErr_SetString ( BossError, e.what() );
3393	>	return NULL;
3394	>	}
3395		}
3396	<	}
3397	<	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 );
3398	<	if (SWIG_IsNewObj(res3)) delete arg3;
3399	<	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;
3396	>	resultobj = result;
3397	>	return resultobj;
3398	>	fail:
3399	>	return NULL;
3400		}
3401
3402
3403	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3404	<	PyObject *resultobj = 0;
3405	<	BossSession *arg1 = (BossSession *) 0 ;
3406	<	int arg2 ;
3407	<	std::string *arg3 = 0 ;
3408	<	std::string *arg4 = 0 ;
3409	<	std::string *arg5 = 0 ;
3410	<	std::string arg6 ;
3411	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3412	<	void *argp1 = 0 ;
3413	<	int res1 = 0 ;
3414	<	int val2 ;
3415	<	int ecode2 = 0 ;
3416	<	int res3 = SWIG_OLDOBJ ;
3417	<	int res4 = SWIG_OLDOBJ ;
3418	<	int res5 = SWIG_OLDOBJ ;
3419	<	PyObject * obj0 = 0 ;
3420	<	PyObject * obj1 = 0 ;
3421	<	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());
3403	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
3404	>	PyObject *resultobj;
3405	>	BossSession *arg1 = (BossSession *) 0 ;
3406	>	PyObject *result;
3407	>	PyObject * obj0 = 0 ;
3408	>
3409	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
3410	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3411	>	{
3412	>	try {
3413	>	result = (PyObject *)BossSession_RTMons(arg1);
3414	>
3415	>	}catch (const BossSchedFailure & e) {
3416	>	PyErr_SetString ( SchedulerError, e.what() );
3417	>	return NULL;
3418	>	}catch (const std::exception& e) {
3419	>	PyErr_SetString ( BossError, e.what() );
3420	>	return NULL;
3421	>	}
3422		}
3423	<	}
3424	<	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 );
3425	<	if (SWIG_IsNewObj(res3)) delete arg3;
3426	<	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;
3423	>	resultobj = result;
3424	>	return resultobj;
3425	>	fail:
3426	>	return NULL;
3427		}
3428
3429
3430	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3431	<	PyObject *resultobj = 0;
3432	<	BossSession *arg1 = (BossSession *) 0 ;
3433	<	int arg2 ;
3434	<	std::string *arg3 = 0 ;
3435	<	std::string *arg4 = 0 ;
3436	<	std::string *arg5 = 0 ;
3437	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3438	<	void *argp1 = 0 ;
3439	<	int res1 = 0 ;
3440	<	int val2 ;
3441	<	int ecode2 = 0 ;
3442	<	int res3 = SWIG_OLDOBJ ;
3443	<	int res4 = SWIG_OLDOBJ ;
3444	<	int res5 = SWIG_OLDOBJ ;
3445	<	PyObject * obj0 = 0 ;
3446	<	PyObject * obj1 = 0 ;
3447	<	PyObject * obj2 = 0 ;
3448	<	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());
3430	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
3431	>	PyObject *resultobj;
3432	>	BossSession *arg1 = (BossSession *) 0 ;
3433	>	PyObject *result;
3434	>	PyObject * obj0 = 0 ;
3435	>
3436	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
3437	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3438	>	{
3439	>	try {
3440	>	result = (PyObject *)BossSession_schedulers(arg1);
3441	>
3442	>	}catch (const BossSchedFailure & e) {
3443	>	PyErr_SetString ( SchedulerError, e.what() );
3444	>	return NULL;
3445	>	}catch (const std::exception& e) {
3446	>	PyErr_SetString ( BossError, e.what() );
3447	>	return NULL;
3448	>	}
3449		}
3450	<	}
3451	<	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 );
3452	<	if (SWIG_IsNewObj(res3)) delete arg3;
3453	<	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;
3450	>	resultobj = result;
3451	>	return resultobj;
3452	>	fail:
3453	>	return NULL;
3454		}
3455
3456
3457	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3458	<	PyObject *resultobj = 0;
3459	<	BossSession *arg1 = (BossSession *) 0 ;
3460	<	int arg2 ;
3461	<	std::string *arg3 = 0 ;
3462	<	std::string *arg4 = 0 ;
3463	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
3464	<	void *argp1 = 0 ;
3465	<	int res1 = 0 ;
3466	<	int val2 ;
3467	<	int ecode2 = 0 ;
3468	<	int res3 = SWIG_OLDOBJ ;
3469	<	int res4 = SWIG_OLDOBJ ;
3470	<	PyObject * obj0 = 0 ;
3471	<	PyObject * obj1 = 0 ;
3472	<	PyObject * obj2 = 0 ;
3473	<	PyObject * obj3 = 0 ;
3474	<
3475	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3476	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3477	<	if (!SWIG_IsOK(res1)) {
3478	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
3479	<	}
3480	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3481	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
3482	<	if (!SWIG_IsOK(ecode2)) {
3483	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
3484	<	}
3485	<	arg2 = static_cast< int >(val2);
3486	<	{
3487	<	std::string *ptr = (std::string *)0;
3488	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
3489	<	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 &""'");
3457	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3458	>	PyObject *resultobj;
3459	>	BossSession *arg1 = (BossSession *) 0 ;
3460	>	std::string *arg2 = 0 ;
3461	>	std::string *arg3 = 0 ;
3462	>	std::string const &arg4_defvalue = "" ;
3463	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3464	>	std::string const &arg5_defvalue = "" ;
3465	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3466	>	unsigned int arg6 = (unsigned int) 0 ;
3467	>	bool arg7 = (bool) false ;
3468	>	PyObject *result;
3469	>	std::string temp2 ;
3470	>	std::string temp3 ;
3471	>	std::string temp4 ;
3472	>	std::string temp5 ;
3473	>	PyObject * obj0 = 0 ;
3474	>	PyObject * obj1 = 0 ;
3475	>	PyObject * obj2 = 0 ;
3476	>	PyObject * obj3 = 0 ;
3477	>	PyObject * obj4 = 0 ;
3478	>	PyObject * obj5 = 0 ;
3479	>	PyObject * obj6 = 0 ;
3480	>
3481	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
3482	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3483	>	{
3484	>	if (PyString_Check(obj1)) {
3485	>	temp2 = std::string(PyString_AsString(obj1));
3486	>	arg2 = &temp2;
3487	>	}else {
3488	>	SWIG_exception(SWIG_TypeError, "string expected");
3489	>	}
3490		}
3491	<	arg4 = ptr;
3492	<	}
3493	<	{
3494	<	try {
3495	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
3496	<	} catch (const std::exception& e) {
3497	<	SWIG_exception(SWIG_RuntimeError, e.what());
3491	>	{
3492	>	if (PyString_Check(obj2)) {
3493	>	temp3 = std::string(PyString_AsString(obj2));
3494	>	arg3 = &temp3;
3495	>	}else {
3496	>	SWIG_exception(SWIG_TypeError, "string expected");
3497	>	}
3498		}
3499	<	}
3500	<	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 );
3501	<	if (SWIG_IsNewObj(res3)) delete arg3;
3502	<	if (SWIG_IsNewObj(res4)) delete arg4;
3503	<	return resultobj;
3504	<	fail:
3505	<	if (SWIG_IsNewObj(res3)) delete arg3;
3506	<	if (SWIG_IsNewObj(res4)) delete arg4;
3507	<	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 &""'");
3499	>	if (obj3) {
3500	>	{
3501	>	if (PyString_Check(obj3)) {
3502	>	temp4 = std::string(PyString_AsString(obj3));
3503	>	arg4 = &temp4;
3504	>	}else {
3505	>	SWIG_exception(SWIG_TypeError, "string expected");
3506	>	}
3507	>	}
3508		}
3509	<	if (!ptr) {
3510	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
3509	>	if (obj4) {
3510	>	{
3511	>	if (PyString_Check(obj4)) {
3512	>	temp5 = std::string(PyString_AsString(obj4));
3513	>	arg5 = &temp5;
3514	>	}else {
3515	>	SWIG_exception(SWIG_TypeError, "string expected");
3516	>	}
3517	>	}
3518		}
3519	<	arg3 = ptr;
3520	<	}
3521	<	{
12723	<	try {
12724	<	result = (arg1)->query(arg2,(std::string const &)*arg3);
12725	<	} catch (const std::exception& e) {
12726	<	SWIG_exception(SWIG_RuntimeError, e.what());
3519	>	if (obj5) {
3520	>	arg6 = (unsigned int) PyInt_AsLong(obj5);
3521	>	if (PyErr_Occurred()) SWIG_fail;
3522		}
3523	<	}
3524	<	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 );
3525	<	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());
3523	>	if (obj6) {
3524	>	arg7 = PyInt_AsLong(obj6) ? true : false;
3525	>	if (PyErr_Occurred()) SWIG_fail;
3526		}
3527	<	}
3528	<	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 );
3529	<	return resultobj;
3530	<	fail:
3531	<	return NULL;
3532	<	}
3533	<
3534	<
3535	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3536	<	PyObject *resultobj = 0;
3537	<	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());
3527	>	{
3528	>	try {
3529	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3530	>
3531	>	}catch (const BossSchedFailure & e) {
3532	>	PyErr_SetString ( SchedulerError, e.what() );
3533	>	return NULL;
3534	>	}catch (const std::exception& e) {
3535	>	PyErr_SetString ( BossError, e.what() );
3536	>	return NULL;
3537	>	}
3538		}
3539	<	}
3540	<	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 );
3541	<	return resultobj;
3542	<	fail:
12799	<	return NULL;
3539	>	resultobj = result;
3540	>	return resultobj;
3541	>	fail:
3542	>	return NULL;
3543		}
3544
3545
3546	<	SWIGINTERN PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3547	<	int argc;
3548	<	PyObject *argv[11];
3549	<	int ii;
3550	<
3551	<	if (!PyTuple_Check(args)) SWIG_fail;
3552	<	argc = PyObject_Length(args);
3553	<	for (ii = 0; (ii < argc) && (ii < 10); ii++) {
3554	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3555	<	}
3556	<	if (argc == 1) {
3557	<	int _v;
3558	<	void *vptr = 0;
3559	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3560	<	_v = SWIG_CheckState(res);
3561	<	if (_v) {
3562	<	return _wrap_BossSession_query__SWIG_9(self, args);
3563	<	}
3564	<	}
3565	<	if (argc == 2) {
3566	<	int _v;
3567	<	void *vptr = 0;
3568	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3569	<	_v = SWIG_CheckState(res);
3570	<	if (_v) {
3571	<	{
3572	<	int res = SWIG_AsVal_int(argv[1], NULL);
3573	<	_v = SWIG_CheckState(res);
3574	<	}
3575	<	if (_v) {
3576	<	return _wrap_BossSession_query__SWIG_8(self, args);
3577	<	}
3578	<	}
3579	<	}
3580	<	if (argc == 3) {
3581	<	int _v;
3582	<	void *vptr = 0;
3583	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3584	<	_v = SWIG_CheckState(res);
3585	<	if (_v) {
3586	<	{
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);
3546	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3547	>	PyObject *resultobj;
3548	>	BossSession *arg1 = (BossSession *) 0 ;
3549	>	int arg2 = (int) SCHEDULED ;
3550	>	std::string const &arg3_defvalue = "all" ;
3551	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3552	>	std::string const &arg4_defvalue = "all" ;
3553	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3554	>	std::string const &arg5_defvalue = "" ;
3555	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3556	>	std::string arg6 = (std::string) "" ;
3557	>	std::string arg7 = (std::string) "" ;
3558	>	std::string arg8 = (std::string) "" ;
3559	>	std::string arg9 = (std::string) "" ;
3560	>	unsigned int arg10 = (unsigned int) 0 ;
3561	>	bool arg11 = (bool) false ;
3562	>	PyObject *result;
3563	>	std::string temp3 ;
3564	>	std::string temp4 ;
3565	>	std::string temp5 ;
3566	>	PyObject * obj0 = 0 ;
3567	>	PyObject * obj2 = 0 ;
3568	>	PyObject * obj3 = 0 ;
3569	>	PyObject * obj4 = 0 ;
3570	>	PyObject * obj5 = 0 ;
3571	>	PyObject * obj6 = 0 ;
3572	>	PyObject * obj7 = 0 ;
3573	>	PyObject * obj8 = 0 ;
3574	>	PyObject * obj9 = 0 ;
3575	>	PyObject * obj10 = 0 ;
3576	>
3577	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) goto fail;
3578	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3579	>	if (obj2) {
3580	>	{
3581	>	if (PyString_Check(obj2)) {
3582	>	temp3 = std::string(PyString_AsString(obj2));
3583	>	arg3 = &temp3;
3584	>	}else {
3585	>	SWIG_exception(SWIG_TypeError, "string expected");
3586	>	}
3587		}
12853	–	}
3588		}
3589	<	}
3590	<	if (argc == 4) {
3591	<	int _v;
3592	<	void *vptr = 0;
3593	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3594	<	_v = SWIG_CheckState(res);
3595	<	if (_v) {
3596	<	{
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	<	}
3589	>	if (obj3) {
3590	>	{
3591	>	if (PyString_Check(obj3)) {
3592	>	temp4 = std::string(PyString_AsString(obj3));
3593	>	arg4 = &temp4;
3594	>	}else {
3595	>	SWIG_exception(SWIG_TypeError, "string expected");
3596	>	}
3597		}
12876	–	}
3598		}
3599	<	}
3600	<	if (argc == 5) {
3601	<	int _v;
3602	<	void *vptr = 0;
3603	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3604	<	_v = SWIG_CheckState(res);
3605	<	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);
3599	>	if (obj4) {
3600	>	{
3601	>	if (PyString_Check(obj4)) {
3602	>	temp5 = std::string(PyString_AsString(obj4));
3603	>	arg5 = &temp5;
3604	>	}else {
3605	>	SWIG_exception(SWIG_TypeError, "string expected");
3606		}
12901	–	}
3607		}
12903	–	}
3608		}
3609	<	}
3610	<	if (argc == 6) {
3611	<	int _v;
3612	<	void *vptr = 0;
3613	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3614	<	_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	<	}
3609	>	if (obj5) {
3610	>	{
3611	>	if (PyString_Check(obj5))
3612	>	arg6 = std::string(PyString_AsString(obj5));
3613	>	else
3614	>	SWIG_exception(SWIG_TypeError, "string expected");
3615		}
12934	–	}
3616		}
3617	<	}
3618	<	if (argc == 7) {
3619	<	int _v;
3620	<	void *vptr = 0;
3621	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3622	<	_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	<	}
3617	>	if (obj6) {
3618	>	{
3619	>	if (PyString_Check(obj6))
3620	>	arg7 = std::string(PyString_AsString(obj6));
3621	>	else
3622	>	SWIG_exception(SWIG_TypeError, "string expected");
3623		}
12969	–	}
3624		}
3625	<	}
3626	<	if (argc == 8) {
3627	<	int _v;
3628	<	void *vptr = 0;
3629	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3630	<	_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	<	}
3625	>	if (obj7) {
3626	>	{
3627	>	if (PyString_Check(obj7))
3628	>	arg8 = std::string(PyString_AsString(obj7));
3629	>	else
3630	>	SWIG_exception(SWIG_TypeError, "string expected");
3631		}
13008	–	}
3632		}
3633	<	}
3634	<	if (argc == 9) {
3635	<	int _v;
3636	<	void *vptr = 0;
3637	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3638	<	_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	<	}
3633	>	if (obj8) {
3634	>	{
3635	>	if (PyString_Check(obj8))
3636	>	arg9 = std::string(PyString_AsString(obj8));
3637	>	else
3638	>	SWIG_exception(SWIG_TypeError, "string expected");
3639		}
13051	–	}
3640		}
3641	<	}
3642	<	if (argc == 10) {
3643	<	int _v;
3644	<	void *vptr = 0;
3645	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3646	<	_v = SWIG_CheckState(res);
3647	<	if (_v) {
3648	<	{
3649	<	int res = SWIG_AsVal_int(argv[1], NULL);
3650	<	_v = SWIG_CheckState(res);
3651	<	}
3652	<	if (_v) {
3653	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
3654	<	_v = SWIG_CheckState(res);
3655	<	if (_v) {
3656	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
3657	<	_v = SWIG_CheckState(res);
3658	<	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	<	}
3641	>	if (obj9) {
3642	>	arg10 = (unsigned int) PyInt_AsLong(obj9);
3643	>	if (PyErr_Occurred()) SWIG_fail;
3644	>	}
3645	>	if (obj10) {
3646	>	arg11 = PyInt_AsLong(obj10) ? true : false;
3647	>	if (PyErr_Occurred()) SWIG_fail;
3648	>	}
3649	>	{
3650	>	try {
3651	>	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
3652	>
3653	>	}catch (const BossSchedFailure & e) {
3654	>	PyErr_SetString ( SchedulerError, e.what() );
3655	>	return NULL;
3656	>	}catch (const std::exception& e) {
3657	>	PyErr_SetString ( BossError, e.what() );
3658	>	return NULL;
3659		}
13100	–	}
3660		}
3661	<	}
3662	<
3663	<	fail:
3664	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_query'");
13106	<	return NULL;
3661	>	resultobj = result;
3662	>	return resultobj;
3663	>	fail:
3664	>	return NULL;
3665		}
3666
3667
3668	<	SWIGINTERN PyObject *_wrap_BossSession_show(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3669	<	PyObject *resultobj = 0;
3670	<	BossSession *arg1 = (BossSession *) 0 ;
3671	<	std::vector<std::string,std::allocator<std::string > > *arg2 = 0 ;
3672	<	PyObject *result = 0 ;
3673	<	void *argp1 = 0 ;
3674	<	int res1 = 0 ;
3675	<	void *argp2 = 0 ;
3676	<	int res2 = 0 ;
3677	<	PyObject * obj0 = 0 ;
3678	<	PyObject * obj1 = 0 ;
3679	<
3680	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) SWIG_fail;
3681	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3682	<	if (!SWIG_IsOK(res1)) {
3683	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_show" "', argument " "1"" of type '" "BossSession *""'");
3684	<	}
3685	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3686	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t,  0 );
3687	<	if (!SWIG_IsOK(res2)) {
3688	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_show" "', argument " "2"" of type '" "std::vector<std::string,std::allocator<std::string > > &""'");
3689	<	}
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());
3668	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3669	>	PyObject *obj;
3670	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3671	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3672	>	Py_INCREF(obj);
3673	>	return Py_BuildValue((char *)"");
3674	>	}
3675	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3676	>	PyObject *resultobj;
3677	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3678	>	char *arg2 ;
3679	>	PyObject * obj0 = 0 ;
3680	>
3681	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3682	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3683	>	{
3684	>	if (arg2) {
3685	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3686	>	strcpy((char *) arg1->key,arg2);
3687	>	}else {
3688	>	arg1->key = 0;
3689	>	}
3690		}
3691	<	}
3692	<	resultobj = result;
3693	<	return resultobj;
3694	<	fail:
13146	<	return NULL;
3691	>	Py_INCREF(Py_None); resultobj = Py_None;
3692	>	return resultobj;
3693	>	fail:
3694	>	return NULL;
3695		}
3696
3697
3698	<	SWIGINTERN PyObject *_wrap_BossSession_CHTools(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3699	<	PyObject *resultobj = 0;
3700	<	BossSession *arg1 = (BossSession *) 0 ;
3701	<	PyObject *result = 0 ;
3702	<	void *argp1 = 0 ;
3703	<	int res1 = 0 ;
3704	<	PyObject * obj0 = 0 ;
3705	<
3706	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) SWIG_fail;
3707	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3708	<	if (!SWIG_IsOK(res1)) {
3709	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_CHTools" "', argument " "1"" of type '" "BossSession *""'");
3710	<	}
3711	<	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;
3698	>	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3699	>	PyObject *resultobj;
3700	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3701	>	char *result;
3702	>	PyObject * obj0 = 0 ;
3703	>
3704	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3705	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3706	>	result = (char *) ((arg1)->key);
3707	>
3708	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3709	>	return resultobj;
3710	>	fail:
3711	>	return NULL;
3712		}
3713
3714
3715	<	SWIGINTERN PyObject *_wrap_BossSession_ProgramTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3716	<	PyObject *resultobj = 0;
3717	<	BossSession *arg1 = (BossSession *) 0 ;
3718	<	PyObject *result = 0 ;
3719	<	void *argp1 = 0 ;
3720	<	int res1 = 0 ;
3721	<	PyObject * obj0 = 0 ;
3722	<
3723	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) SWIG_fail;
3724	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3725	<	if (!SWIG_IsOK(res1)) {
3726	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_ProgramTypes" "', argument " "1"" of type '" "BossSession *""'");
3727	<	}
3728	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3729	<	{
3730	<	try {
3731	<	result = (PyObject *)BossSession_ProgramTypes(arg1);
13195	<	} catch (const std::exception& e) {
13196	<	SWIG_exception(SWIG_RuntimeError, e.what());
3715	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3716	>	PyObject *resultobj;
3717	>	char *arg1 ;
3718	>	BossTaskException *result;
3719	>
3720	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3721	>	{
3722	>	try {
3723	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3724	>
3725	>	}catch (const BossSchedFailure & e) {
3726	>	PyErr_SetString ( SchedulerError, e.what() );
3727	>	return NULL;
3728	>	}catch (const std::exception& e) {
3729	>	PyErr_SetString ( BossError, e.what() );
3730	>	return NULL;
3731	>	}
3732		}
3733	<	}
3734	<	resultobj = result;
3735	<	return resultobj;
3736	<	fail:
13202	<	return NULL;
3733	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3734	>	return resultobj;
3735	>	fail:
3736	>	return NULL;
3737		}
3738
3739
3740	<	SWIGINTERN PyObject *_wrap_BossSession_RTMons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3741	<	PyObject *resultobj = 0;
3742	<	BossSession *arg1 = (BossSession *) 0 ;
3743	<	PyObject *result = 0 ;
3744	<	void *argp1 = 0 ;
3745	<	int res1 = 0 ;
3746	<	PyObject * obj0 = 0 ;
3747	<
3748	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) SWIG_fail;
3749	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3750	<	if (!SWIG_IsOK(res1)) {
3751	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTMons" "', argument " "1"" of type '" "BossSession *""'");
3752	<	}
3753	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3754	<	{
3755	<	try {
3756	<	result = (PyObject *)BossSession_RTMons(arg1);
3757	<	} catch (const std::exception& e) {
3758	<	SWIG_exception(SWIG_RuntimeError, e.what());
3740	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3741	>	PyObject *resultobj;
3742	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3743	>	char *result;
3744	>	PyObject * obj0 = 0 ;
3745	>
3746	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3747	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3748	>	{
3749	>	try {
3750	>	result = (char *)((BossTaskException const *)arg1)->what();
3751	>
3752	>	}catch (const BossSchedFailure & e) {
3753	>	PyErr_SetString ( SchedulerError, e.what() );
3754	>	return NULL;
3755	>	}catch (const std::exception& e) {
3756	>	PyErr_SetString ( BossError, e.what() );
3757	>	return NULL;
3758	>	}
3759		}
3760	<	}
3761	<	resultobj = result;
3762	<	return resultobj;
3763	<	fail:
13230	<	return NULL;
3760	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3761	>	return resultobj;
3762	>	fail:
3763	>	return NULL;
3764		}
3765
3766
3767	<	SWIGINTERN PyObject *_wrap_BossSession_schedulers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3768	<	PyObject *resultobj = 0;
3769	<	BossSession *arg1 = (BossSession *) 0 ;
3770	<	PyObject *result = 0 ;
3771	<	void *argp1 = 0 ;
3772	<	int res1 = 0 ;
3773	<	PyObject * obj0 = 0 ;
3774	<
3775	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) SWIG_fail;
3776	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
3777	<	if (!SWIG_IsOK(res1)) {
3778	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulers" "', argument " "1"" of type '" "BossSession *""'");
3779	<	}
3780	<	arg1 = reinterpret_cast< BossSession * >(argp1);
3781	<	{
3782	<	try {
3783	<	result = (PyObject *)BossSession_schedulers(arg1);
3784	<	} catch (const std::exception& e) {
13252	<	SWIG_exception(SWIG_RuntimeError, e.what());
3767	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3768	>	PyObject *resultobj;
3769	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3770	>	PyObject * obj0 = 0 ;
3771	>
3772	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3773	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3774	>	{
3775	>	try {
3776	>	delete arg1;
3777	>
3778	>	}catch (const BossSchedFailure & e) {
3779	>	PyErr_SetString ( SchedulerError, e.what() );
3780	>	return NULL;
3781	>	}catch (const std::exception& e) {
3782	>	PyErr_SetString ( BossError, e.what() );
3783	>	return NULL;
3784	>	}
3785		}
3786	<	}
3787	<	resultobj = result;
3788	<	return resultobj;
3789	<	fail:
13258	<	return NULL;
3786	>	Py_INCREF(Py_None); resultobj = Py_None;
3787	>	return resultobj;
3788	>	fail:
3789	>	return NULL;
3790		}
3791
3792
3793	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3794	<	PyObject *resultobj = 0;
3795	<	BossSession *arg1 = (BossSession *) 0 ;
3796	<	std::string *arg2 = 0 ;
3797	<	std::string *arg3 = 0 ;
3798	<	std::string *arg4 = 0 ;
3799	<	std::string *arg5 = 0 ;
3800	<	bool arg6 ;
3801	<	PyObject *result = 0 ;
3802	<	void *argp1 = 0 ;
3803	<	int res1 = 0 ;
3804	<	int res2 = SWIG_OLDOBJ ;
3805	<	int res3 = SWIG_OLDOBJ ;
3806	<	int res4 = SWIG_OLDOBJ ;
3807	<	int res5 = SWIG_OLDOBJ ;
3808	<	bool val6 ;
3809	<	int ecode6 = 0 ;
3810	<	PyObject * obj0 = 0 ;
3811	<	PyObject * obj1 = 0 ;
3812	<	PyObject * obj2 = 0 ;
3813	<	PyObject * obj3 = 0 ;
3814	<	PyObject * obj4 = 0 ;
3815	<	PyObject * obj5 = 0 ;
3816	<
3817	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
3818	<	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());
3793	>	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3794	>	PyObject *obj;
3795	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3796	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3797	>	Py_INCREF(obj);
3798	>	return Py_BuildValue((char *)"");
3799	>	}
3800	>	static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3801	>	PyObject *resultobj;
3802	>	BossDatabase *arg1 = (BossDatabase *) 0 ;
3803	>	BossTask *result;
3804	>	PyObject * obj0 = 0 ;
3805	>
3806	>	if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
3807	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3808	>	{
3809	>	try {
3810	>	result = (BossTask *)new BossTask(arg1);
3811	>
3812	>	}catch (const BossSchedFailure & e) {
3813	>	PyErr_SetString ( SchedulerError, e.what() );
3814	>	return NULL;
3815	>	}catch (const std::exception& e) {
3816	>	PyErr_SetString ( BossError, e.what() );
3817	>	return NULL;
3818	>	}
3819		}
3820	<	}
3821	<	resultobj = result;
3822	<	if (SWIG_IsNewObj(res2)) delete arg2;
3823	<	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;
3820	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3821	>	return resultobj;
3822	>	fail:
3823	>	return NULL;
3824		}
3825
3826
3827	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3828	<	PyObject *resultobj = 0;
3829	<	BossSession *arg1 = (BossSession *) 0 ;
3830	<	std::string *arg2 = 0 ;
3831	<	std::string *arg3 = 0 ;
3832	<	std::string *arg4 = 0 ;
3833	<	std::string *arg5 = 0 ;
3834	<	PyObject *result = 0 ;
3835	<	void *argp1 = 0 ;
3836	<	int res1 = 0 ;
3837	<	int res2 = SWIG_OLDOBJ ;
3838	<	int res3 = SWIG_OLDOBJ ;
3839	<	int res4 = SWIG_OLDOBJ ;
3840	<	int res5 = SWIG_OLDOBJ ;
3841	<	PyObject * obj0 = 0 ;
3842	<	PyObject * obj1 = 0 ;
3843	<	PyObject * obj2 = 0 ;
3844	<	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 &""'");
3827	>	static PyObject *_wrap_new_BossTask__SWIG_1(PyObject *self, PyObject *args) {
3828	>	PyObject *resultobj;
3829	>	BossDatabase *arg1 = (BossDatabase *) 0 ;
3830	>	std::string *arg2 = 0 ;
3831	>	BossTask *result;
3832	>	std::string temp2 ;
3833	>	PyObject * obj0 = 0 ;
3834	>	PyObject * obj1 = 0 ;
3835	>
3836	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_BossTask",&obj0,&obj1)) goto fail;
3837	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3838	>	{
3839	>	if (PyString_Check(obj1)) {
3840	>	temp2 = std::string(PyString_AsString(obj1));
3841	>	arg2 = &temp2;
3842	>	}else {
3843	>	SWIG_exception(SWIG_TypeError, "string expected");
3844	>	}
3845		}
3846	<	arg5 = ptr;
3847	<	}
3848	<	{
3849	<	try {
3850	<	result = (PyObject *)BossSession_schedListMatch__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3851	<	} catch (const std::exception& e) {
3852	<	SWIG_exception(SWIG_RuntimeError, e.what());
3846	>	{
3847	>	try {
3848	>	result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3849	>
3850	>	}catch (const BossSchedFailure & e) {
3851	>	PyErr_SetString ( SchedulerError, e.what() );
3852	>	return NULL;
3853	>	}catch (const std::exception& e) {
3854	>	PyErr_SetString ( BossError, e.what() );
3855	>	return NULL;
3856	>	}
3857		}
3858	<	}
3859	<	resultobj = result;
3860	<	if (SWIG_IsNewObj(res2)) delete arg2;
3861	<	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;
3858	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3859	>	return resultobj;
3860	>	fail:
3861	>	return NULL;
3862		}
3863
3864
3865	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3866	<	PyObject *resultobj = 0;
3867	<	BossSession *arg1 = (BossSession *) 0 ;
3868	<	std::string *arg2 = 0 ;
3869	<	std::string *arg3 = 0 ;
3870	<	std::string *arg4 = 0 ;
3871	<	PyObject *result = 0 ;
3872	<	void *argp1 = 0 ;
3873	<	int res1 = 0 ;
3874	<	int res2 = SWIG_OLDOBJ ;
3875	<	int res3 = SWIG_OLDOBJ ;
3876	<	int res4 = SWIG_OLDOBJ ;
3877	<	PyObject * obj0 = 0 ;
3878	<	PyObject * obj1 = 0 ;
3879	<	PyObject * obj2 = 0 ;
3880	<	PyObject * obj3 = 0 ;
3881	<
3882	<	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());
3865	>	static PyObject *_wrap_delete_BossTask(PyObject *self, PyObject *args) {
3866	>	PyObject *resultobj;
3867	>	BossTask *arg1 = (BossTask *) 0 ;
3868	>	PyObject * obj0 = 0 ;
3869	>
3870	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTask",&obj0)) goto fail;
3871	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3872	>	{
3873	>	try {
3874	>	delete arg1;
3875	>
3876	>	}catch (const BossSchedFailure & e) {
3877	>	PyErr_SetString ( SchedulerError, e.what() );
3878	>	return NULL;
3879	>	}catch (const std::exception& e) {
3880	>	PyErr_SetString ( BossError, e.what() );
3881	>	return NULL;
3882	>	}
3883		}
3884	<	}
3885	<	resultobj = result;
3886	<	if (SWIG_IsNewObj(res2)) delete arg2;
3887	<	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;
3884	>	Py_INCREF(Py_None); resultobj = Py_None;
3885	>	return resultobj;
3886	>	fail:
3887	>	return NULL;
3888		}
3889
3890
3891	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3892	<	PyObject *resultobj = 0;
3893	<	BossSession *arg1 = (BossSession *) 0 ;
3894	<	std::string *arg2 = 0 ;
3895	<	std::string *arg3 = 0 ;
3896	<	PyObject *result = 0 ;
3897	<	void *argp1 = 0 ;
3898	<	int res1 = 0 ;
3899	<	int res2 = SWIG_OLDOBJ ;
3900	<	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 &""'");
3891	>	static PyObject *_wrap_new_BossTask__SWIG_2(PyObject *self, PyObject *args) {
3892	>	PyObject *resultobj;
3893	>	BossTask *arg1 = 0 ;
3894	>	BossTask *result;
3895	>	PyObject * obj0 = 0 ;
3896	>
3897	>	if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
3898	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3899	>	if (arg1 == NULL) {
3900	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3901		}
3902	<	arg3 = ptr;
3903	<	}
3904	<	{
3905	<	try {
3906	<	result = (PyObject *)BossSession_schedListMatch__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
3907	<	} catch (const std::exception& e) {
3908	<	SWIG_exception(SWIG_RuntimeError, e.what());
3902	>	{
3903	>	try {
3904	>	result = (BossTask *)new BossTask((BossTask const &)*arg1);
3905	>
3906	>	}catch (const BossSchedFailure & e) {
3907	>	PyErr_SetString ( SchedulerError, e.what() );
3908	>	return NULL;
3909	>	}catch (const std::exception& e) {
3910	>	PyErr_SetString ( BossError, e.what() );
3911	>	return NULL;
3912	>	}
3913		}
3914	<	}
3915	<	resultobj = result;
3916	<	if (SWIG_IsNewObj(res2)) delete arg2;
3917	<	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;
3914	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3915	>	return resultobj;
3916	>	fail:
3917	>	return NULL;
3918		}
3919
3920
3921	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3922	<	int argc;
3923	<	PyObject *argv[7];
3924	<	int ii;
3925	<
3926	<	if (!PyTuple_Check(args)) SWIG_fail;
3927	<	argc = PyObject_Length(args);
3928	<	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
3929	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3930	<	}
3931	<	if (argc == 3) {
3932	<	int _v;
3933	<	void *vptr = 0;
3934	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3935	<	_v = SWIG_CheckState(res);
3936	<	if (_v) {
3937	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3938	<	_v = SWIG_CheckState(res);
3939	<	if (_v) {
3940	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
13611	<	_v = SWIG_CheckState(res);
3921	>	static PyObject *_wrap_new_BossTask(PyObject *self, PyObject *args) {
3922	>	int argc;
3923	>	PyObject *argv[3];
3924	>	int ii;
3925	>
3926	>	argc = PyObject_Length(args);
3927	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3928	>	argv[ii] = PyTuple_GetItem(args,ii);
3929	>	}
3930	>	if (argc == 1) {
3931	>	int _v;
3932	>	{
3933	>	void *ptr;
3934	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
3935	>	_v = 0;
3936	>	PyErr_Clear();
3937	>	}else {
3938	>	_v = 1;
3939	>	}
3940	>	}
3941		if (_v) {
3942	<	return _wrap_BossSession_schedListMatch__SWIG_3(self, args);
3942	>	return _wrap_new_BossTask__SWIG_0(self,args);
3943		}
13615	–	}
3944		}
3945	<	}
3946	<	if (argc == 4) {
3947	<	int _v;
3948	<	void *vptr = 0;
3949	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3950	<	_v = SWIG_CheckState(res);
3951	<	if (_v) {
3952	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3953	<	_v = SWIG_CheckState(res);
3954	<	if (_v) {
3955	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
13628	<	_v = SWIG_CheckState(res);
3945	>	if (argc == 1) {
3946	>	int _v;
3947	>	{
3948	>	void *ptr;
3949	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3950	>	_v = 0;
3951	>	PyErr_Clear();
3952	>	}else {
3953	>	_v = 1;
3954	>	}
3955	>	}
3956		if (_v) {
3957	<	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	<	}
3957	>	return _wrap_new_BossTask__SWIG_2(self,args);
3958		}
13636	–	}
3959		}
3960	<	}
3961	<	if (argc == 5) {
3962	<	int _v;
3963	<	void *vptr = 0;
3964	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3965	<	_v = SWIG_CheckState(res);
3966	<	if (_v) {
3967	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3968	<	_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);
3960	>	if (argc == 2) {
3961	>	int _v;
3962	>	{
3963	>	void *ptr;
3964	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
3965	>	_v = 0;
3966	>	PyErr_Clear();
3967	>	}else {
3968	>	_v = 1;
3969		}
13659	–	}
3970		}
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);
3971		if (_v) {
3972	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
3973	<	_v = SWIG_CheckState(res);
3974	<	if (_v) {
13679	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
13680	<	_v = SWIG_CheckState(res);
3972	>	{
3973	>	_v = PyString_Check(argv[1]) ? 1 : 0;
3974	>	}
3975		if (_v) {
3976	<	{
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	<	}
3976	>	return _wrap_new_BossTask__SWIG_1(self,args);
3977		}
13690	–	}
3978		}
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 &""'");
13762	–	}
13763	–	if (!ptr) {
13764	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
13765	–	}
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""'");
3979		}
3980	<	arg6 = *ptr;
3981	<	if (SWIG_IsNewObj(res)) delete ptr;
3982	<	}
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;
3980	>
3981	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_BossTask'");
3982	>	return NULL;
3983		}
3984
3985
3986	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3987	<	PyObject *resultobj = 0;
3988	<	BossSession *arg1 = (BossSession *) 0 ;
3989	<	int arg2 ;
3990	<	std::string *arg3 = 0 ;
3991	<	std::string *arg4 = 0 ;
3992	<	std::string *arg5 = 0 ;
3993	<	std::string arg6 ;
3994	<	std::string arg7 ;
3995	<	std::string arg8 ;
3996	<	std::string arg9 ;
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 ;
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""'");
3986	>	static PyObject *_wrap_BossTask_id(PyObject *self, PyObject *args) {
3987	>	PyObject *resultobj;
3988	>	BossTask *arg1 = (BossTask *) 0 ;
3989	>	std::string *result;
3990	>	PyObject * obj0 = 0 ;
3991	>
3992	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_id",&obj0)) goto fail;
3993	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3994	>	{
3995	>	try {
3996	>	{
3997	>	std::string const &_result_ref = ((BossTask const *)arg1)->id();
3998	>	result = (std::string *) &_result_ref;
3999	>	}
4000	>
4001	>	}catch (const BossSchedFailure & e) {
4002	>	PyErr_SetString ( SchedulerError, e.what() );
4003	>	return NULL;
4004	>	}catch (const std::exception& e) {
4005	>	PyErr_SetString ( BossError, e.what() );
4006	>	return NULL;
4007	>	}
4008		}
4009	<	arg9 = *ptr;
4010	<	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());
4009	>	{
4010	>	resultobj = PyString_FromStringAndSize(result->data(),result->size());
4011		}
4012	<	}
4013	<	resultobj = result;
4014	<	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;
4012	>	return resultobj;
4013	>	fail:
4014	>	return NULL;
4015		}
4016
4017
4018	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4019	<	PyObject *resultobj = 0;
4020	<	BossSession *arg1 = (BossSession *) 0 ;
4021	<	int arg2 ;
4022	<	std::string *arg3 = 0 ;
4023	<	std::string *arg4 = 0 ;
4024	<	std::string *arg5 = 0 ;
4025	<	std::string arg6 ;
4026	<	std::string arg7 ;
4027	<	std::string arg8 ;
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 ;
4038	<	PyObject * obj2 = 0 ;
4039	<	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""'");
4018	>	static PyObject *_wrap_BossTask_name(PyObject *self, PyObject *args) {
4019	>	PyObject *resultobj;
4020	>	BossTask *arg1 = (BossTask *) 0 ;
4021	>	std::string *result;
4022	>	PyObject * obj0 = 0 ;
4023	>
4024	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_name",&obj0)) goto fail;
4025	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4026	>	{
4027	>	try {
4028	>	{
4029	>	std::string const &_result_ref = ((BossTask const *)arg1)->name();
4030	>	result = (std::string *) &_result_ref;
4031	>	}
4032	>
4033	>	}catch (const BossSchedFailure & e) {
4034	>	PyErr_SetString ( SchedulerError, e.what() );
4035	>	return NULL;
4036	>	}catch (const std::exception& e) {
4037	>	PyErr_SetString ( BossError, e.what() );
4038	>	return NULL;
4039	>	}
4040		}
4041	<	arg8 = *ptr;
4042	<	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());
4041	>	{
4042	>	resultobj = PyString_FromStringAndSize(result->data(),result->size());
4043		}
4044	<	}
4045	<	resultobj = result;
4046	<	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;
4044	>	return resultobj;
4045	>	fail:
4046	>	return NULL;
4047		}
4048
4049
4050	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4051	<	PyObject *resultobj = 0;
4052	<	BossSession *arg1 = (BossSession *) 0 ;
4053	<	int arg2 ;
4054	<	std::string *arg3 = 0 ;
4055	<	std::string *arg4 = 0 ;
4056	<	std::string *arg5 = 0 ;
4057	<	std::string arg6 ;
4058	<	std::string arg7 ;
4059	<	PyObject *result = 0 ;
4060	<	void *argp1 = 0 ;
4061	<	int res1 = 0 ;
4062	<	int val2 ;
4063	<	int ecode2 = 0 ;
4064	<	int res3 = SWIG_OLDOBJ ;
4065	<	int res4 = SWIG_OLDOBJ ;
4066	<	int res5 = SWIG_OLDOBJ ;
4067	<	PyObject * obj0 = 0 ;
4068	<	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""'");
4050	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
4051	>	PyObject *resultobj;
4052	>	BossTask *arg1 = (BossTask *) 0 ;
4053	>	std::map<std::string,std::string > result;
4054	>	PyObject * obj0 = 0 ;
4055	>
4056	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
4057	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4058	>	{
4059	>	try {
4060	>	result = ((BossTask const *)arg1)->taskMap();
4061	>
4062	>	}catch (const BossSchedFailure & e) {
4063	>	PyErr_SetString ( SchedulerError, e.what() );
4064	>	return NULL;
4065	>	}catch (const std::exception& e) {
4066	>	PyErr_SetString ( BossError, e.what() );
4067	>	return NULL;
4068	>	}
4069		}
4070	<	arg7 = *ptr;
4071	<	if (SWIG_IsNewObj(res)) delete ptr;
4072	<	}
4073	<	{
4074	<	try {
4075	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
4076	<	} catch (const std::exception& e) {
14178	<	SWIG_exception(SWIG_RuntimeError, e.what());
4070	>	{
4071	>	resultobj = PyDict_New();
4072	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4073	>	PyDict_SetItem(resultobj,
4074	>	SwigString_FromString(i->first),
4075	>	SwigString_FromString(i->second));
4076	>	}
4077		}
4078	<	}
4079	<	resultobj = result;
4080	<	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;
4078	>	return resultobj;
4079	>	fail:
4080	>	return NULL;
4081		}
4082
4083
4084	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_4(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	<	std::string arg6 ;
4092	<	PyObject *result = 0 ;
4093	<	void *argp1 = 0 ;
4094	<	int res1 = 0 ;
4095	<	int val2 ;
4096	<	int ecode2 = 0 ;
4097	<	int res3 = SWIG_OLDOBJ ;
4098	<	int res4 = SWIG_OLDOBJ ;
4099	<	int res5 = SWIG_OLDOBJ ;
4100	<	PyObject * obj0 = 0 ;
4101	<	PyObject * obj1 = 0 ;
4102	<	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""'");
4084	>	static PyObject *_wrap_BossTask_job_begin(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_begin",&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_begin();
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	<	arg6 = *ptr;
4105	<	if (SWIG_IsNewObj(res)) delete ptr;
4106	<	}
4107	<	{
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());
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;
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;
4109	>	return resultobj;
4110	>	fail:
4111	>	return NULL;
4112		}
4113
4114
4115	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_5(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	<	std::string *arg5 = 0 ;
4122	<	PyObject *result = 0 ;
4123	<	void *argp1 = 0 ;
4124	<	int res1 = 0 ;
4125	<	int val2 ;
4126	<	int ecode2 = 0 ;
4127	<	int res3 = SWIG_OLDOBJ ;
4128	<	int res4 = SWIG_OLDOBJ ;
4129	<	int res5 = SWIG_OLDOBJ ;
4130	<	PyObject * obj0 = 0 ;
4131	<	PyObject * obj1 = 0 ;
4132	<	PyObject * obj2 = 0 ;
4133	<	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 &""'");
4115	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
4116	>	PyObject *resultobj;
4117	>	BossTask *arg1 = (BossTask *) 0 ;
4118	>	BossTask::job_iterator result;
4119	>	PyObject * obj0 = 0 ;
4120	>
4121	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&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)->job_end();
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	<	arg5 = ptr;
4136	<	}
4137	<	{
4138	<	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());
4135	>	{
4136	>	BossTask::job_iterator * resultptr;
4137	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
4138	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
4139		}
4140	<	}
4141	<	resultobj = result;
4142	<	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;
4140	>	return resultobj;
4141	>	fail:
4142	>	return NULL;
4143		}
4144
4145
4146	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4147	<	PyObject *resultobj = 0;
4148	<	BossSession *arg1 = (BossSession *) 0 ;
4149	<	int arg2 ;
4150	<	std::string *arg3 = 0 ;
4151	<	std::string *arg4 = 0 ;
4152	<	PyObject *result = 0 ;
4153	<	void *argp1 = 0 ;
4154	<	int res1 = 0 ;
4155	<	int val2 ;
4156	<	int ecode2 = 0 ;
4157	<	int res3 = SWIG_OLDOBJ ;
4158	<	int res4 = SWIG_OLDOBJ ;
4159	<	PyObject * obj0 = 0 ;
4160	<	PyObject * obj1 = 0 ;
4161	<	PyObject * obj2 = 0 ;
4162	<	PyObject * obj3 = 0 ;
4163	<
4164	<	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 &""'");
4146	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
4147	>	PyObject *resultobj;
4148	>	BossTask *arg1 = (BossTask *) 0 ;
4149	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4150	>	PyObject * obj0 = 0 ;
4151	>
4152	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
4153	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4154	>	{
4155	>	try {
4156	>	result = ((BossTask const *)arg1)->jobsMap();
4157	>
4158	>	}catch (const BossSchedFailure & e) {
4159	>	PyErr_SetString ( SchedulerError, e.what() );
4160	>	return NULL;
4161	>	}catch (const std::exception& e) {
4162	>	PyErr_SetString ( BossError, e.what() );
4163	>	return NULL;
4164	>	}
4165		}
4166	<	arg4 = ptr;
4167	<	}
4168	<	{
4169	<	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());
4166	>	{
4167	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4168	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4169	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4170		}
4171	<	}
4172	<	resultobj = result;
4173	<	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;
4171	>	return resultobj;
4172	>	fail:
4173	>	return NULL;
4174		}
4175
4176
4177	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4178	<	PyObject *resultobj = 0;
4179	<	BossSession *arg1 = (BossSession *) 0 ;
4180	<	int arg2 ;
4181	<	std::string *arg3 = 0 ;
4182	<	PyObject *result = 0 ;
4183	<	void *argp1 = 0 ;
4184	<	int res1 = 0 ;
4185	<	int val2 ;
4186	<	int ecode2 = 0 ;
4187	<	int res3 = SWIG_OLDOBJ ;
4188	<	PyObject * obj0 = 0 ;
4189	<	PyObject * obj1 = 0 ;
4190	<	PyObject * obj2 = 0 ;
4191	<
4192	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_queryTasks",&obj0,&obj1,&obj2)) SWIG_fail;
4193	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
4194	<	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 &""'");
4177	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
4178	>	PyObject *resultobj;
4179	>	BossTask *arg1 = (BossTask *) 0 ;
4180	>	SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
4181	>	std::map<std::string,std::string > *arg3 = 0 ;
4182	>	std::string result;
4183	>	std::vector<BossJob * >::const_iterator *argp2 ;
4184	>	PyObject * obj0 = 0 ;
4185	>	PyObject * obj1 = 0 ;
4186	>	PyObject * obj2 = 0 ;
4187	>
4188	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobMap",&obj0,&obj1,&obj2)) goto fail;
4189	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4190	>	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
4191	>	arg2 = *argp2;
4192	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4193	>	if (arg3 == NULL) {
4194	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
4195		}
4196	<	if (!ptr) {
4197	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
4196	>	{
4197	>	try {
4198	>	result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
4199	>
4200	>	}catch (const BossSchedFailure & e) {
4201	>	PyErr_SetString ( SchedulerError, e.what() );
4202	>	return NULL;
4203	>	}catch (const std::exception& e) {
4204	>	PyErr_SetString ( BossError, e.what() );
4205	>	return NULL;
4206	>	}
4207		}
4208	<	arg3 = ptr;
4209	<	}
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());
4208	>	{
4209	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
4210		}
4211	<	}
4212	<	resultobj = result;
4213	<	if (SWIG_IsNewObj(res3)) delete arg3;
14490	<	return resultobj;
14491	<	fail:
14492	<	if (SWIG_IsNewObj(res3)) delete arg3;
14493	<	return NULL;
4211	>	return resultobj;
4212	>	fail:
4213	>	return NULL;
4214		}
4215
4216
4217	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4218	<	PyObject *resultobj = 0;
4219	<	BossSession *arg1 = (BossSession *) 0 ;
4220	<	int arg2 ;
4221	<	PyObject *result = 0 ;
4222	<	void *argp1 = 0 ;
4223	<	int res1 = 0 ;
4224	<	int val2 ;
4225	<	int ecode2 = 0 ;
4226	<	PyObject * obj0 = 0 ;
4227	<	PyObject * obj1 = 0 ;
4228	<
4229	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_queryTasks",&obj0,&obj1)) SWIG_fail;
4230	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
4231	<	if (!SWIG_IsOK(res1)) {
4232	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
4233	<	}
4234	<	arg1 = reinterpret_cast< BossSession * >(argp1);
4235	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
4236	<	if (!SWIG_IsOK(ecode2)) {
4237	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
4238	<	}
4239	<	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());
4217	>	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
4218	>	PyObject *resultobj;
4219	>	BossTask *arg1 = (BossTask *) 0 ;
4220	>	unsigned int arg2 ;
4221	>	std::map<std::string,std::string > result;
4222	>	PyObject * obj0 = 0 ;
4223	>	PyObject * obj1 = 0 ;
4224	>
4225	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
4226	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4227	>	arg2 = (unsigned int) PyInt_AsLong(obj1);
4228	>	if (PyErr_Occurred()) SWIG_fail;
4229	>	{
4230	>	try {
4231	>	result = ((BossTask const *)arg1)->jobMap(arg2);
4232	>
4233	>	}catch (const BossSchedFailure & e) {
4234	>	PyErr_SetString ( SchedulerError, e.what() );
4235	>	return NULL;
4236	>	}catch (const std::exception& e) {
4237	>	PyErr_SetString ( BossError, e.what() );
4238	>	return NULL;
4239	>	}
4240		}
4241	<	}
4242	<	resultobj = result;
4243	<	return resultobj;
4244	<	fail:
4245	<	return NULL;
4246	<	}
4247	<
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());
4241	>	{
4242	>	resultobj = PyDict_New();
4243	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
4244	>	PyDict_SetItem(resultobj,
4245	>	SwigString_FromString(i->first),
4246	>	SwigString_FromString(i->second));
4247	>	}
4248		}
4249	<	}
4250	<	resultobj = result;
4251	<	return resultobj;
14557	<	fail:
14558	<	return NULL;
4249	>	return resultobj;
4250	>	fail:
4251	>	return NULL;
4252		}
4253
4254
4255	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
4256	<	int argc;
4257	<	PyObject *argv[11];
4258	<	int ii;
4259	<
4260	<	if (!PyTuple_Check(args)) SWIG_fail;
4261	<	argc = PyObject_Length(args);
4262	<	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	<	}
4255	>	static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4256	>	int argc;
4257	>	PyObject *argv[4];
4258	>	int ii;
4259	>
4260	>	argc = PyObject_Length(args);
4261	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4262	>	argv[ii] = PyTuple_GetItem(args,ii);
4263		}
4264	<	}
4265	<	if (argc == 5) {
4266	<	int _v;
4267	<	void *vptr = 0;
4268	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
4269	<	_v = SWIG_CheckState(res);
4270	<	if (_v) {
4271	<	{
4272	<	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);
4264	>	if (argc == 2) {
4265	>	int _v;
4266	>	{
4267	>	void *ptr;
4268	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4269	>	_v = 0;
4270	>	PyErr_Clear();
4271	>	}else {
4272	>	_v = 1;
4273		}
14660	–	}
4274		}
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);
4275		if (_v) {
4276	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
4277	<	_v = SWIG_CheckState(res);
4278	<	if (_v) {
14682	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
14683	<	_v = SWIG_CheckState(res);
4276	>	{
4277	>	_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
4278	>	}
4279		if (_v) {
4280	<	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	<	}
4280	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
4281		}
14691	–	}
4282		}
14693	–	}
4283		}
4284	<	}
4285	<	if (argc == 7) {
4286	<	int _v;
4287	<	void *vptr = 0;
4288	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
4289	<	_v = SWIG_CheckState(res);
4290	<	if (_v) {
4291	<	{
4292	<	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	<	}
4284	>	if (argc == 3) {
4285	>	int _v;
4286	>	{
4287	>	void *ptr;
4288	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4289	>	_v = 0;
4290	>	PyErr_Clear();
4291	>	}else {
4292	>	_v = 1;
4293		}
14726	–	}
4294		}
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);
4295		if (_v) {
4296	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
4297	<	_v = SWIG_CheckState(res);
4298	<	if (_v) {
4299	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
4300	<	_v = SWIG_CheckState(res);
4301	<	if (_v) {
4302	<	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	<	}
4296	>	{
4297	>	void *ptr;
4298	>	if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator, 0) == -1) {
4299	>	_v = 0;
4300	>	PyErr_Clear();
4301	>	}else {
4302	>	_v = 1;
4303		}
14763	–	}
4304		}
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);
4305		if (_v) {
4306	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
4307	<	_v = SWIG_CheckState(res);
4308	<	if (_v) {
4309	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
4310	<	_v = SWIG_CheckState(res);
4311	<	if (_v) {
4312	<	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);
4306	>	{
4307	>	void *ptr;
4308	>	if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_std__mapTstd__string_std__string_t, 0) == -1) {
4309	>	_v = 0;
4310	>	PyErr_Clear();
4311	>	}else {
4312	>	_v = 1;
4313		}
14804	–	}
4314		}
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);
4315		if (_v) {
4316	<	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	<	}
4316	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4317		}
14855	–	}
4318		}
14857	–	}
4319		}
14859	–	}
4320		}
4321	<	}
4322	<
4323	<	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());
15467	<	}
15468	<	}
15469	<	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));
15470	<	return resultobj;
15471	<	fail:
15472	<	return NULL;
4321	>
4322	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobMap'");
4323	>	return NULL;
4324		}
4325
4326
4327	<	SWIGINTERN PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
4328	<	int argc;
4329	<	PyObject *argv[4];
4330	<	int ii;
4331	<
4332	<	if (!PyTuple_Check(args)) SWIG_fail;
4333	<	argc = PyObject_Length(args);
4334	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4335	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4336	<	}
4337	<	if (argc == 2) {
4338	<	int _v;
4339	<	void *vptr = 0;
4340	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4341	<	_v = SWIG_CheckState(res);
4342	<	if (_v) {
4343	<	{
4344	<	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
4345	<	_v = SWIG_CheckState(res);
4346	<	}
4347	<	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);
4327	>	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4328	>	PyObject *resultobj;
4329	>	BossTask *arg1 = (BossTask *) 0 ;
4330	>	BossJob *arg2 = (BossJob *) 0 ;
4331	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4332	>	PyObject * obj0 = 0 ;
4333	>	PyObject * obj1 = 0 ;
4334	>
4335	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4336	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4337	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4338	>	{
4339	>	try {
4340	>	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4341	>
4342	>	}catch (const BossSchedFailure & e) {
4343	>	PyErr_SetString ( SchedulerError, e.what() );
4344	>	return NULL;
4345	>	}catch (const std::exception& e) {
4346	>	PyErr_SetString ( BossError, e.what() );
4347	>	return NULL;
4348		}
15516	–	}
4349		}
4350	<	}
4351	<
4352	<	fail:
4353	<	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());
4350	>	{
4351	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4352	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4353	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4354		}
4355	<	}
4356	<	resultobj = SWIG_Py_Void();
4357	<	if (SWIG_IsNewObj(res2)) delete arg2;
15695	<	return resultobj;
15696	<	fail:
15697	<	if (SWIG_IsNewObj(res2)) delete arg2;
15698	<	return NULL;
4355	>	return resultobj;
4356	>	fail:
4357	>	return NULL;
4358		}
4359
4360
4361	<	SWIGINTERN PyObject *_wrap_BossTask_declare__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4362	<	PyObject *resultobj = 0;
4363	<	BossTask *arg1 = (BossTask *) 0 ;
4364	<	XMLDoc *arg2 = (XMLDoc *) 0 ;
4365	<	std::string *arg3 = 0 ;
4366	<	void *argp1 = 0 ;
4367	<	int res1 = 0 ;
4368	<	void *argp2 = 0 ;
4369	<	int res2 = 0 ;
4370	<	int res3 = SWIG_OLDOBJ ;
4371	<	PyObject * obj0 = 0 ;
4372	<	PyObject * obj1 = 0 ;
4373	<	PyObject * obj2 = 0 ;
4374	<
4375	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_declare",&obj0,&obj1,&obj2)) SWIG_fail;
4376	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4377	<	if (!SWIG_IsOK(res1)) {
4378	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_declare" "', argument " "1"" of type '" "BossTask *""'");
4379	<	}
4380	<	arg1 = reinterpret_cast< BossTask * >(argp1);
4381	<	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XMLDoc, 0 |  0 );
4382	<	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());
4361	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4362	>	PyObject *resultobj;
4363	>	BossTask *arg1 = (BossTask *) 0 ;
4364	>	BossJob *arg2 = (BossJob *) 0 ;
4365	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4366	>	PyObject * obj0 = 0 ;
4367	>	PyObject * obj1 = 0 ;
4368	>
4369	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4370	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4371	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4372	>	{
4373	>	try {
4374	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4375	>
4376	>	}catch (const BossSchedFailure & e) {
4377	>	PyErr_SetString ( SchedulerError, e.what() );
4378	>	return NULL;
4379	>	}catch (const std::exception& e) {
4380	>	PyErr_SetString ( BossError, e.what() );
4381	>	return NULL;
4382	>	}
4383		}
4384	<	}
4385	<	resultobj = SWIG_Py_Void();
4386	<	if (SWIG_IsNewObj(res3)) delete arg3;
4387	<	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());
4384	>	{
4385	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4386	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4387	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4388		}
4389	<	}
4390	<	resultobj = SWIG_Py_Void();
4391	<	return resultobj;
15785	<	fail:
15786	<	return NULL;
4389	>	return resultobj;
4390	>	fail:
4391	>	return NULL;
4392		}
4393
4394
4395	<	SWIGINTERN PyObject *_wrap_BossTask_declare(PyObject *self, PyObject *args) {
4396	<	int argc;
4397	<	PyObject *argv[4];
4398	<	int ii;
4399	<
4400	<	if (!PyTuple_Check(args)) SWIG_fail;
4401	<	argc = PyObject_Length(args);
4402	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4403	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4404	<	}
4405	<	if (argc == 2) {
4406	<	int _v;
4407	<	void *vptr = 0;
4408	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4409	<	_v = SWIG_CheckState(res);
4410	<	if (_v) {
4411	<	void *vptr = 0;
4412	<	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLDoc, 0);
4413	<	_v = SWIG_CheckState(res);
4414	<	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);
4395	>	static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4396	>	PyObject *resultobj;
4397	>	BossTask *arg1 = (BossTask *) 0 ;
4398	>	std::string *arg2 = 0 ;
4399	>	std::string const &arg3_defvalue = "" ;
4400	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4401	>	std::string temp2 ;
4402	>	std::string temp3 ;
4403	>	PyObject * obj0 = 0 ;
4404	>	PyObject * obj1 = 0 ;
4405	>	PyObject * obj2 = 0 ;
4406	>
4407	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
4408	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4409	>	{
4410	>	if (PyString_Check(obj1)) {
4411	>	temp2 = std::string(PyString_AsString(obj1));
4412	>	arg2 = &temp2;
4413	>	}else {
4414	>	SWIG_exception(SWIG_TypeError, "string expected");
4415		}
15842	–	}
4416		}
4417	<	}
4418	<	if (argc == 3) {
4419	<	int _v;
4420	<	void *vptr = 0;
4421	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4422	<	_v = SWIG_CheckState(res);
4423	<	if (_v) {
4424	<	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);
4417	>	if (obj2) {
4418	>	{
4419	>	if (PyString_Check(obj2)) {
4420	>	temp3 = std::string(PyString_AsString(obj2));
4421	>	arg3 = &temp3;
4422	>	}else {
4423	>	SWIG_exception(SWIG_TypeError, "string expected");
4424	>	}
4425		}
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 &""'");
4426		}
4427	<	if (!ptr) {
4428	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
4429	<	}
4430	<	arg5 = ptr;
4431	<	}
4432	<	{
4433	<	std::string *ptr = (std::string *)0;
4434	<	res6 = SWIG_AsPtr_std_string(obj5, &ptr);
4435	<	if (!SWIG_IsOK(res6)) {
4436	<	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BossTask_submit" "', argument " "6"" of type '" "std::string const &""'");
4437	<	}
16201	<	if (!ptr) {
16202	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "6"" of type '" "std::string const &""'");
16203	<	}
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());
4427	>	{
4428	>	try {
4429	>	(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4430	>
4431	>	}catch (const BossSchedFailure & e) {
4432	>	PyErr_SetString ( SchedulerError, e.what() );
4433	>	return NULL;
4434	>	}catch (const std::exception& e) {
4435	>	PyErr_SetString ( BossError, e.what() );
4436	>	return NULL;
4437	>	}
4438		}
4439	<	}
4440	<	resultobj = SWIG_From_int(static_cast< int >(result));
4441	<	if (SWIG_IsNewObj(res2)) delete arg2;
4442	<	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;
4439	>	Py_INCREF(Py_None); resultobj = Py_None;
4440	>	return resultobj;
4441	>	fail:
4442	>	return NULL;
4443		}
4444
4445
4446	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4447	<	PyObject *resultobj = 0;
4448	<	BossTask *arg1 = (BossTask *) 0 ;
4449	<	std::string *arg2 = 0 ;
4450	<	int result;
4451	<	void *argp1 = 0 ;
4452	<	int res1 = 0 ;
4453	<	int res2 = SWIG_OLDOBJ ;
4454	<	PyObject * obj0 = 0 ;
4455	<	PyObject * obj1 = 0 ;
4456	<
4457	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_submit",&obj0,&obj1)) SWIG_fail;
4458	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4459	<	if (!SWIG_IsOK(res1)) {
4460	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
4461	<	}
4462	<	arg1 = reinterpret_cast< BossTask * >(argp1);
4463	<	{
4464	<	std::string *ptr = (std::string *)0;
4465	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
4466	<	if (!SWIG_IsOK(res2)) {
4467	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
4468	<	}
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());
4446	>	static PyObject *_wrap_BossTask_declare__SWIG_1(PyObject *self, PyObject *args) {
4447	>	PyObject *resultobj;
4448	>	BossTask *arg1 = (BossTask *) 0 ;
4449	>	XMLDoc *arg2 = (XMLDoc *) 0 ;
4450	>	std::string const &arg3_defvalue = "" ;
4451	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4452	>	std::string temp3 ;
4453	>	PyObject * obj0 = 0 ;
4454	>	PyObject * obj1 = 0 ;
4455	>	PyObject * obj2 = 0 ;
4456	>
4457	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
4458	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4459	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_XMLDoc,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4460	>	if (obj2) {
4461	>	{
4462	>	if (PyString_Check(obj2)) {
4463	>	temp3 = std::string(PyString_AsString(obj2));
4464	>	arg3 = &temp3;
4465	>	}else {
4466	>	SWIG_exception(SWIG_TypeError, "string expected");
4467	>	}
4468	>	}
4469		}
4470	<	}
4471	<	resultobj = SWIG_From_int(static_cast< int >(result));
4472	<	if (SWIG_IsNewObj(res2)) delete arg2;
4473	<	return resultobj;
4474	<	fail:
4475	<	if (SWIG_IsNewObj(res2)) delete arg2;
4476	<	return NULL;
4477	<	}
4478	<
4479	<
4480	<	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());
4470	>	{
4471	>	try {
4472	>	(arg1)->declare(arg2,(std::string const &)*arg3);
4473	>
4474	>	}catch (const BossSchedFailure & e) {
4475	>	PyErr_SetString ( SchedulerError, e.what() );
4476	>	return NULL;
4477	>	}catch (const std::exception& e) {
4478	>	PyErr_SetString ( BossError, e.what() );
4479	>	return NULL;
4480	>	}
4481		}
4482	<	}
4483	<	resultobj = SWIG_From_int(static_cast< int >(result));
4484	<	return resultobj;
4485	<	fail:
16526	<	return NULL;
4482	>	Py_INCREF(Py_None); resultobj = Py_None;
4483	>	return resultobj;
4484	>	fail:
4485	>	return NULL;
4486		}
4487
4488
4489	<	SWIGINTERN PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4490	<	int argc;
4491	<	PyObject *argv[8];
4492	<	int ii;
4493	<
4494	<	if (!PyTuple_Check(args)) SWIG_fail;
4495	<	argc = PyObject_Length(args);
4496	<	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	<	}
4489	>	static PyObject *_wrap_BossTask_declare(PyObject *self, PyObject *args) {
4490	>	int argc;
4491	>	PyObject *argv[4];
4492	>	int ii;
4493	>
4494	>	argc = PyObject_Length(args);
4495	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4496	>	argv[ii] = PyTuple_GetItem(args,ii);
4497		}
4498	<	}
4499	<	if (argc == 4) {
4500	<	int _v;
4501	<	void *vptr = 0;
4502	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4503	<	_v = SWIG_CheckState(res);
4504	<	if (_v) {
4505	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4506	<	_v = SWIG_CheckState(res);
4507	<	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	<	}
4498	>	if ((argc >= 2) && (argc <= 3)) {
4499	>	int _v;
4500	>	{
4501	>	void *ptr;
4502	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4503	>	_v = 0;
4504	>	PyErr_Clear();
4505	>	}else {
4506	>	_v = 1;
4507	>	}
4508		}
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);
4509		if (_v) {
4510	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
4511	<	_v = SWIG_CheckState(res);
4512	<	if (_v) {
4513	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
4514	<	_v = SWIG_CheckState(res);
4510	>	{
4511	>	void *ptr;
4512	>	if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_XMLDoc, 0) == -1) {
4513	>	_v = 0;
4514	>	PyErr_Clear();
4515	>	}else {
4516	>	_v = 1;
4517	>	}
4518	>	}
4519		if (_v) {
4520	<	return _wrap_BossTask_submit__SWIG_2(self, args);
4520	>	if (argc <= 2) {
4521	>	return _wrap_BossTask_declare__SWIG_1(self,args);
4522	>	}
4523	>	{
4524	>	_v = PyString_Check(argv[2]) ? 1 : 0;
4525	>	}
4526	>	if (_v) {
4527	>	return _wrap_BossTask_declare__SWIG_1(self,args);
4528	>	}
4529		}
16620	–	}
4530		}
16622	–	}
4531		}
4532	<	}
4533	<	if (argc == 6) {
4534	<	int _v;
4535	<	void *vptr = 0;
4536	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4537	<	_v = SWIG_CheckState(res);
4538	<	if (_v) {
4539	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4540	<	_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	<	}
4532	>	if ((argc >= 2) && (argc <= 3)) {
4533	>	int _v;
4534	>	{
4535	>	void *ptr;
4536	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4537	>	_v = 0;
4538	>	PyErr_Clear();
4539	>	}else {
4540	>	_v = 1;
4541		}
16649	–	}
4542		}
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);
4543		if (_v) {
4544	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
4545	<	_v = SWIG_CheckState(res);
4546	<	if (_v) {
16669	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
16670	<	_v = SWIG_CheckState(res);
4544	>	{
4545	>	_v = PyString_Check(argv[1]) ? 1 : 0;
4546	>	}
4547		if (_v) {
4548	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
4549	<	_v = SWIG_CheckState(res);
4550	<	if (_v) {
4548	>	if (argc <= 2) {
4549	>	return _wrap_BossTask_declare__SWIG_0(self,args);
4550	>	}
4551		{
4552	<	int res = SWIG_AsVal_bool(argv[6], NULL);
16677	<	_v = SWIG_CheckState(res);
4552	>	_v = PyString_Check(argv[2]) ? 1 : 0;
4553		}
4554		if (_v) {
4555	<	return _wrap_BossTask_submit__SWIG_0(self, args);
4555	>	return _wrap_BossTask_declare__SWIG_0(self,args);
4556		}
16682	–	}
4557		}
16684	–	}
4558		}
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 &""'");
16722	–	}
16723	–	if (!ptr) {
16724	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_reSubmit" "', argument " "2"" of type '" "std::string const &""'");
4559		}
4560	<	arg2 = ptr;
4561	<	}
4562	<	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;
4560	>
4561	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_declare'");
4562	>	return NULL;
4563		}
4564
4565
4566	<	SWIGINTERN PyObject *_wrap_BossTask_reSubmit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4567	<	PyObject *resultobj = 0;
4568	<	BossTask *arg1 = (BossTask *) 0 ;
4569	<	std::string *arg2 = 0 ;
4570	<	int result;
4571	<	void *argp1 = 0 ;
4572	<	int res1 = 0 ;
4573	<	int res2 = SWIG_OLDOBJ ;
4574	<	PyObject * obj0 = 0 ;
4575	<	PyObject * obj1 = 0 ;
4576	<
4577	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_reSubmit",&obj0,&obj1)) SWIG_fail;
4578	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4579	<	if (!SWIG_IsOK(res1)) {
4580	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_reSubmit" "', argument " "1"" of type '" "BossTask *""'");
4581	<	}
4582	<	arg1 = reinterpret_cast< BossTask * >(argp1);
4583	<	{
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());
4566	>	static PyObject *_wrap_BossTask_remove(PyObject *self, PyObject *args) {
4567	>	PyObject *resultobj;
4568	>	BossTask *arg1 = (BossTask *) 0 ;
4569	>	PyObject * obj0 = 0 ;
4570	>
4571	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_remove",&obj0)) goto fail;
4572	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4573	>	{
4574	>	try {
4575	>	(arg1)->remove();
4576	>
4577	>	}catch (const BossSchedFailure & e) {
4578	>	PyErr_SetString ( SchedulerError, e.what() );
4579	>	return NULL;
4580	>	}catch (const std::exception& e) {
4581	>	PyErr_SetString ( BossError, e.what() );
4582	>	return NULL;
4583	>	}
4584		}
4585	<	}
4586	<	resultobj = SWIG_From_int(static_cast< int >(result));
4587	<	if (SWIG_IsNewObj(res2)) delete arg2;
4588	<	return resultobj;
16787	<	fail:
16788	<	if (SWIG_IsNewObj(res2)) delete arg2;
16789	<	return NULL;
4585	>	Py_INCREF(Py_None); resultobj = Py_None;
4586	>	return resultobj;
4587	>	fail:
4588	>	return NULL;
4589		}
4590
4591
4592	<	SWIGINTERN PyObject *_wrap_BossTask_reSubmit(PyObject *self, PyObject *args) {
4593	<	int argc;
4594	<	PyObject *argv[4];
4595	<	int ii;
4596	<
4597	<	if (!PyTuple_Check(args)) SWIG_fail;
4598	<	argc = PyObject_Length(args);
4599	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4600	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4601	<	}
4602	<	if (argc == 2) {
4603	<	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) {
4592	>	static PyObject *_wrap_BossTask_archive(PyObject *self, PyObject *args) {
4593	>	PyObject *resultobj;
4594	>	BossTask *arg1 = (BossTask *) 0 ;
4595	>	std::string const &arg2_defvalue = "all" ;
4596	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4597	>	std::string temp2 ;
4598	>	PyObject * obj0 = 0 ;
4599	>	PyObject * obj1 = 0 ;
4600	>
4601	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossTask_archive",&obj0,&obj1)) goto fail;
4602	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4603	>	if (obj1) {
4604		{
4605	<	int res = SWIG_AsVal_bool(argv[2], NULL);
4606	<	_v = SWIG_CheckState(res);
4607	<	}
4608	<	if (_v) {
4609	<	return _wrap_BossTask_reSubmit__SWIG_0(self, args);
4605	>	if (PyString_Check(obj1)) {
4606	>	temp2 = std::string(PyString_AsString(obj1));
4607	>	arg2 = &temp2;
4608	>	}else {
4609	>	SWIG_exception(SWIG_TypeError, "string expected");
4610	>	}
4611		}
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 &""'");
16868	–	}
16869	–	if (!ptr) {
16870	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_kill" "', argument " "2"" of type '" "std::string const &""'");
4612		}
4613	<	arg2 = ptr;
4614	<	}
4615	<	ecode3 = SWIG_AsVal_bool(obj2, &val3);
4616	<	if (!SWIG_IsOK(ecode3)) {
4617	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_kill" "', argument " "3"" of type '" "bool""'");
4618	<	}
4619	<	arg3 = static_cast< bool >(val3);
4620	<	{
4621	<	try {
4622	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4623	<	} 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());
4613	>	{
4614	>	try {
4615	>	(arg1)->archive((std::string const &)*arg2);
4616	>
4617	>	}catch (const BossSchedFailure & e) {
4618	>	PyErr_SetString ( SchedulerError, e.what() );
4619	>	return NULL;
4620	>	}catch (const std::exception& e) {
4621	>	PyErr_SetString ( BossError, e.what() );
4622	>	return NULL;
4623	>	}
4624		}
4625	<	}
4626	<	resultobj = SWIG_From_int(static_cast< int >(result));
4627	<	if (SWIG_IsNewObj(res2)) delete arg2;
4628	<	return resultobj;
16933	<	fail:
16934	<	if (SWIG_IsNewObj(res2)) delete arg2;
16935	<	return NULL;
4625	>	Py_INCREF(Py_None); resultobj = Py_None;
4626	>	return resultobj;
4627	>	fail:
4628	>	return NULL;
4629		}
4630
4631
4632	<	SWIGINTERN PyObject *_wrap_BossTask_kill(PyObject *self, PyObject *args) {
4633	<	int argc;
4634	<	PyObject *argv[4];
4635	<	int ii;
4636	<
4637	<	if (!PyTuple_Check(args)) SWIG_fail;
4638	<	argc = PyObject_Length(args);
4639	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4640	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4641	<	}
4642	<	if (argc == 2) {
4643	<	int _v;
4644	<	void *vptr = 0;
4645	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4646	<	_v = SWIG_CheckState(res);
4647	<	if (_v) {
4648	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4649	<	_v = SWIG_CheckState(res);
4650	<	if (_v) {
4651	<	return _wrap_BossTask_kill__SWIG_1(self, args);
4652	<	}
4653	<	}
4654	<	}
4655	<	if (argc == 3) {
4656	<	int _v;
4657	<	void *vptr = 0;
4658	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4659	<	_v = SWIG_CheckState(res);
4660	<	if (_v) {
4661	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4662	<	_v = SWIG_CheckState(res);
4663	<	if (_v) {
4632	>	static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4633	>	PyObject *resultobj;
4634	>	BossTask *arg1 = (BossTask *) 0 ;
4635	>	std::string const &arg2_defvalue = "all" ;
4636	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4637	>	std::string const &arg3_defvalue = "" ;
4638	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4639	>	std::string const &arg4_defvalue = "" ;
4640	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4641	>	std::string const &arg5_defvalue = "" ;
4642	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
4643	>	std::string const &arg6_defvalue = "" ;
4644	>	std::string *arg6 = (std::string *) &arg6_defvalue ;
4645	>	unsigned int arg7 = (unsigned int) 0 ;
4646	>	bool arg8 = (bool) false ;
4647	>	int result;
4648	>	std::string temp2 ;
4649	>	std::string temp3 ;
4650	>	std::string temp4 ;
4651	>	std::string temp5 ;
4652	>	std::string temp6 ;
4653	>	PyObject * obj0 = 0 ;
4654	>	PyObject * obj1 = 0 ;
4655	>	PyObject * obj2 = 0 ;
4656	>	PyObject * obj3 = 0 ;
4657	>	PyObject * obj4 = 0 ;
4658	>	PyObject * obj5 = 0 ;
4659	>	PyObject * obj6 = 0 ;
4660	>	PyObject * obj7 = 0 ;
4661	>
4662	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4663	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4664	>	if (obj1) {
4665		{
4666	<	int res = SWIG_AsVal_bool(argv[2], NULL);
4667	<	_v = SWIG_CheckState(res);
4668	<	}
4669	<	if (_v) {
4670	<	return _wrap_BossTask_kill__SWIG_0(self, args);
4666	>	if (PyString_Check(obj1)) {
4667	>	temp2 = std::string(PyString_AsString(obj1));
4668	>	arg2 = &temp2;
4669	>	}else {
4670	>	SWIG_exception(SWIG_TypeError, "string expected");
4671	>	}
4672		}
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 &""'");
17035	–	}
17036	–	arg3 = ptr;
17037	–	}
17038	–	ecode4 = SWIG_AsVal_bool(obj3, &val4);
17039	–	if (!SWIG_IsOK(ecode4)) {
17040	–	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_getOutput" "', argument " "4"" of type '" "bool""'");
17041	–	}
17042	–	arg4 = static_cast< bool >(val4);
17043	–	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 &""'");
4673		}
4674	<	arg2 = ptr;
4675	<	}
4676	<	{
4677	<	std::string *ptr = (std::string *)0;
4678	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
4679	<	if (!SWIG_IsOK(res3)) {
4680	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
4681	<	}
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);
4674	>	if (obj2) {
4675	>	{
4676	>	if (PyString_Check(obj2)) {
4677	>	temp3 = std::string(PyString_AsString(obj2));
4678	>	arg3 = &temp3;
4679	>	}else {
4680	>	SWIG_exception(SWIG_TypeError, "string expected");
4681	>	}
4682		}
17313	–	}
4683		}
4684	<	}
4685	<	if (argc == 4) {
4686	<	int _v;
4687	<	void *vptr = 0;
4688	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4689	<	_v = SWIG_CheckState(res);
4690	<	if (_v) {
4691	<	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	<	}
4684	>	if (obj3) {
4685	>	{
4686	>	if (PyString_Check(obj3)) {
4687	>	temp4 = std::string(PyString_AsString(obj3));
4688	>	arg4 = &temp4;
4689	>	}else {
4690	>	SWIG_exception(SWIG_TypeError, "string expected");
4691	>	}
4692		}
17336	–	}
4693		}
4694	<	}
4695	<	if (argc == 5) {
4696	<	int _v;
4697	<	void *vptr = 0;
4698	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4699	<	_v = SWIG_CheckState(res);
4700	<	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);
4694	>	if (obj4) {
4695	>	{
4696	>	if (PyString_Check(obj4)) {
4697	>	temp5 = std::string(PyString_AsString(obj4));
4698	>	arg5 = &temp5;
4699	>	}else {
4700	>	SWIG_exception(SWIG_TypeError, "string expected");
4701		}
4702	<	if (_v) {
4703	<	return _wrap_BossTask_getOutput__SWIG_0(self, args);
4702	>	}
4703	>	}
4704	>	if (obj5) {
4705	>	{
4706	>	if (PyString_Check(obj5)) {
4707	>	temp6 = std::string(PyString_AsString(obj5));
4708	>	arg6 = &temp6;
4709	>	}else {
4710	>	SWIG_exception(SWIG_TypeError, "string expected");
4711		}
17363	–	}
4712		}
17365	–	}
4713		}
4714	<	}
4715	<
4716	<	fail:
17370	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_getOutput'");
17371	<	return NULL;
17372	<	}
17373	<
17374	<
17375	<	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 &""'");
4714	>	if (obj6) {
4715	>	arg7 = (unsigned int) PyInt_AsLong(obj6);
4716	>	if (PyErr_Occurred()) SWIG_fail;
4717		}
4718	<	if (!ptr) {
4719	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
4718	>	if (obj7) {
4719	>	arg8 = PyInt_AsLong(obj7) ? true : false;
4720	>	if (PyErr_Occurred()) SWIG_fail;
4721		}
4722	<	arg2 = ptr;
4723	<	}
4724	<	ecode3 = SWIG_AsVal_bool(obj2, &val3);
4725	<	if (!SWIG_IsOK(ecode3)) {
4726	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_getAllOutput" "', argument " "3"" of type '" "bool""'");
4727	<	}
4728	<	arg3 = static_cast< bool >(val3);
4729	<	ecode4 = SWIG_AsVal_bool(obj3, &val4);
4730	<	if (!SWIG_IsOK(ecode4)) {
4731	<	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_getAllOutput" "', argument " "4"" of type '" "bool""'");
4732	<	}
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());
4722	>	{
4723	>	try {
4724	>	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,arg8);
4725	>
4726	>	}catch (const BossSchedFailure & e) {
4727	>	PyErr_SetString ( SchedulerError, e.what() );
4728	>	return NULL;
4729	>	}catch (const std::exception& e) {
4730	>	PyErr_SetString ( BossError, e.what() );
4731	>	return NULL;
4732	>	}
4733		}
4734	<	}
4735	<	resultobj = SWIG_From_int(static_cast< int >(result));
4736	<	if (SWIG_IsNewObj(res2)) delete arg2;
4737	<	return resultobj;
17431	<	fail:
17432	<	if (SWIG_IsNewObj(res2)) delete arg2;
17433	<	return NULL;
4734	>	resultobj = PyInt_FromLong((long)result);
4735	>	return resultobj;
4736	>	fail:
4737	>	return NULL;
4738		}
4739
4740
4741	<	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4742	<	PyObject *resultobj = 0;
4743	<	BossTask *arg1 = (BossTask *) 0 ;
4744	<	std::string *arg2 = 0 ;
4745	<	bool arg3 ;
4746	<	int result;
4747	<	void *argp1 = 0 ;
4748	<	int res1 = 0 ;
4749	<	int res2 = SWIG_OLDOBJ ;
4750	<	bool val3 ;
4751	<	int ecode3 = 0 ;
4752	<	PyObject * obj0 = 0 ;
4753	<	PyObject * obj1 = 0 ;
4754	<	PyObject * obj2 = 0 ;
4755	<
4756	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2)) SWIG_fail;
4757	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4758	<	if (!SWIG_IsOK(res1)) {
4759	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getAllOutput" "', argument " "1"" of type '" "BossTask *""'");
4760	<	}
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 &""'");
4741	>	static PyObject *_wrap_BossTask_reSubmit(PyObject *self, PyObject *args) {
4742	>	PyObject *resultobj;
4743	>	BossTask *arg1 = (BossTask *) 0 ;
4744	>	std::string *arg2 = 0 ;
4745	>	bool arg3 = (bool) false ;
4746	>	int result;
4747	>	std::string temp2 ;
4748	>	PyObject * obj0 = 0 ;
4749	>	PyObject * obj1 = 0 ;
4750	>	PyObject * obj2 = 0 ;
4751	>
4752	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_reSubmit",&obj0,&obj1,&obj2)) goto fail;
4753	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4754	>	{
4755	>	if (PyString_Check(obj1)) {
4756	>	temp2 = std::string(PyString_AsString(obj1));
4757	>	arg2 = &temp2;
4758	>	}else {
4759	>	SWIG_exception(SWIG_TypeError, "string expected");
4760	>	}
4761		}
4762	<	if (!ptr) {
4763	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
4762	>	if (obj2) {
4763	>	arg3 = PyInt_AsLong(obj2) ? true : false;
4764	>	if (PyErr_Occurred()) SWIG_fail;
4765		}
4766	<	arg2 = ptr;
4767	<	}
4768	<	ecode3 = SWIG_AsVal_bool(obj2, &val3);
4769	<	if (!SWIG_IsOK(ecode3)) {
4770	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_getAllOutput" "', argument " "3"" of type '" "bool""'");
4771	<	}
4772	<	arg3 = static_cast< bool >(val3);
4773	<	{
4774	<	try {
4775	<	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3);
4776	<	} catch (const std::exception& e) {
17478	<	SWIG_exception(SWIG_RuntimeError, e.what());
4766	>	{
4767	>	try {
4768	>	result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4769	>
4770	>	}catch (const BossSchedFailure & e) {
4771	>	PyErr_SetString ( SchedulerError, e.what() );
4772	>	return NULL;
4773	>	}catch (const std::exception& e) {
4774	>	PyErr_SetString ( BossError, e.what() );
4775	>	return NULL;
4776	>	}
4777		}
4778	<	}
4779	<	resultobj = SWIG_From_int(static_cast< int >(result));
4780	<	if (SWIG_IsNewObj(res2)) delete arg2;
4781	<	return resultobj;
17484	<	fail:
17485	<	if (SWIG_IsNewObj(res2)) delete arg2;
17486	<	return NULL;
4778	>	resultobj = PyInt_FromLong((long)result);
4779	>	return resultobj;
4780	>	fail:
4781	>	return NULL;
4782		}
4783
4784
4785	<	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4786	<	PyObject *resultobj = 0;
4787	<	BossTask *arg1 = (BossTask *) 0 ;
4788	<	std::string *arg2 = 0 ;
4789	<	int result;
4790	<	void *argp1 = 0 ;
4791	<	int res1 = 0 ;
4792	<	int res2 = SWIG_OLDOBJ ;
4793	<	PyObject * obj0 = 0 ;
4794	<	PyObject * obj1 = 0 ;
4795	<
4796	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_getAllOutput",&obj0,&obj1)) SWIG_fail;
4797	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4798	<	if (!SWIG_IsOK(res1)) {
4799	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getAllOutput" "', argument " "1"" of type '" "BossTask *""'");
4800	<	}
4801	<	arg1 = reinterpret_cast< BossTask * >(argp1);
4802	<	{
4803	<	std::string *ptr = (std::string *)0;
4804	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
4805	<	if (!SWIG_IsOK(res2)) {
4806	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
4785	>	static PyObject *_wrap_BossTask_kill(PyObject *self, PyObject *args) {
4786	>	PyObject *resultobj;
4787	>	BossTask *arg1 = (BossTask *) 0 ;
4788	>	std::string *arg2 = 0 ;
4789	>	unsigned int arg3 = (unsigned int) 0 ;
4790	>	bool arg4 = (bool) false ;
4791	>	int result;
4792	>	std::string temp2 ;
4793	>	PyObject * obj0 = 0 ;
4794	>	PyObject * obj1 = 0 ;
4795	>	PyObject * obj2 = 0 ;
4796	>	PyObject * obj3 = 0 ;
4797	>
4798	>	if(!PyArg_ParseTuple(args,(char *)"OO|OO:BossTask_kill",&obj0,&obj1,&obj2,&obj3)) goto fail;
4799	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4800	>	{
4801	>	if (PyString_Check(obj1)) {
4802	>	temp2 = std::string(PyString_AsString(obj1));
4803	>	arg2 = &temp2;
4804	>	}else {
4805	>	SWIG_exception(SWIG_TypeError, "string expected");
4806	>	}
4807		}
4808	<	if (!ptr) {
4809	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
4808	>	if (obj2) {
4809	>	arg3 = (unsigned int) PyInt_AsLong(obj2);
4810	>	if (PyErr_Occurred()) SWIG_fail;
4811		}
4812	<	arg2 = ptr;
4813	<	}
4814	<	{
17519	<	try {
17520	<	result = (int)(arg1)->getAllOutput((std::string const &)*arg2);
17521	<	} catch (const std::exception& e) {
17522	<	SWIG_exception(SWIG_RuntimeError, e.what());
4812	>	if (obj3) {
4813	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4814	>	if (PyErr_Occurred()) SWIG_fail;
4815		}
4816	<	}
4817	<	resultobj = SWIG_From_int(static_cast< int >(result));
4818	<	if (SWIG_IsNewObj(res2)) delete arg2;
4819	<	return resultobj;
4820	<	fail:
4821	<	if (SWIG_IsNewObj(res2)) delete arg2;
4822	<	return NULL;
4823	<	}
4824	<
4825	<
4826	<	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());
4816	>	{
4817	>	try {
4818	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3,arg4);
4819	>
4820	>	}catch (const BossSchedFailure & e) {
4821	>	PyErr_SetString ( SchedulerError, e.what() );
4822	>	return NULL;
4823	>	}catch (const std::exception& e) {
4824	>	PyErr_SetString ( BossError, e.what() );
4825	>	return NULL;
4826	>	}
4827		}
4828	<	}
4829	<	resultobj = SWIG_From_int(static_cast< int >(result));
4830	<	return resultobj;
4831	<	fail:
17558	<	return NULL;
4828	>	resultobj = PyInt_FromLong((long)result);
4829	>	return resultobj;
4830	>	fail:
4831	>	return NULL;
4832		}
4833
4834
4835	<	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput(PyObject *self, PyObject *args) {
4836	<	int argc;
4837	<	PyObject *argv[5];
4838	<	int ii;
4839	<
4840	<	if (!PyTuple_Check(args)) SWIG_fail;
4841	<	argc = PyObject_Length(args);
4842	<	for (ii = 0; (ii < argc) && (ii < 4); ii++) {
4843	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4844	<	}
4845	<	if (argc == 1) {
4846	<	int _v;
4847	<	void *vptr = 0;
4848	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4849	<	_v = SWIG_CheckState(res);
4850	<	if (_v) {
4851	<	return _wrap_BossTask_getAllOutput__SWIG_3(self, args);
4852	<	}
4853	<	}
4854	<	if (argc == 2) {
4855	<	int _v;
4856	<	void *vptr = 0;
4857	<	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) {
4835	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4836	>	PyObject *resultobj;
4837	>	BossTask *arg1 = (BossTask *) 0 ;
4838	>	std::string const &arg2_defvalue = "all" ;
4839	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4840	>	std::string const &arg3_defvalue = "" ;
4841	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4842	>	unsigned int arg4 = (unsigned int) 0 ;
4843	>	bool arg5 = (bool) false ;
4844	>	bool arg6 = (bool) false ;
4845	>	int result;
4846	>	std::string temp2 ;
4847	>	std::string temp3 ;
4848	>	PyObject * obj0 = 0 ;
4849	>	PyObject * obj1 = 0 ;
4850	>	PyObject * obj2 = 0 ;
4851	>	PyObject * obj3 = 0 ;
4852	>	PyObject * obj4 = 0 ;
4853	>	PyObject * obj5 = 0 ;
4854	>
4855	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
4856	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4857	>	if (obj1) {
4858		{
4859	<	int res = SWIG_AsVal_bool(argv[2], NULL);
4860	<	_v = SWIG_CheckState(res);
4861	<	}
4862	<	if (_v) {
4863	<	return _wrap_BossTask_getAllOutput__SWIG_1(self, args);
4859	>	if (PyString_Check(obj1)) {
4860	>	temp2 = std::string(PyString_AsString(obj1));
4861	>	arg2 = &temp2;
4862	>	}else {
4863	>	SWIG_exception(SWIG_TypeError, "string expected");
4864	>	}
4865		}
17610	–	}
4866		}
4867	<	}
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) {
4867	>	if (obj2) {
4868		{
4869	<	int res = SWIG_AsVal_bool(argv[2], NULL);
4870	<	_v = SWIG_CheckState(res);
4871	<	}
4872	<	if (_v) {
4873	<	{
4874	<	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	<	}
4869	>	if (PyString_Check(obj2)) {
4870	>	temp3 = std::string(PyString_AsString(obj2));
4871	>	arg3 = &temp3;
4872	>	}else {
4873	>	SWIG_exception(SWIG_TypeError, "string expected");
4874	>	}
4875		}
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 &""'");
4876		}
4877	<	if (!ptr) {
4878	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
4877	>	if (obj3) {
4878	>	arg4 = (unsigned int) PyInt_AsLong(obj3);
4879	>	if (PyErr_Occurred()) SWIG_fail;
4880		}
4881	<	arg3 = ptr;
4882	<	}
4883	<	{
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 &""'");
4881	>	if (obj4) {
4882	>	arg5 = PyInt_AsLong(obj4) ? true : false;
4883	>	if (PyErr_Occurred()) SWIG_fail;
4884		}
4885	<	if (!ptr) {
4886	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
4885	>	if (obj5) {
4886	>	arg6 = PyInt_AsLong(obj5) ? true : false;
4887	>	if (PyErr_Occurred()) SWIG_fail;
4888		}
4889	<	arg4 = ptr;
4890	<	}
4891	<	{
4892	<	std::string *ptr = (std::string *)0;
4893	<	int res = SWIG_AsPtr_std_string(obj4, &ptr);
4894	<	if (!SWIG_IsOK(res) || !ptr) {
4895	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
4896	<	}
4897	<	arg5 = *ptr;
4898	<	if (SWIG_IsNewObj(res)) delete ptr;
4899	<	}
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 &""'");
18253	<	}
18254	<	if (!ptr) {
18255	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18256	<	}
18257	<	arg3 = ptr;
18258	<	}
18259	<	{
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());
18264	<	}
18265	<	}
18266	<	resultobj = SWIG_From_int(static_cast< int >(result));
18267	<	if (SWIG_IsNewObj(res3)) delete arg3;
18268	<	return resultobj;
18269	<	fail:
18270	<	if (SWIG_IsNewObj(res3)) delete arg3;
18271	<	return NULL;
18272	<	}
18273	<
18274	<
18275	<	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());
4889	>	{
4890	>	try {
4891	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
4892	>
4893	>	}catch (const BossSchedFailure & e) {
4894	>	PyErr_SetString ( SchedulerError, e.what() );
4895	>	return NULL;
4896	>	}catch (const std::exception& e) {
4897	>	PyErr_SetString ( BossError, e.what() );
4898	>	return NULL;
4899	>	}
4900		}
4901	<	}
4902	<	resultobj = SWIG_From_int(static_cast< int >(result));
4903	<	return resultobj;
4904	<	fail:
18336	<	return NULL;
4901	>	resultobj = PyInt_FromLong((long)result);
4902	>	return resultobj;
4903	>	fail:
4904	>	return NULL;
4905		}
4906
4907
4908	<	SWIGINTERN PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
4909	<	int argc;
4910	<	PyObject *argv[10];
4911	<	int ii;
4912	<
4913	<	if (!PyTuple_Check(args)) SWIG_fail;
4914	<	argc = PyObject_Length(args);
4915	<	for (ii = 0; (ii < argc) && (ii < 9); ii++) {
4916	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4917	<	}
4918	<	if (argc == 1) {
4919	<	int _v;
4920	<	void *vptr = 0;
4921	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4922	<	_v = SWIG_CheckState(res);
4923	<	if (_v) {
4924	<	return _wrap_BossTask_query__SWIG_8(self, args);
4925	<	}
4926	<	}
4927	<	if (argc == 2) {
4928	<	int _v;
4929	<	void *vptr = 0;
4930	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4931	<	_v = SWIG_CheckState(res);
4932	<	if (_v) {
4933	<	{
4934	<	int res = SWIG_AsVal_int(argv[1], NULL);
4935	<	_v = SWIG_CheckState(res);
4936	<	}
4937	<	if (_v) {
4938	<	return _wrap_BossTask_query__SWIG_7(self, args);
4939	<	}
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);
4908	>	static PyObject *_wrap_BossTask_load(PyObject *self, PyObject *args) {
4909	>	PyObject *resultobj;
4910	>	BossTask *arg1 = (BossTask *) 0 ;
4911	>	int arg2 = (int) SCHEDULED ;
4912	>	std::string const &arg3_defvalue = "all" ;
4913	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4914	>	std::string const &arg4_defvalue = "" ;
4915	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4916	>	std::string arg5 = (std::string) "" ;
4917	>	std::string arg6 = (std::string) "" ;
4918	>	std::string arg7 = (std::string) "" ;
4919	>	std::string arg8 = (std::string) "" ;
4920	>	int result;
4921	>	std::string temp3 ;
4922	>	std::string temp4 ;
4923	>	PyObject * obj0 = 0 ;
4924	>	PyObject * obj2 = 0 ;
4925	>	PyObject * obj3 = 0 ;
4926	>	PyObject * obj4 = 0 ;
4927	>	PyObject * obj5 = 0 ;
4928	>	PyObject * obj6 = 0 ;
4929	>	PyObject * obj7 = 0 ;
4930	>
4931	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOO:BossTask_load",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
4932	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4933	>	if (obj2) {
4934	>	{
4935	>	if (PyString_Check(obj2)) {
4936	>	temp3 = std::string(PyString_AsString(obj2));
4937	>	arg3 = &temp3;
4938	>	}else {
4939	>	SWIG_exception(SWIG_TypeError, "string expected");
4940		}
18438	–	}
4941		}
18440	–	}
4942		}
4943	<	}
4944	<	if (argc == 6) {
4945	<	int _v;
4946	<	void *vptr = 0;
4947	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4948	<	_v = SWIG_CheckState(res);
4949	<	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	<	}
4943	>	if (obj3) {
4944	>	{
4945	>	if (PyString_Check(obj3)) {
4946	>	temp4 = std::string(PyString_AsString(obj3));
4947	>	arg4 = &temp4;
4948	>	}else {
4949	>	SWIG_exception(SWIG_TypeError, "string expected");
4950		}
18469	–	}
4951		}
18471	–	}
4952		}
4953	<	}
4954	<	if (argc == 7) {
4955	<	int _v;
4956	<	void *vptr = 0;
4957	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4958	<	_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	<	}
4953	>	if (obj4) {
4954	>	{
4955	>	if (PyString_Check(obj4))
4956	>	arg5 = std::string(PyString_AsString(obj4));
4957	>	else
4958	>	SWIG_exception(SWIG_TypeError, "string expected");
4959		}
18506	–	}
4960		}
4961	<	}
4962	<	if (argc == 8) {
4963	<	int _v;
4964	<	void *vptr = 0;
4965	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4966	<	_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	<	}
4961	>	if (obj5) {
4962	>	{
4963	>	if (PyString_Check(obj5))
4964	>	arg6 = std::string(PyString_AsString(obj5));
4965	>	else
4966	>	SWIG_exception(SWIG_TypeError, "string expected");
4967		}
18545	–	}
4968		}
4969	<	}
4970	<	if (argc == 9) {
4971	<	int _v;
4972	<	void *vptr = 0;
4973	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4974	<	_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	<	}
4969	>	if (obj6) {
4970	>	{
4971	>	if (PyString_Check(obj6))
4972	>	arg7 = std::string(PyString_AsString(obj6));
4973	>	else
4974	>	SWIG_exception(SWIG_TypeError, "string expected");
4975		}
18590	–	}
4976		}
4977	<	}
4978	<
4979	<	fail:
4980	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_query'");
4981	<	return NULL;
4982	<	}
4983	<
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());
18665	<	}
18666	<	}
18667	<	resultobj = SWIG_Py_Void();
18668	<	return resultobj;
18669	<	fail:
18670	<	return NULL;
18671	<	}
18672	<
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());
4977	>	if (obj7) {
4978	>	{
4979	>	if (PyString_Check(obj7))
4980	>	arg8 = std::string(PyString_AsString(obj7));
4981	>	else
4982	>	SWIG_exception(SWIG_TypeError, "string expected");
4983	>	}
4984		}
4985	<	}
4986	<	resultobj = SWIG_Py_Void();
4987	<	return resultobj;
4988	<	fail:
4989	<	return NULL;
4990	<	}
4991	<
4992	<
4993	<	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4994	<	PyObject *resultobj = 0;
4995	<	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());
4985	>	{
4986	>	try {
4987	>	result = (int)(arg1)->load(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
4988	>
4989	>	}catch (const BossSchedFailure & e) {
4990	>	PyErr_SetString ( SchedulerError, e.what() );
4991	>	return NULL;
4992	>	}catch (const std::exception& e) {
4993	>	PyErr_SetString ( BossError, e.what() );
4994	>	return NULL;
4995	>	}
4996		}
4997	<	}
4998	<	resultobj = SWIG_Py_Void();
4999	<	return resultobj;
5000	<	fail:
18850	<	return NULL;
4997	>	resultobj = PyInt_FromLong((long)result);
4998	>	return resultobj;
4999	>	fail:
5000	>	return NULL;
5001		}
5002
5003
5004	<	SWIGINTERN PyObject *_wrap_BossTask_query_out(PyObject *self, PyObject *args) {
5005	<	int argc;
5006	<	PyObject *argv[6];
5007	<	int ii;
5008	<
5009	<	if (!PyTuple_Check(args)) SWIG_fail;
5010	<	argc = PyObject_Length(args);
5011	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
5012	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5013	<	}
5014	<	if (argc == 1) {
5015	<	int _v;
5016	<	void *vptr = 0;
5017	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
5018	<	_v = SWIG_CheckState(res);
5019	<	if (_v) {
5020	<	return _wrap_BossTask_query_out__SWIG_4(self, args);
5021	<	}
5022	<	}
5023	<	if (argc == 2) {
5024	<	int _v;
5025	<	void *vptr = 0;
5026	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
5027	<	_v = SWIG_CheckState(res);
5028	<	if (_v) {
5029	<	void *vptr = 0;
5030	<	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, 0);
5031	<	_v = SWIG_CheckState(res);
5032	<	if (_v) {
5033	<	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) {
5004	>	static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
5005	>	PyObject *resultobj;
5006	>	BossTask *arg1 = (BossTask *) 0 ;
5007	>	int arg2 = (int) SCHEDULED ;
5008	>	std::string const &arg3_defvalue = "all" ;
5009	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
5010	>	std::string const &arg4_defvalue = "" ;
5011	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
5012	>	std::string arg5 = (std::string) "" ;
5013	>	std::string arg6 = (std::string) "" ;
5014	>	std::string arg7 = (std::string) "" ;
5015	>	std::string arg8 = (std::string) "" ;
5016	>	unsigned int arg9 = (unsigned int) 0 ;
5017	>	bool arg10 = (bool) false ;
5018	>	int result;
5019	>	std::string temp3 ;
5020	>	std::string temp4 ;
5021	>	PyObject * obj0 = 0 ;
5022	>	PyObject * obj2 = 0 ;
5023	>	PyObject * obj3 = 0 ;
5024	>	PyObject * obj4 = 0 ;
5025	>	PyObject * obj5 = 0 ;
5026	>	PyObject * obj6 = 0 ;
5027	>	PyObject * obj7 = 0 ;
5028	>	PyObject * obj8 = 0 ;
5029	>	PyObject * obj9 = 0 ;
5030	>
5031	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
5032	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5033	>	if (obj2) {
5034		{
5035	<	int res = SWIG_AsVal_int(argv[2], NULL);
5036	<	_v = SWIG_CheckState(res);
5035	>	if (PyString_Check(obj2)) {
5036	>	temp3 = std::string(PyString_AsString(obj2));
5037	>	arg3 = &temp3;
5038	>	}else {
5039	>	SWIG_exception(SWIG_TypeError, "string expected");
5040	>	}
5041		}
5042	<	if (_v) {
5043	<	return _wrap_BossTask_query_out__SWIG_2(self, args);
5042	>	}
5043	>	if (obj3) {
5044	>	{
5045	>	if (PyString_Check(obj3)) {
5046	>	temp4 = std::string(PyString_AsString(obj3));
5047	>	arg4 = &temp4;
5048	>	}else {
5049	>	SWIG_exception(SWIG_TypeError, "string expected");
5050	>	}
5051		}
18904	–	}
5052		}
5053	<	}
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) {
5053	>	if (obj4) {
5054		{
5055	<	int res = SWIG_AsVal_int(argv[2], NULL);
5056	<	_v = SWIG_CheckState(res);
5055	>	if (PyString_Check(obj4))
5056	>	arg5 = std::string(PyString_AsString(obj4));
5057	>	else
5058	>	SWIG_exception(SWIG_TypeError, "string expected");
5059		}
5060	<	if (_v) {
5061	<	{
5062	<	int res = SWIG_AsVal_int(argv[3], NULL);
5063	<	_v = SWIG_CheckState(res);
5064	<	}
5065	<	if (_v) {
5066	<	return _wrap_BossTask_query_out__SWIG_1(self, args);
18928	<	}
5060	>	}
5061	>	if (obj5) {
5062	>	{
5063	>	if (PyString_Check(obj5))
5064	>	arg6 = std::string(PyString_AsString(obj5));
5065	>	else
5066	>	SWIG_exception(SWIG_TypeError, "string expected");
5067		}
18930	–	}
5068		}
5069	<	}
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) {
5069	>	if (obj6) {
5070		{
5071	<	int res = SWIG_AsVal_int(argv[2], NULL);
5072	<	_v = SWIG_CheckState(res);
5071	>	if (PyString_Check(obj6))
5072	>	arg7 = std::string(PyString_AsString(obj6));
5073	>	else
5074	>	SWIG_exception(SWIG_TypeError, "string expected");
5075		}
5076	<	if (_v) {
5077	<	{
5078	<	int res = SWIG_AsVal_int(argv[3], NULL);
5079	<	_v = SWIG_CheckState(res);
5080	<	}
5081	<	if (_v) {
5082	<	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	<	}
5076	>	}
5077	>	if (obj7) {
5078	>	{
5079	>	if (PyString_Check(obj7))
5080	>	arg8 = std::string(PyString_AsString(obj7));
5081	>	else
5082	>	SWIG_exception(SWIG_TypeError, "string expected");
5083		}
18960	–	}
5084		}
5085	<	}
5086	<
5087	<	fail:
18965	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_query_out'");
18966	<	return NULL;
18967	<	}
18968	<
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());
5085	>	if (obj8) {
5086	>	arg9 = (unsigned int) PyInt_AsLong(obj8);
5087	>	if (PyErr_Occurred()) SWIG_fail;
5088		}
5089	<	}
5090	<	resultobj = SWIG_Py_Void();
5091	<	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());
5089	>	if (obj9) {
5090	>	arg10 = PyInt_AsLong(obj9) ? true : false;
5091	>	if (PyErr_Occurred()) SWIG_fail;
5092		}
5093	<	}
5094	<	resultobj = result;
5095	<	return resultobj;
5096	<	fail:
5097	<	return NULL;
5098	<	}
5099	<
5100	<
5101	<	SWIGINTERN PyObject *_wrap_BossTask_jobDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5102	<	PyObject *resultobj = 0;
5103	<	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());
5093	>	{
5094	>	try {
5095	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5096	>
5097	>	}catch (const BossSchedFailure & e) {
5098	>	PyErr_SetString ( SchedulerError, e.what() );
5099	>	return NULL;
5100	>	}catch (const std::exception& e) {
5101	>	PyErr_SetString ( BossError, e.what() );
5102	>	return NULL;
5103	>	}
5104		}
5105	<	}
5106	<	resultobj = result;
5107	<	return resultobj;
5108	<	fail:
19076	<	return NULL;
5105	>	resultobj = PyInt_FromLong((long)result);
5106	>	return resultobj;
5107	>	fail:
5108	>	return NULL;
5109		}
5110
5111
5112	<	SWIGINTERN PyObject *_wrap_BossTask_jobsDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5113	<	PyObject *resultobj = 0;
5114	<	BossTask *arg1 = (BossTask *) 0 ;
5115	<	PyObject *result = 0 ;
5116	<	void *argp1 = 0 ;
5117	<	int res1 = 0 ;
5118	<	PyObject * obj0 = 0 ;
5119	<
5120	<	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) SWIG_fail;
5121	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
5122	<	if (!SWIG_IsOK(res1)) {
5123	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_jobsDict" "', argument " "1"" of type '" "BossTask const *""'");
5124	<	}
5125	<	arg1 = reinterpret_cast< BossTask * >(argp1);
5126	<	{
5127	<	try {
5128	<	result = (PyObject *)BossTask_jobsDict((BossTask const *)arg1);
5129	<	} catch (const std::exception& e) {
5130	<	SWIG_exception(SWIG_RuntimeError, e.what());
5112	>	static PyObject *_wrap_BossTask_query_out(PyObject *self, PyObject *args) {
5113	>	PyObject *resultobj;
5114	>	BossTask *arg1 = (BossTask *) 0 ;
5115	>	std::ostream &arg2_defvalue = std::cout ;
5116	>	std::ostream *arg2 = (std::ostream *) &arg2_defvalue ;
5117	>	jobStates const &arg3_defvalue = SCHEDULED ;
5118	>	jobStates *arg3 = (jobStates *) &arg3_defvalue ;
5119	>	printOption const &arg4_defvalue = NORMAL ;
5120	>	printOption *arg4 = (printOption *) &arg4_defvalue ;
5121	>	std::string arg5 = (std::string) "" ;
5122	>	PyObject * obj0 = 0 ;
5123	>	PyObject * obj1 = 0 ;
5124	>	PyObject * obj2 = 0 ;
5125	>	PyObject * obj3 = 0 ;
5126	>	PyObject * obj4 = 0 ;
5127	>
5128	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_query_out",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5129	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5130	>	if (obj1) {
5131	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5132	>	if (arg2 == NULL) {
5133	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5134	>	}
5135		}
5136	<	}
5137	<	resultobj = result;
5138	<	return resultobj;
5139	<	fail:
5140	<	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());
5136	>	if (obj2) {
5137	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5138	>	if (arg3 == NULL) {
5139	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5140	>	}
5141		}
5142	<	}
5143	<	resultobj = result;
5144	<	return resultobj;
5145	<	fail:
5146	<	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 &""'");
5142	>	if (obj3) {
5143	>	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5144	>	if (arg4 == NULL) {
5145	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5146	>	}
5147		}
5148	<	if (!ptr) {
5149	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_jobPrograms" "', argument " "2"" of type '" "std::string const &""'");
5148	>	if (obj4) {
5149	>	{
5150	>	if (PyString_Check(obj4))
5151	>	arg5 = std::string(PyString_AsString(obj4));
5152	>	else
5153	>	SWIG_exception(SWIG_TypeError, "string expected");
5154	>	}
5155		}
5156	<	arg2 = ptr;
5157	<	}
5158	<	{
5159	<	try {
5160	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5161	<	} catch (const std::exception& e) {
5162	<	SWIG_exception(SWIG_RuntimeError, e.what());
5156	>	{
5157	>	try {
5158	>	((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
5159	>
5160	>	}catch (const BossSchedFailure & e) {
5161	>	PyErr_SetString ( SchedulerError, e.what() );
5162	>	return NULL;
5163	>	}catch (const std::exception& e) {
5164	>	PyErr_SetString ( BossError, e.what() );
5165	>	return NULL;
5166	>	}
5167		}
5168	<	}
5169	<	resultobj = result;
5170	<	if (SWIG_IsNewObj(res2)) delete arg2;
5171	<	return resultobj;
19186	<	fail:
19187	<	if (SWIG_IsNewObj(res2)) delete arg2;
19188	<	return NULL;
5168	>	Py_INCREF(Py_None); resultobj = Py_None;
5169	>	return resultobj;
5170	>	fail:
5171	>	return NULL;
5172		}
5173
5174
5175	<	SWIGINTERN PyObject *BossTask_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5176	<	PyObject *obj;
5177	<	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
5178	<	SWIG_TypeNewClientData(SWIGTYPE_p_BossTask, SWIG_NewClientData(obj));
5179	<	return SWIG_Py_Void();
5180	<	}
5181	<
5182	<	SWIGINTERN PyObject *_wrap_prompt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183	<	PyObject *resultobj = 0;
5184	<	std::string *arg1 = 0 ;
5185	<	bool result;
5186	<	int res1 = SWIG_OLDOBJ ;
5187	<	PyObject * obj0 = 0 ;
5188	<
5189	<	if (!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) SWIG_fail;
5190	<	{
5191	<	std::string *ptr = (std::string *)0;
5192	<	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());
5175	>	static PyObject *_wrap_BossTask_clear(PyObject *self, PyObject *args) {
5176	>	PyObject *resultobj;
5177	>	BossTask *arg1 = (BossTask *) 0 ;
5178	>	PyObject * obj0 = 0 ;
5179	>
5180	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_clear",&obj0)) goto fail;
5181	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5182	>	{
5183	>	try {
5184	>	(arg1)->clear();
5185	>
5186	>	}catch (const BossSchedFailure & e) {
5187	>	PyErr_SetString ( SchedulerError, e.what() );
5188	>	return NULL;
5189	>	}catch (const std::exception& e) {
5190	>	PyErr_SetString ( BossError, e.what() );
5191	>	return NULL;
5192	>	}
5193		}
5194	<	}
5195	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
5196	<	if (SWIG_IsNewObj(res1)) delete arg1;
5197	<	return resultobj;
19228	<	fail:
19229	<	if (SWIG_IsNewObj(res1)) delete arg1;
19230	<	return NULL;
5194	>	Py_INCREF(Py_None); resultobj = Py_None;
5195	>	return resultobj;
5196	>	fail:
5197	>	return NULL;
5198		}
5199
5200
5201	<	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202	<	PyObject *resultobj = 0;
5203	<	std::string arg1 ;
5204	<	bool arg2 ;
5205	<	BossAdministratorSession *result = 0 ;
5206	<	bool val2 ;
5207	<	int ecode2 = 0 ;
5208	<	PyObject * obj0 = 0 ;
5209	<	PyObject * obj1 = 0 ;
5210	<
5211	<	if (!PyArg_ParseTuple(args,(char *)"OO:new_BossAdministratorSession",&obj0,&obj1)) SWIG_fail;
5212	<	{
5213	<	std::string *ptr = (std::string *)0;
5214	<	int res = SWIG_AsPtr_std_string(obj0, &ptr);
5215	<	if (!SWIG_IsOK(res) || !ptr) {
5216	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BossAdministratorSession" "', argument " "1"" of type '" "std::string""'");
5201	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
5202	>	PyObject *resultobj;
5203	>	BossTask *arg1 = (BossTask *) 0 ;
5204	>	PyObject *arg2 = (PyObject *) 0 ;
5205	>	BossAttributeContainer *arg3 = 0 ;
5206	>	PyObject *result;
5207	>	PyObject * obj0 = 0 ;
5208	>	PyObject * obj1 = 0 ;
5209	>	PyObject * obj2 = 0 ;
5210	>
5211	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
5212	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5213	>	arg2 = obj1;
5214	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5215	>	if (arg3 == NULL) {
5216	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5217		}
5218	<	arg1 = *ptr;
5219	<	if (SWIG_IsNewObj(res)) delete ptr;
5220	<	}
5221	<	ecode2 = SWIG_AsVal_bool(obj1, &val2);
5222	<	if (!SWIG_IsOK(ecode2)) {
5223	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BossAdministratorSession" "', argument " "2"" of type '" "bool""'");
5224	<	}
5225	<	arg2 = static_cast< bool >(val2);
5226	<	{
5227	<	try {
5228	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
19262	<	} catch (const std::exception& e) {
19263	<	SWIG_exception(SWIG_RuntimeError, e.what());
5218	>	{
5219	>	try {
5220	>	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
5221	>
5222	>	}catch (const BossSchedFailure & e) {
5223	>	PyErr_SetString ( SchedulerError, e.what() );
5224	>	return NULL;
5225	>	}catch (const std::exception& e) {
5226	>	PyErr_SetString ( BossError, e.what() );
5227	>	return NULL;
5228	>	}
5229		}
5230	<	}
5231	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_NEW |  0 );
5232	<	return resultobj;
5233	<	fail:
19269	<	return NULL;
5230	>	resultobj = result;
5231	>	return resultobj;
5232	>	fail:
5233	>	return NULL;
5234		}
5235
5236
5237	<	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5238	<	PyObject *resultobj = 0;
5239	<	std::string arg1 ;
5240	<	BossAdministratorSession *result = 0 ;
5241	<	PyObject * obj0 = 0 ;
5242	<
5243	<	if (!PyArg_ParseTuple(args,(char *)"O:new_BossAdministratorSession",&obj0)) SWIG_fail;
5244	<	{
5245	<	std::string *ptr = (std::string *)0;
5246	<	int res = SWIG_AsPtr_std_string(obj0, &ptr);
5247	<	if (!SWIG_IsOK(res) || !ptr) {
5248	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BossAdministratorSession" "', argument " "1"" of type '" "std::string""'");
5249	<	}
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());
5237	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
5238	>	PyObject *resultobj;
5239	>	BossTask *arg1 = (BossTask *) 0 ;
5240	>	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
5241	>	PyObject *result;
5242	>	PyObject * obj0 = 0 ;
5243	>	PyObject * obj1 = 0 ;
5244	>
5245	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
5246	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5247	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5248	>	if (arg2 == NULL) {
5249	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5250		}
5251	<	}
5252	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_NEW |  0 );
5253	<	return resultobj;
5254	<	fail:
5255	<	return NULL;
5256	<	}
5257	<
5258	<
5259	<	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5260	<	PyObject *resultobj = 0;
5261	<	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());
5251	>	{
5252	>	try {
5253	>	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
5254	>
5255	>	}catch (const BossSchedFailure & e) {
5256	>	PyErr_SetString ( SchedulerError, e.what() );
5257	>	return NULL;
5258	>	}catch (const std::exception& e) {
5259	>	PyErr_SetString ( BossError, e.what() );
5260	>	return NULL;
5261	>	}
5262		}
5263	<	}
5264	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_NEW |  0 );
5265	<	return resultobj;
5266	<	fail:
19318	<	return NULL;
5263	>	resultobj = result;
5264	>	return resultobj;
5265	>	fail:
5266	>	return NULL;
5267		}
5268
5269
5270	<	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5271	<	int argc;
5272	<	PyObject *argv[3];
5273	<	int ii;
5274	<
5275	<	if (!PyTuple_Check(args)) SWIG_fail;
5276	<	argc = PyObject_Length(args);
5277	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5278	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5279	<	}
5280	<	if (argc == 0) {
5281	<	return _wrap_new_BossAdministratorSession__SWIG_2(self, args);
5282	<	}
5283	<	if (argc == 1) {
5284	<	int _v;
5285	<	int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
5286	<	_v = SWIG_CheckState(res);
5287	<	if (_v) {
5288	<	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	<	}
5270	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
5271	>	PyObject *resultobj;
5272	>	BossTask *arg1 = (BossTask *) 0 ;
5273	>	PyObject *result;
5274	>	PyObject * obj0 = 0 ;
5275	>
5276	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
5277	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5278	>	{
5279	>	try {
5280	>	result = (PyObject *)BossTask_jobsDict(arg1);
5281	>
5282	>	}catch (const BossSchedFailure & e) {
5283	>	PyErr_SetString ( SchedulerError, e.what() );
5284	>	return NULL;
5285	>	}catch (const std::exception& e) {
5286	>	PyErr_SetString ( BossError, e.what() );
5287	>	return NULL;
5288	>	}
5289		}
5290	<	}
5291	<
5292	<	fail:
5293	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BossAdministratorSession'");
19360	<	return NULL;
5290	>	resultobj = result;
5291	>	return resultobj;
5292	>	fail:
5293	>	return NULL;
5294		}
5295
5296
5297	<	SWIGINTERN PyObject *_wrap_delete_BossAdministratorSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5298	<	PyObject *resultobj = 0;
5299	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5300	<	void *argp1 = 0 ;
5301	<	int res1 = 0 ;
5302	<	PyObject * obj0 = 0 ;
5303	<
5304	<	if (!PyArg_ParseTuple(args,(char *)"O:delete_BossAdministratorSession",&obj0)) SWIG_fail;
5305	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_DISOWN |  0 );
5306	<	if (!SWIG_IsOK(res1)) {
5307	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BossAdministratorSession" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5308	<	}
5309	<	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());
5297	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
5298	>	PyObject *resultobj;
5299	>	BossTask *arg1 = (BossTask *) 0 ;
5300	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
5301	>	PyObject *result;
5302	>	PyObject * obj0 = 0 ;
5303	>	PyObject * obj1 = 0 ;
5304	>
5305	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
5306	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5307	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5308	>	if (arg2 == NULL) {
5309	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
5310		}
5311	<	}
5312	<	resultobj = SWIG_Py_Void();
5313	<	return resultobj;
5314	<	fail:
5315	<	return NULL;
5316	<	}
5317	<
5318	<
5319	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5320	<	PyObject *resultobj = 0;
5321	<	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());
5311	>	{
5312	>	try {
5313	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
5314	>
5315	>	}catch (const BossSchedFailure & e) {
5316	>	PyErr_SetString ( SchedulerError, e.what() );
5317	>	return NULL;
5318	>	}catch (const std::exception& e) {
5319	>	PyErr_SetString ( BossError, e.what() );
5320	>	return NULL;
5321	>	}
5322		}
5323	<	}
5324	<	resultobj = SWIG_From_int(static_cast< int >(result));
5325	<	return resultobj;
5326	<	fail:
19416	<	return NULL;
5323	>	resultobj = result;
5324	>	return resultobj;
5325	>	fail:
5326	>	return NULL;
5327		}
5328
5329
5330	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5331	<	PyObject *resultobj = 0;
5332	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5333	<	std::string *arg2 = 0 ;
5334	<	int result;
5335	<	void *argp1 = 0 ;
5336	<	int res1 = 0 ;
5337	<	int res2 = SWIG_OLDOBJ ;
5338	<	PyObject * obj0 = 0 ;
5339	<	PyObject * obj1 = 0 ;
5340	<
5341	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureRTMonDB",&obj0,&obj1)) SWIG_fail;
5342	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5343	<	if (!SWIG_IsOK(res1)) {
5344	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_configureRTMonDB" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5345	<	}
5346	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5347	<	{
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 &""'");
5330	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
5331	>	PyObject *resultobj;
5332	>	BossTask *arg1 = (BossTask *) 0 ;
5333	>	std::string *arg2 = 0 ;
5334	>	PyObject *result;
5335	>	std::string temp2 ;
5336	>	PyObject * obj0 = 0 ;
5337	>	PyObject * obj1 = 0 ;
5338	>
5339	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
5340	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5341	>	{
5342	>	if (PyString_Check(obj1)) {
5343	>	temp2 = std::string(PyString_AsString(obj1));
5344	>	arg2 = &temp2;
5345	>	}else {
5346	>	SWIG_exception(SWIG_TypeError, "string expected");
5347	>	}
5348		}
5349	<	arg2 = ptr;
5350	<	}
5351	<	{
5352	<	try {
5353	<	result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5354	<	} catch (const std::exception& e) {
5355	<	SWIG_exception(SWIG_RuntimeError, e.what());
5349	>	{
5350	>	try {
5351	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
5352	>
5353	>	}catch (const BossSchedFailure & e) {
5354	>	PyErr_SetString ( SchedulerError, e.what() );
5355	>	return NULL;
5356	>	}catch (const std::exception& e) {
5357	>	PyErr_SetString ( BossError, e.what() );
5358	>	return NULL;
5359	>	}
5360		}
5361	<	}
5362	<	resultobj = SWIG_From_int(static_cast< int >(result));
5363	<	if (SWIG_IsNewObj(res2)) delete arg2;
5364	<	return resultobj;
19458	<	fail:
19459	<	if (SWIG_IsNewObj(res2)) delete arg2;
19460	<	return NULL;
5361	>	resultobj = result;
5362	>	return resultobj;
5363	>	fail:
5364	>	return NULL;
5365		}
5366
5367
5368	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_deleteCHTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5369	<	PyObject *resultobj = 0;
5370	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5371	<	std::string *arg2 = 0 ;
5372	<	int result;
5373	<	void *argp1 = 0 ;
5374	<	int res1 = 0 ;
5375	<	int res2 = SWIG_OLDOBJ ;
5376	<	PyObject * obj0 = 0 ;
5377	<	PyObject * obj1 = 0 ;
5378	<
5379	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteCHTool",&obj0,&obj1)) SWIG_fail;
5380	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5381	<	if (!SWIG_IsOK(res1)) {
5382	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_deleteCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5383	<	}
5384	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5385	<	{
5386	<	std::string *ptr = (std::string *)0;
5387	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5388	<	if (!SWIG_IsOK(res2)) {
5389	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_deleteCHTool" "', argument " "2"" of type '" "std::string const &""'");
5368	>	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
5369	>	PyObject *obj;
5370	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5371	>	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
5372	>	Py_INCREF(obj);
5373	>	return Py_BuildValue((char *)"");
5374	>	}
5375	>	static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
5376	>	PyObject *resultobj;
5377	>	std::string arg1 = (std::string) "" ;
5378	>	std::string arg2 = (std::string) "2" ;
5379	>	std::string arg3 = (std::string) "" ;
5380	>	std::string arg4 = (std::string) "" ;
5381	>	bool arg5 = (bool) false ;
5382	>	BossAdministratorSession *result;
5383	>	PyObject * obj0 = 0 ;
5384	>	PyObject * obj1 = 0 ;
5385	>	PyObject * obj2 = 0 ;
5386	>	PyObject * obj3 = 0 ;
5387	>	PyObject * obj4 = 0 ;
5388	>
5389	>	if(!PyArg_ParseTuple(args,(char *)"|OOOOO:new_BossAdministratorSession",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5390	>	if (obj0) {
5391	>	{
5392	>	if (PyString_Check(obj0))
5393	>	arg1 = std::string(PyString_AsString(obj0));
5394	>	else
5395	>	SWIG_exception(SWIG_TypeError, "string expected");
5396	>	}
5397		}
5398	<	if (!ptr) {
5399	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteCHTool" "', argument " "2"" of type '" "std::string const &""'");
5398	>	if (obj1) {
5399	>	{
5400	>	if (PyString_Check(obj1))
5401	>	arg2 = std::string(PyString_AsString(obj1));
5402	>	else
5403	>	SWIG_exception(SWIG_TypeError, "string expected");
5404	>	}
5405		}
5406	<	arg2 = ptr;
5407	<	}
5408	<	{
5409	<	try {
5410	<	result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5411	<	} catch (const std::exception& e) {
5412	<	SWIG_exception(SWIG_RuntimeError, e.what());
5406	>	if (obj2) {
5407	>	{
5408	>	if (PyString_Check(obj2))
5409	>	arg3 = std::string(PyString_AsString(obj2));
5410	>	else
5411	>	SWIG_exception(SWIG_TypeError, "string expected");
5412	>	}
5413		}
5414	<	}
5415	<	resultobj = SWIG_From_int(static_cast< int >(result));
5416	<	if (SWIG_IsNewObj(res2)) delete arg2;
5417	<	return resultobj;
5418	<	fail:
5419	<	if (SWIG_IsNewObj(res2)) delete arg2;
5420	<	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 &""'");
5414	>	if (obj3) {
5415	>	{
5416	>	if (PyString_Check(obj3))
5417	>	arg4 = std::string(PyString_AsString(obj3));
5418	>	else
5419	>	SWIG_exception(SWIG_TypeError, "string expected");
5420	>	}
5421		}
5422	<	if (!ptr) {
5423	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteProgramType" "', argument " "2"" of type '" "std::string const &""'");
5422	>	if (obj4) {
5423	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5424	>	if (PyErr_Occurred()) SWIG_fail;
5425		}
5426	<	arg2 = ptr;
5427	<	}
5428	<	{
5429	<	try {
5430	<	result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5431	<	} catch (const std::exception& e) {
5432	<	SWIG_exception(SWIG_RuntimeError, e.what());
5426	>	{
5427	>	try {
5428	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2,arg3,arg4,arg5);
5429	>
5430	>	}catch (const BossSchedFailure & e) {
5431	>	PyErr_SetString ( SchedulerError, e.what() );
5432	>	return NULL;
5433	>	}catch (const std::exception& e) {
5434	>	PyErr_SetString ( BossError, e.what() );
5435	>	return NULL;
5436	>	}
5437		}
5438	<	}
5439	<	resultobj = SWIG_From_int(static_cast< int >(result));
5440	<	if (SWIG_IsNewObj(res2)) delete arg2;
5441	<	return resultobj;
19546	<	fail:
19547	<	if (SWIG_IsNewObj(res2)) delete arg2;
19548	<	return NULL;
5438	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
5439	>	return resultobj;
5440	>	fail:
5441	>	return NULL;
5442		}
5443
5444
5445	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_deleteRTMon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5446	<	PyObject *resultobj = 0;
5447	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5448	<	std::string *arg2 = 0 ;
5449	<	int result;
5450	<	void *argp1 = 0 ;
5451	<	int res1 = 0 ;
5452	<	int res2 = SWIG_OLDOBJ ;
5453	<	PyObject * obj0 = 0 ;
5454	<	PyObject * obj1 = 0 ;
5455	<
5456	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteRTMon",&obj0,&obj1)) SWIG_fail;
5457	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5458	<	if (!SWIG_IsOK(res1)) {
5459	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_deleteRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5460	<	}
5461	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5462	<	{
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());
5445	>	static PyObject *_wrap_delete_BossAdministratorSession(PyObject *self, PyObject *args) {
5446	>	PyObject *resultobj;
5447	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5448	>	PyObject * obj0 = 0 ;
5449	>
5450	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossAdministratorSession",&obj0)) goto fail;
5451	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5452	>	{
5453	>	try {
5454	>	delete arg1;
5455	>
5456	>	}catch (const BossSchedFailure & e) {
5457	>	PyErr_SetString ( SchedulerError, e.what() );
5458	>	return NULL;
5459	>	}catch (const std::exception& e) {
5460	>	PyErr_SetString ( BossError, e.what() );
5461	>	return NULL;
5462	>	}
5463		}
5464	<	}
5465	<	resultobj = SWIG_From_int(static_cast< int >(result));
5466	<	if (SWIG_IsNewObj(res2)) delete arg2;
5467	<	return resultobj;
19590	<	fail:
19591	<	if (SWIG_IsNewObj(res2)) delete arg2;
19592	<	return NULL;
5464	>	Py_INCREF(Py_None); resultobj = Py_None;
5465	>	return resultobj;
5466	>	fail:
5467	>	return NULL;
5468		}
5469
5470
5471	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_deleteScheduler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5472	<	PyObject *resultobj = 0;
5473	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5474	<	std::string *arg2 = 0 ;
5475	<	int result;
5476	<	void *argp1 = 0 ;
5477	<	int res1 = 0 ;
5478	<	int res2 = SWIG_OLDOBJ ;
5479	<	PyObject * obj0 = 0 ;
5480	<	PyObject * obj1 = 0 ;
5481	<
5482	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteScheduler",&obj0,&obj1)) SWIG_fail;
5483	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5484	<	if (!SWIG_IsOK(res1)) {
5485	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_deleteScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5486	<	}
5487	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5488	<	{
5489	<	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());
5471	>	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
5472	>	PyObject *resultobj;
5473	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5474	>	int result;
5475	>	PyObject * obj0 = 0 ;
5476	>
5477	>	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
5478	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5479	>	{
5480	>	try {
5481	>	result = (int)(arg1)->configureDB();
5482	>
5483	>	}catch (const BossSchedFailure & e) {
5484	>	PyErr_SetString ( SchedulerError, e.what() );
5485	>	return NULL;
5486	>	}catch (const std::exception& e) {
5487	>	PyErr_SetString ( BossError, e.what() );
5488	>	return NULL;
5489	>	}
5490		}
5491	<	}
5492	<	resultobj = SWIG_From_int(static_cast< int >(result));
5493	<	if (SWIG_IsNewObj(res2)) delete arg2;
5494	<	return resultobj;
19634	<	fail:
19635	<	if (SWIG_IsNewObj(res2)) delete arg2;
19636	<	return NULL;
5491	>	resultobj = PyInt_FromLong((long)result);
5492	>	return resultobj;
5493	>	fail:
5494	>	return NULL;
5495		}
5496
5497
5498	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5499	<	PyObject *resultobj = 0;
5500	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5501	<	std::string *arg2 = 0 ;
5502	<	std::string arg3 ;
5503	<	std::string arg4 ;
5504	<	bool arg5 ;
5505	<	bool arg6 ;
5506	<	int result;
5507	<	void *argp1 = 0 ;
5508	<	int res1 = 0 ;
5509	<	int res2 = SWIG_OLDOBJ ;
5510	<	bool val5 ;
5511	<	int ecode5 = 0 ;
5512	<	bool val6 ;
5513	<	int ecode6 = 0 ;
5514	<	PyObject * obj0 = 0 ;
5515	<	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""'");
5498	>	static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
5499	>	PyObject *resultobj;
5500	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5501	>	std::string *arg2 = 0 ;
5502	>	int result;
5503	>	std::string temp2 ;
5504	>	PyObject * obj0 = 0 ;
5505	>	PyObject * obj1 = 0 ;
5506	>
5507	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureRTMonDB",&obj0,&obj1)) goto fail;
5508	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5509	>	{
5510	>	if (PyString_Check(obj1)) {
5511	>	temp2 = std::string(PyString_AsString(obj1));
5512	>	arg2 = &temp2;
5513	>	}else {
5514	>	SWIG_exception(SWIG_TypeError, "string expected");
5515	>	}
5516		}
5517	<	arg4 = *ptr;
5518	<	if (SWIG_IsNewObj(res)) delete ptr;
5519	<	}
5520	<	ecode5 = SWIG_AsVal_bool(obj4, &val5);
5521	<	if (!SWIG_IsOK(ecode5)) {
5522	<	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "5"" of type '" "bool""'");
5523	<	}
5524	<	arg5 = static_cast< bool >(val5);
5525	<	ecode6 = SWIG_AsVal_bool(obj5, &val6);
5526	<	if (!SWIG_IsOK(ecode6)) {
5527	<	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());
5517	>	{
5518	>	try {
5519	>	result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
5520	>
5521	>	}catch (const BossSchedFailure & e) {
5522	>	PyErr_SetString ( SchedulerError, e.what() );
5523	>	return NULL;
5524	>	}catch (const std::exception& e) {
5525	>	PyErr_SetString ( BossError, e.what() );
5526	>	return NULL;
5527	>	}
5528		}
5529	<	}
5530	<	resultobj = SWIG_From_int(static_cast< int >(result));
5531	<	if (SWIG_IsNewObj(res2)) delete arg2;
5532	<	return resultobj;
19718	<	fail:
19719	<	if (SWIG_IsNewObj(res2)) delete arg2;
19720	<	return NULL;
5529	>	resultobj = PyInt_FromLong((long)result);
5530	>	return resultobj;
5531	>	fail:
5532	>	return NULL;
5533		}
5534
5535
5536	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5537	<	PyObject *resultobj = 0;
5538	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5539	<	std::string *arg2 = 0 ;
5540	<	std::string arg3 ;
5541	<	std::string arg4 ;
5542	<	bool arg5 ;
5543	<	int result;
5544	<	void *argp1 = 0 ;
5545	<	int res1 = 0 ;
5546	<	int res2 = SWIG_OLDOBJ ;
5547	<	bool val5 ;
5548	<	int ecode5 = 0 ;
5549	<	PyObject * obj0 = 0 ;
5550	<	PyObject * obj1 = 0 ;
5551	<	PyObject * obj2 = 0 ;
5552	<	PyObject * obj3 = 0 ;
5553	<	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""'");
5536	>	static PyObject *_wrap_BossAdministratorSession_deleteCHTool(PyObject *self, PyObject *args) {
5537	>	PyObject *resultobj;
5538	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5539	>	std::string *arg2 = 0 ;
5540	>	int result;
5541	>	std::string temp2 ;
5542	>	PyObject * obj0 = 0 ;
5543	>	PyObject * obj1 = 0 ;
5544	>
5545	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteCHTool",&obj0,&obj1)) goto fail;
5546	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5547	>	{
5548	>	if (PyString_Check(obj1)) {
5549	>	temp2 = std::string(PyString_AsString(obj1));
5550	>	arg2 = &temp2;
5551	>	}else {
5552	>	SWIG_exception(SWIG_TypeError, "string expected");
5553	>	}
5554		}
5555	<	arg4 = *ptr;
5556	<	if (SWIG_IsNewObj(res)) delete ptr;
5557	<	}
5558	<	ecode5 = SWIG_AsVal_bool(obj4, &val5);
5559	<	if (!SWIG_IsOK(ecode5)) {
5560	<	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "5"" of type '" "bool""'");
5561	<	}
5562	<	arg5 = static_cast< bool >(val5);
5563	<	{
5564	<	try {
5565	<	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5);
19786	<	} catch (const std::exception& e) {
19787	<	SWIG_exception(SWIG_RuntimeError, e.what());
5555	>	{
5556	>	try {
5557	>	result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
5558	>
5559	>	}catch (const BossSchedFailure & e) {
5560	>	PyErr_SetString ( SchedulerError, e.what() );
5561	>	return NULL;
5562	>	}catch (const std::exception& e) {
5563	>	PyErr_SetString ( BossError, e.what() );
5564	>	return NULL;
5565	>	}
5566		}
5567	<	}
5568	<	resultobj = SWIG_From_int(static_cast< int >(result));
5569	<	if (SWIG_IsNewObj(res2)) delete arg2;
5570	<	return resultobj;
19793	<	fail:
19794	<	if (SWIG_IsNewObj(res2)) delete arg2;
19795	<	return NULL;
5567	>	resultobj = PyInt_FromLong((long)result);
5568	>	return resultobj;
5569	>	fail:
5570	>	return NULL;
5571		}
5572
5573
5574	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575	<	PyObject *resultobj = 0;
5576	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5577	<	std::string *arg2 = 0 ;
5578	<	std::string arg3 ;
5579	<	std::string arg4 ;
5580	<	int result;
5581	<	void *argp1 = 0 ;
5582	<	int res1 = 0 ;
5583	<	int res2 = SWIG_OLDOBJ ;
5584	<	PyObject * obj0 = 0 ;
5585	<	PyObject * obj1 = 0 ;
5586	<	PyObject * obj2 = 0 ;
5587	<	PyObject * obj3 = 0 ;
5588	<
5589	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5590	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5591	<	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""'");
5574	>	static PyObject *_wrap_BossAdministratorSession_deleteProgramType(PyObject *self, PyObject *args) {
5575	>	PyObject *resultobj;
5576	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5577	>	std::string *arg2 = 0 ;
5578	>	int result;
5579	>	std::string temp2 ;
5580	>	PyObject * obj0 = 0 ;
5581	>	PyObject * obj1 = 0 ;
5582	>
5583	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteProgramType",&obj0,&obj1)) goto fail;
5584	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5585	>	{
5586	>	if (PyString_Check(obj1)) {
5587	>	temp2 = std::string(PyString_AsString(obj1));
5588	>	arg2 = &temp2;
5589	>	}else {
5590	>	SWIG_exception(SWIG_TypeError, "string expected");
5591	>	}
5592		}
5593	<	arg4 = *ptr;
5594	<	if (SWIG_IsNewObj(res)) delete ptr;
5595	<	}
5596	<	{
5597	<	try {
5598	<	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4);
5599	<	} catch (const std::exception& e) {
5600	<	SWIG_exception(SWIG_RuntimeError, e.what());
5593	>	{
5594	>	try {
5595	>	result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
5596	>
5597	>	}catch (const BossSchedFailure & e) {
5598	>	PyErr_SetString ( SchedulerError, e.what() );
5599	>	return NULL;
5600	>	}catch (const std::exception& e) {
5601	>	PyErr_SetString ( BossError, e.what() );
5602	>	return NULL;
5603	>	}
5604		}
5605	<	}
5606	<	resultobj = SWIG_From_int(static_cast< int >(result));
5607	<	if (SWIG_IsNewObj(res2)) delete arg2;
5608	<	return resultobj;
19859	<	fail:
19860	<	if (SWIG_IsNewObj(res2)) delete arg2;
19861	<	return NULL;
5605	>	resultobj = PyInt_FromLong((long)result);
5606	>	return resultobj;
5607	>	fail:
5608	>	return NULL;
5609		}
5610
5611
5612	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5613	<	PyObject *resultobj = 0;
5614	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5615	<	std::string *arg2 = 0 ;
5616	<	std::string arg3 ;
5617	<	int result;
5618	<	void *argp1 = 0 ;
5619	<	int res1 = 0 ;
5620	<	int res2 = SWIG_OLDOBJ ;
5621	<	PyObject * obj0 = 0 ;
5622	<	PyObject * obj1 = 0 ;
5623	<	PyObject * obj2 = 0 ;
5624	<
5625	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2)) SWIG_fail;
5626	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5627	<	if (!SWIG_IsOK(res1)) {
5628	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5629	<	}
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""'");
5612	>	static PyObject *_wrap_BossAdministratorSession_deleteRTMon(PyObject *self, PyObject *args) {
5613	>	PyObject *resultobj;
5614	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5615	>	std::string *arg2 = 0 ;
5616	>	int result;
5617	>	std::string temp2 ;
5618	>	PyObject * obj0 = 0 ;
5619	>	PyObject * obj1 = 0 ;
5620	>
5621	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteRTMon",&obj0,&obj1)) goto fail;
5622	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5623	>	{
5624	>	if (PyString_Check(obj1)) {
5625	>	temp2 = std::string(PyString_AsString(obj1));
5626	>	arg2 = &temp2;
5627	>	}else {
5628	>	SWIG_exception(SWIG_TypeError, "string expected");
5629	>	}
5630		}
5631	<	arg3 = *ptr;
5632	<	if (SWIG_IsNewObj(res)) delete ptr;
5633	<	}
5634	<	{
5635	<	try {
5636	<	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3);
5637	<	} catch (const std::exception& e) {
5638	<	SWIG_exception(SWIG_RuntimeError, e.what());
5631	>	{
5632	>	try {
5633	>	result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5634	>
5635	>	}catch (const BossSchedFailure & e) {
5636	>	PyErr_SetString ( SchedulerError, e.what() );
5637	>	return NULL;
5638	>	}catch (const std::exception& e) {
5639	>	PyErr_SetString ( BossError, e.what() );
5640	>	return NULL;
5641	>	}
5642		}
5643	<	}
5644	<	resultobj = SWIG_From_int(static_cast< int >(result));
5645	<	if (SWIG_IsNewObj(res2)) delete arg2;
5646	<	return resultobj;
19914	<	fail:
19915	<	if (SWIG_IsNewObj(res2)) delete arg2;
19916	<	return NULL;
5643	>	resultobj = PyInt_FromLong((long)result);
5644	>	return resultobj;
5645	>	fail:
5646	>	return NULL;
5647		}
5648
5649
5650	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5651	<	PyObject *resultobj = 0;
5652	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5653	<	std::string *arg2 = 0 ;
5654	<	int result;
5655	<	void *argp1 = 0 ;
5656	<	int res1 = 0 ;
5657	<	int res2 = SWIG_OLDOBJ ;
5658	<	PyObject * obj0 = 0 ;
5659	<	PyObject * obj1 = 0 ;
5660	<
5661	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerCHTool",&obj0,&obj1)) SWIG_fail;
5662	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5663	<	if (!SWIG_IsOK(res1)) {
5664	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5665	<	}
5666	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5667	<	{
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 &""'");
5650	>	static PyObject *_wrap_BossAdministratorSession_deleteScheduler(PyObject *self, PyObject *args) {
5651	>	PyObject *resultobj;
5652	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5653	>	std::string *arg2 = 0 ;
5654	>	int result;
5655	>	std::string temp2 ;
5656	>	PyObject * obj0 = 0 ;
5657	>	PyObject * obj1 = 0 ;
5658	>
5659	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteScheduler",&obj0,&obj1)) goto fail;
5660	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5661	>	{
5662	>	if (PyString_Check(obj1)) {
5663	>	temp2 = std::string(PyString_AsString(obj1));
5664	>	arg2 = &temp2;
5665	>	}else {
5666	>	SWIG_exception(SWIG_TypeError, "string expected");
5667	>	}
5668		}
5669	<	arg2 = ptr;
5670	<	}
5671	<	{
5672	<	try {
5673	<	result = (int)(arg1)->registerCHTool((std::string const &)*arg2);
5674	<	} catch (const std::exception& e) {
5675	<	SWIG_exception(SWIG_RuntimeError, e.what());
5669	>	{
5670	>	try {
5671	>	result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5672	>
5673	>	}catch (const BossSchedFailure & e) {
5674	>	PyErr_SetString ( SchedulerError, e.what() );
5675	>	return NULL;
5676	>	}catch (const std::exception& e) {
5677	>	PyErr_SetString ( BossError, e.what() );
5678	>	return NULL;
5679	>	}
5680		}
5681	<	}
5682	<	resultobj = SWIG_From_int(static_cast< int >(result));
5683	<	if (SWIG_IsNewObj(res2)) delete arg2;
5684	<	return resultobj;
19958	<	fail:
19959	<	if (SWIG_IsNewObj(res2)) delete arg2;
19960	<	return NULL;
5681	>	resultobj = PyInt_FromLong((long)result);
5682	>	return resultobj;
5683	>	fail:
5684	>	return NULL;
5685		}
5686
5687
5688	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool(PyObject *self, PyObject *args) {
5689	<	int argc;
5690	<	PyObject *argv[7];
5691	<	int ii;
5692	<
5693	<	if (!PyTuple_Check(args)) SWIG_fail;
5694	<	argc = PyObject_Length(args);
5695	<	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
5696	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5697	<	}
5698	<	if (argc == 2) {
5699	<	int _v;
5700	<	void *vptr = 0;
5701	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5702	<	_v = SWIG_CheckState(res);
5703	<	if (_v) {
5704	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5705	<	_v = SWIG_CheckState(res);
5706	<	if (_v) {
5707	<	return _wrap_BossAdministratorSession_registerCHTool__SWIG_4(self, args);
5708	<	}
5709	<	}
5710	<	}
5711	<	if (argc == 3) {
5712	<	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	<	}
5688	>	static PyObject *_wrap_BossAdministratorSession_registerCHTool(PyObject *self, PyObject *args) {
5689	>	PyObject *resultobj;
5690	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5691	>	std::string *arg2 = 0 ;
5692	>	std::string arg3 = (std::string) "NULL" ;
5693	>	std::string arg4 = (std::string) "NULL" ;
5694	>	bool arg5 = (bool) false ;
5695	>	bool arg6 = (bool) false ;
5696	>	int result;
5697	>	std::string temp2 ;
5698	>	PyObject * obj0 = 0 ;
5699	>	PyObject * obj1 = 0 ;
5700	>	PyObject * obj2 = 0 ;
5701	>	PyObject * obj3 = 0 ;
5702	>	PyObject * obj4 = 0 ;
5703	>	PyObject * obj5 = 0 ;
5704	>
5705	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5706	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5707	>	{
5708	>	if (PyString_Check(obj1)) {
5709	>	temp2 = std::string(PyString_AsString(obj1));
5710	>	arg2 = &temp2;
5711	>	}else {
5712	>	SWIG_exception(SWIG_TypeError, "string expected");
5713		}
20022	–	}
5714		}
5715	<	}
5716	<	if (argc == 5) {
5717	<	int _v;
5718	<	void *vptr = 0;
5719	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5720	<	_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	<	}
5715	>	if (obj2) {
5716	>	{
5717	>	if (PyString_Check(obj2))
5718	>	arg3 = std::string(PyString_AsString(obj2));
5719	>	else
5720	>	SWIG_exception(SWIG_TypeError, "string expected");
5721		}
20049	–	}
5722		}
5723	<	}
5724	<	if (argc == 6) {
5725	<	int _v;
5726	<	void *vptr = 0;
5727	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5728	<	_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	<	}
5723	>	if (obj3) {
5724	>	{
5725	>	if (PyString_Check(obj3))
5726	>	arg4 = std::string(PyString_AsString(obj3));
5727	>	else
5728	>	SWIG_exception(SWIG_TypeError, "string expected");
5729		}
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 &""'");
5730		}
5731	<	arg2 = ptr;
5732	<	}
5733	<	{
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""'");
5731	>	if (obj4) {
5732	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5733	>	if (PyErr_Occurred()) SWIG_fail;
5734		}
5735	<	arg3 = *ptr;
5736	<	if (SWIG_IsNewObj(res)) delete ptr;
5737	<	}
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""'");
5735	>	if (obj5) {
5736	>	arg6 = PyInt_AsLong(obj5) ? true : false;
5737	>	if (PyErr_Occurred()) SWIG_fail;
5738		}
5739	<	arg5 = *ptr;
5740	<	if (SWIG_IsNewObj(res)) delete ptr;
5741	<	}
5742	<	{
5743	<	std::string *ptr = (std::string *)0;
5744	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
5745	<	if (!SWIG_IsOK(res) || !ptr) {
5746	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "6"" of type '" "std::string""'");
5747	<	}
5748	<	arg6 = *ptr;
5749	<	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""'");
20501	<	}
20502	<	arg3 = *ptr;
20503	<	if (SWIG_IsNewObj(res)) delete ptr;
20504	<	}
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""'");
20510	<	}
20511	<	arg4 = *ptr;
20512	<	if (SWIG_IsNewObj(res)) delete ptr;
20513	<	}
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());
20519	<	}
20520	<	}
20521	<	resultobj = SWIG_From_int(static_cast< int >(result));
20522	<	if (SWIG_IsNewObj(res2)) delete arg2;
20523	<	return resultobj;
20524	<	fail:
20525	<	if (SWIG_IsNewObj(res2)) delete arg2;
20526	<	return NULL;
20527	<	}
20528	<
20529	<
20530	<	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());
5739	>	{
5740	>	try {
5741	>	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5742	>
5743	>	}catch (const BossSchedFailure & e) {
5744	>	PyErr_SetString ( SchedulerError, e.what() );
5745	>	return NULL;
5746	>	}catch (const std::exception& e) {
5747	>	PyErr_SetString ( BossError, e.what() );
5748	>	return NULL;
5749	>	}
5750		}
5751	<	}
5752	<	resultobj = SWIG_From_int(static_cast< int >(result));
5753	<	if (SWIG_IsNewObj(res2)) delete arg2;
5754	<	return resultobj;
20623	<	fail:
20624	<	if (SWIG_IsNewObj(res2)) delete arg2;
20625	<	return NULL;
5751	>	resultobj = PyInt_FromLong((long)result);
5752	>	return resultobj;
5753	>	fail:
5754	>	return NULL;
5755		}
5756
5757
5758	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
5759	<	int argc;
5760	<	PyObject *argv[9];
5761	<	int ii;
5762	<
5763	<	if (!PyTuple_Check(args)) SWIG_fail;
5764	<	argc = PyObject_Length(args);
5765	<	for (ii = 0; (ii < argc) && (ii < 8); ii++) {
5766	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5767	<	}
5768	<	if (argc == 2) {
5769	<	int _v;
5770	<	void *vptr = 0;
5771	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5772	<	_v = SWIG_CheckState(res);
5773	<	if (_v) {
5774	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5775	<	_v = SWIG_CheckState(res);
5776	<	if (_v) {
5777	<	return _wrap_BossAdministratorSession_registerProgram__SWIG_6(self, args);
5778	<	}
5779	<	}
5780	<	}
5781	<	if (argc == 3) {
5782	<	int _v;
5783	<	void *vptr = 0;
5784	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5785	<	_v = SWIG_CheckState(res);
5786	<	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);
5758	>	static PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
5759	>	PyObject *resultobj;
5760	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5761	>	std::string *arg2 = 0 ;
5762	>	std::string arg3 = (std::string) "NULL" ;
5763	>	std::string arg4 = (std::string) "NULL" ;
5764	>	std::string arg5 = (std::string) "NULL" ;
5765	>	std::string arg6 = (std::string) "NULL" ;
5766	>	std::string arg7 = (std::string) "" ;
5767	>	bool arg8 = (bool) false ;
5768	>	int result;
5769	>	std::string temp2 ;
5770	>	PyObject * obj0 = 0 ;
5771	>	PyObject * obj1 = 0 ;
5772	>	PyObject * obj2 = 0 ;
5773	>	PyObject * obj3 = 0 ;
5774	>	PyObject * obj4 = 0 ;
5775	>	PyObject * obj5 = 0 ;
5776	>	PyObject * obj6 = 0 ;
5777	>	PyObject * obj7 = 0 ;
5778	>
5779	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5780	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5781	>	{
5782	>	if (PyString_Check(obj1)) {
5783	>	temp2 = std::string(PyString_AsString(obj1));
5784	>	arg2 = &temp2;
5785	>	}else {
5786	>	SWIG_exception(SWIG_TypeError, "string expected");
5787		}
20666	–	}
5788		}
5789	<	}
5790	<	if (argc == 4) {
5791	<	int _v;
5792	<	void *vptr = 0;
5793	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5794	<	_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	<	}
5789	>	if (obj2) {
5790	>	{
5791	>	if (PyString_Check(obj2))
5792	>	arg3 = std::string(PyString_AsString(obj2));
5793	>	else
5794	>	SWIG_exception(SWIG_TypeError, "string expected");
5795		}
20687	–	}
5796		}
5797	<	}
5798	<	if (argc == 5) {
5799	<	int _v;
5800	<	void *vptr = 0;
5801	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5802	<	_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	<	}
5797	>	if (obj3) {
5798	>	{
5799	>	if (PyString_Check(obj3))
5800	>	arg4 = std::string(PyString_AsString(obj3));
5801	>	else
5802	>	SWIG_exception(SWIG_TypeError, "string expected");
5803		}
20712	–	}
5804		}
5805	<	}
5806	<	if (argc == 6) {
5807	<	int _v;
5808	<	void *vptr = 0;
5809	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5810	<	_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	<	}
5805	>	if (obj4) {
5806	>	{
5807	>	if (PyString_Check(obj4))
5808	>	arg5 = std::string(PyString_AsString(obj4));
5809	>	else
5810	>	SWIG_exception(SWIG_TypeError, "string expected");
5811		}
20741	–	}
5812		}
5813	<	}
5814	<	if (argc == 7) {
5815	<	int _v;
5816	<	void *vptr = 0;
5817	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5818	<	_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	<	}
5813	>	if (obj5) {
5814	>	{
5815	>	if (PyString_Check(obj5))
5816	>	arg6 = std::string(PyString_AsString(obj5));
5817	>	else
5818	>	SWIG_exception(SWIG_TypeError, "string expected");
5819		}
20774	–	}
5820		}
5821	<	}
5822	<	if (argc == 8) {
5823	<	int _v;
5824	<	void *vptr = 0;
5825	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5826	<	_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	<	}
5821	>	if (obj6) {
5822	>	{
5823	>	if (PyString_Check(obj6))
5824	>	arg7 = std::string(PyString_AsString(obj6));
5825	>	else
5826	>	SWIG_exception(SWIG_TypeError, "string expected");
5827		}
20813	–	}
5828		}
5829	<	}
5830	<
5831	<	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 &""'");
5829	>	if (obj7) {
5830	>	arg8 = PyInt_AsLong(obj7) ? true : false;
5831	>	if (PyErr_Occurred()) SWIG_fail;
5832		}
5833	<	arg2 = ptr;
5834	<	}
5835	<	{
5836	<	std::string *ptr = (std::string *)0;
5837	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
5838	<	if (!SWIG_IsOK(res) || !ptr) {
5839	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
5840	<	}
5841	<	arg3 = *ptr;
5842	<	if (SWIG_IsNewObj(res)) delete ptr;
5843	<	}
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 &""'");
20950	<	}
20951	<	if (!ptr) {
20952	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
20953	<	}
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""'");
20961	<	}
20962	<	arg3 = *ptr;
20963	<	if (SWIG_IsNewObj(res)) delete ptr;
20964	<	}
20965	<	{
20966	<	std::string *ptr = (std::string *)0;
20967	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20968	<	if (!SWIG_IsOK(res) || !ptr) {
20969	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "4"" of type '" "std::string""'");
20970	<	}
20971	<	arg4 = *ptr;
20972	<	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());
5833	>	{
5834	>	try {
5835	>	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5836	>
5837	>	}catch (const BossSchedFailure & e) {
5838	>	PyErr_SetString ( SchedulerError, e.what() );
5839	>	return NULL;
5840	>	}catch (const std::exception& e) {
5841	>	PyErr_SetString ( BossError, e.what() );
5842	>	return NULL;
5843	>	}
5844		}
5845	<	}
5846	<	resultobj = SWIG_From_int(static_cast< int >(result));
5847	<	if (SWIG_IsNewObj(res2)) delete arg2;
5848	<	return resultobj;
21240	<	fail:
21241	<	if (SWIG_IsNewObj(res2)) delete arg2;
21242	<	return NULL;
5845	>	resultobj = PyInt_FromLong((long)result);
5846	>	return resultobj;
5847	>	fail:
5848	>	return NULL;
5849		}
5850
5851
5852	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
5853	<	int argc;
5854	<	PyObject *argv[8];
5855	<	int ii;
5856	<
5857	<	if (!PyTuple_Check(args)) SWIG_fail;
5858	<	argc = PyObject_Length(args);
5859	<	for (ii = 0; (ii < argc) && (ii < 7); ii++) {
5860	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5861	<	}
5862	<	if (argc == 2) {
5863	<	int _v;
5864	<	void *vptr = 0;
5865	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5866	<	_v = SWIG_CheckState(res);
5867	<	if (_v) {
5868	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5869	<	_v = SWIG_CheckState(res);
5870	<	if (_v) {
5871	<	return _wrap_BossAdministratorSession_registerRTMon__SWIG_5(self, args);
5872	<	}
5873	<	}
5874	<	}
5875	<	if (argc == 3) {
5876	<	int _v;
5877	<	void *vptr = 0;
5878	<	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);
5852	>	static PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
5853	>	PyObject *resultobj;
5854	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5855	>	std::string *arg2 = 0 ;
5856	>	std::string arg3 = (std::string) "NULL" ;
5857	>	std::string arg4 = (std::string) "NULL" ;
5858	>	std::string arg5 = (std::string) "NULL" ;
5859	>	bool arg6 = (bool) false ;
5860	>	bool arg7 = (bool) false ;
5861	>	int result;
5862	>	std::string temp2 ;
5863	>	PyObject * obj0 = 0 ;
5864	>	PyObject * obj1 = 0 ;
5865	>	PyObject * obj2 = 0 ;
5866	>	PyObject * obj3 = 0 ;
5867	>	PyObject * obj4 = 0 ;
5868	>	PyObject * obj5 = 0 ;
5869	>	PyObject * obj6 = 0 ;
5870	>
5871	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5872	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5873	>	{
5874	>	if (PyString_Check(obj1)) {
5875	>	temp2 = std::string(PyString_AsString(obj1));
5876	>	arg2 = &temp2;
5877	>	}else {
5878	>	SWIG_exception(SWIG_TypeError, "string expected");
5879		}
21283	–	}
5880		}
5881	<	}
5882	<	if (argc == 4) {
5883	<	int _v;
5884	<	void *vptr = 0;
5885	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5886	<	_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	<	}
5881	>	if (obj2) {
5882	>	{
5883	>	if (PyString_Check(obj2))
5884	>	arg3 = std::string(PyString_AsString(obj2));
5885	>	else
5886	>	SWIG_exception(SWIG_TypeError, "string expected");
5887		}
21304	–	}
5888		}
5889	<	}
5890	<	if (argc == 5) {
5891	<	int _v;
5892	<	void *vptr = 0;
5893	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5894	<	_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	<	}
5889	>	if (obj3) {
5890	>	{
5891	>	if (PyString_Check(obj3))
5892	>	arg4 = std::string(PyString_AsString(obj3));
5893	>	else
5894	>	SWIG_exception(SWIG_TypeError, "string expected");
5895		}
21329	–	}
5896		}
5897	<	}
5898	<	if (argc == 6) {
5899	<	int _v;
5900	<	void *vptr = 0;
5901	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5902	<	_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	<	}
21359	<	}
21360	<	}
21361	<	}
21362	<	}
21363	<	if (argc == 7) {
21364	<	int _v;
21365	<	void *vptr = 0;
21366	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
21367	<	_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	<	}
5897	>	if (obj4) {
5898	>	{
5899	>	if (PyString_Check(obj4))
5900	>	arg5 = std::string(PyString_AsString(obj4));
5901	>	else
5902	>	SWIG_exception(SWIG_TypeError, "string expected");
5903		}
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""'");
5904		}
5905	<	arg10 = *ptr;
5906	<	if (SWIG_IsNewObj(res)) delete ptr;
5907	<	}
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""'");
5905	>	if (obj5) {
5906	>	arg6 = PyInt_AsLong(obj5) ? true : false;
5907	>	if (PyErr_Occurred()) SWIG_fail;
5908		}
5909	<	arg6 = *ptr;
5910	<	if (SWIG_IsNewObj(res)) delete ptr;
5911	<	}
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""'");
5909	>	if (obj6) {
5910	>	arg7 = PyInt_AsLong(obj6) ? true : false;
5911	>	if (PyErr_Occurred()) SWIG_fail;
5912		}
5913	<	arg3 = *ptr;
5914	<	if (SWIG_IsNewObj(res)) delete ptr;
5915	<	}
5916	<	{
5917	<	std::string *ptr = (std::string *)0;
5918	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
5919	<	if (!SWIG_IsOK(res) || !ptr) {
5920	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
5921	<	}
5922	<	arg4 = *ptr;
5923	<	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 &""'");
22907	<	}
22908	<	arg2 = ptr;
22909	<	}
22910	<	{
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""'");
22915	<	}
22916	<	arg3 = *ptr;
22917	<	if (SWIG_IsNewObj(res)) delete ptr;
22918	<	}
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());
22933	<	}
22934	<	}
22935	<	resultobj = SWIG_From_int(static_cast< int >(result));
22936	<	if (SWIG_IsNewObj(res2)) delete arg2;
22937	<	return resultobj;
22938	<	fail:
22939	<	if (SWIG_IsNewObj(res2)) delete arg2;
22940	<	return NULL;
22941	<	}
22942	<
22943	<
22944	<	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());
5913	>	{
5914	>	try {
5915	>	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5916	>
5917	>	}catch (const BossSchedFailure & e) {
5918	>	PyErr_SetString ( SchedulerError, e.what() );
5919	>	return NULL;
5920	>	}catch (const std::exception& e) {
5921	>	PyErr_SetString ( BossError, e.what() );
5922	>	return NULL;
5923	>	}
5924		}
5925	<	}
5926	<	resultobj = SWIG_From_int(static_cast< int >(result));
5927	<	if (SWIG_IsNewObj(res2)) delete arg2;
5928	<	return resultobj;
23037	<	fail:
23038	<	if (SWIG_IsNewObj(res2)) delete arg2;
23039	<	return NULL;
5925	>	resultobj = PyInt_FromLong((long)result);
5926	>	return resultobj;
5927	>	fail:
5928	>	return NULL;
5929		}
5930
5931
5932	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
5933	<	int argc;
5934	<	PyObject *argv[16];
5935	<	int ii;
5936	<
5937	<	if (!PyTuple_Check(args)) SWIG_fail;
5938	<	argc = PyObject_Length(args);
5939	<	for (ii = 0; (ii < argc) && (ii < 15); ii++) {
5940	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5941	<	}
5942	<	if (argc == 2) {
5943	<	int _v;
5944	<	void *vptr = 0;
5945	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5946	<	_v = SWIG_CheckState(res);
5947	<	if (_v) {
5948	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5949	<	_v = SWIG_CheckState(res);
5950	<	if (_v) {
5951	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_13(self, args);
5952	<	}
5953	<	}
5954	<	}
5955	<	if (argc == 3) {
5956	<	int _v;
5957	<	void *vptr = 0;
5958	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5959	<	_v = SWIG_CheckState(res);
5960	<	if (_v) {
5961	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5962	<	_v = SWIG_CheckState(res);
5963	<	if (_v) {
5964	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
5965	<	_v = SWIG_CheckState(res);
5966	<	if (_v) {
5967	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_12(self, args);
5968	<	}
5969	<	}
5970	<	}
5971	<	}
5972	<	if (argc == 4) {
5973	<	int _v;
5974	<	void *vptr = 0;
5975	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5976	<	_v = SWIG_CheckState(res);
5977	<	if (_v) {
5978	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5979	<	_v = SWIG_CheckState(res);
5980	<	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	<	}
5932	>	static PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
5933	>	PyObject *resultobj;
5934	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5935	>	std::string *arg2 = 0 ;
5936	>	std::string arg3 = (std::string) "NULL" ;
5937	>	std::string arg4 = (std::string) "NULL" ;
5938	>	std::string arg5 = (std::string) "NULL" ;
5939	>	std::string arg6 = (std::string) "NULL" ;
5940	>	std::string arg7 = (std::string) "" ;
5941	>	std::string arg8 = (std::string) "" ;
5942	>	std::string arg9 = (std::string) "" ;
5943	>	std::string arg10 = (std::string) "" ;
5944	>	std::string const &arg11_defvalue = "" ;
5945	>	std::string *arg11 = (std::string *) &arg11_defvalue ;
5946	>	std::string arg12 = (std::string) "" ;
5947	>	std::string arg13 = (std::string) "" ;
5948	>	bool arg14 = (bool) false ;
5949	>	bool arg15 = (bool) false ;
5950	>	bool arg16 = (bool) false ;
5951	>	bool arg17 = (bool) false ;
5952	>	int result;
5953	>	std::string temp2 ;
5954	>	std::string temp11 ;
5955	>	PyObject * obj0 = 0 ;
5956	>	PyObject * obj1 = 0 ;
5957	>	PyObject * obj2 = 0 ;
5958	>	PyObject * obj3 = 0 ;
5959	>	PyObject * obj4 = 0 ;
5960	>	PyObject * obj5 = 0 ;
5961	>	PyObject * obj6 = 0 ;
5962	>	PyObject * obj7 = 0 ;
5963	>	PyObject * obj8 = 0 ;
5964	>	PyObject * obj9 = 0 ;
5965	>	PyObject * obj10 = 0 ;
5966	>	PyObject * obj11 = 0 ;
5967	>	PyObject * obj12 = 0 ;
5968	>	PyObject * obj13 = 0 ;
5969	>	PyObject * obj14 = 0 ;
5970	>	PyObject * obj15 = 0 ;
5971	>	PyObject * obj16 = 0 ;
5972	>
5973	>	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;
5974	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5975	>	{
5976	>	if (PyString_Check(obj1)) {
5977	>	temp2 = std::string(PyString_AsString(obj1));
5978	>	arg2 = &temp2;
5979	>	}else {
5980	>	SWIG_exception(SWIG_TypeError, "string expected");
5981		}
23101	–	}
5982		}
5983	<	}
5984	<	if (argc == 5) {
5985	<	int _v;
5986	<	void *vptr = 0;
5987	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5988	<	_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	<	}
5983	>	if (obj2) {
5984	>	{
5985	>	if (PyString_Check(obj2))
5986	>	arg3 = std::string(PyString_AsString(obj2));
5987	>	else
5988	>	SWIG_exception(SWIG_TypeError, "string expected");
5989		}
23126	–	}
5990		}
5991	<	}
5992	<	if (argc == 6) {
5993	<	int _v;
5994	<	void *vptr = 0;
5995	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5996	<	_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	<	}
5991	>	if (obj3) {
5992	>	{
5993	>	if (PyString_Check(obj3))
5994	>	arg4 = std::string(PyString_AsString(obj3));
5995	>	else
5996	>	SWIG_exception(SWIG_TypeError, "string expected");
5997		}
23155	–	}
5998		}
5999	<	}
6000	<	if (argc == 7) {
6001	<	int _v;
6002	<	void *vptr = 0;
6003	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6004	<	_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	<	}
5999	>	if (obj4) {
6000	>	{
6001	>	if (PyString_Check(obj4))
6002	>	arg5 = std::string(PyString_AsString(obj4));
6003	>	else
6004	>	SWIG_exception(SWIG_TypeError, "string expected");
6005		}
23188	–	}
6006		}
6007	<	}
6008	<	if (argc == 8) {
6009	<	int _v;
6010	<	void *vptr = 0;
6011	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6012	<	_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	<	}
6007	>	if (obj5) {
6008	>	{
6009	>	if (PyString_Check(obj5))
6010	>	arg6 = std::string(PyString_AsString(obj5));
6011	>	else
6012	>	SWIG_exception(SWIG_TypeError, "string expected");
6013		}
23225	–	}
6014		}
6015	<	}
6016	<	if (argc == 9) {
6017	<	int _v;
6018	<	void *vptr = 0;
6019	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6020	<	_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	<	}
6015	>	if (obj6) {
6016	>	{
6017	>	if (PyString_Check(obj6))
6018	>	arg7 = std::string(PyString_AsString(obj6));
6019	>	else
6020	>	SWIG_exception(SWIG_TypeError, "string expected");
6021		}
23266	–	}
6022		}
6023	<	}
6024	<	if (argc == 10) {
6025	<	int _v;
6026	<	void *vptr = 0;
6027	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6028	<	_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	<	}
6023	>	if (obj7) {
6024	>	{
6025	>	if (PyString_Check(obj7))
6026	>	arg8 = std::string(PyString_AsString(obj7));
6027	>	else
6028	>	SWIG_exception(SWIG_TypeError, "string expected");
6029		}
23311	–	}
6030		}
6031	<	}
6032	<	if (argc == 11) {
6033	<	int _v;
6034	<	void *vptr = 0;
6035	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6036	<	_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	<	}
6031	>	if (obj8) {
6032	>	{
6033	>	if (PyString_Check(obj8))
6034	>	arg9 = std::string(PyString_AsString(obj8));
6035	>	else
6036	>	SWIG_exception(SWIG_TypeError, "string expected");
6037		}
23360	–	}
6038		}
6039	<	}
6040	<	if (argc == 12) {
6041	<	int _v;
6042	<	void *vptr = 0;
6043	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6044	<	_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	<	}
6039	>	if (obj9) {
6040	>	{
6041	>	if (PyString_Check(obj9))
6042	>	arg10 = std::string(PyString_AsString(obj9));
6043	>	else
6044	>	SWIG_exception(SWIG_TypeError, "string expected");
6045		}
23413	–	}
6046		}
6047	<	}
6048	<	if (argc == 13) {
6049	<	int _v;
6050	<	void *vptr = 0;
6051	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6052	<	_v = SWIG_CheckState(res);
6053	<	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	<	}
6047	>	if (obj10) {
6048	>	{
6049	>	if (PyString_Check(obj10)) {
6050	>	temp11 = std::string(PyString_AsString(obj10));
6051	>	arg11 = &temp11;
6052	>	}else {
6053	>	SWIG_exception(SWIG_TypeError, "string expected");
6054		}
23468	–	}
6055		}
23470	–	}
6056		}
6057	<	}
6058	<	if (argc == 14) {
6059	<	int _v;
6060	<	void *vptr = 0;
6061	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6062	<	_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	<	}
6057	>	if (obj11) {
6058	>	{
6059	>	if (PyString_Check(obj11))
6060	>	arg12 = std::string(PyString_AsString(obj11));
6061	>	else
6062	>	SWIG_exception(SWIG_TypeError, "string expected");
6063		}
23533	–	}
6064		}
6065	<	}
6066	<	if (argc == 15) {
6067	<	int _v;
6068	<	void *vptr = 0;
6069	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6070	<	_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	<	}
6065	>	if (obj12) {
6066	>	{
6067	>	if (PyString_Check(obj12))
6068	>	arg13 = std::string(PyString_AsString(obj12));
6069	>	else
6070	>	SWIG_exception(SWIG_TypeError, "string expected");
6071		}
23602	–	}
6072		}
6073	<	}
6074	<
6075	<	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());
6073	>	if (obj13) {
6074	>	arg14 = PyInt_AsLong(obj13) ? true : false;
6075	>	if (PyErr_Occurred()) SWIG_fail;
6076		}
6077	<	}
6078	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
6079	<	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""'");
6077	>	if (obj14) {
6078	>	arg15 = PyInt_AsLong(obj14) ? true : false;
6079	>	if (PyErr_Occurred()) SWIG_fail;
6080		}
6081	<	arg2 = *ptr;
6082	<	if (SWIG_IsNewObj(res)) delete ptr;
6083	<	}
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());
6081	>	if (obj15) {
6082	>	arg16 = PyInt_AsLong(obj15) ? true : false;
6083	>	if (PyErr_Occurred()) SWIG_fail;
6084		}
6085	<	}
6086	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
6087	<	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""'");
6085	>	if (obj16) {
6086	>	arg17 = PyInt_AsLong(obj16) ? true : false;
6087	>	if (PyErr_Occurred()) SWIG_fail;
6088		}
6089	<	arg2 = *ptr;
6090	<	if (SWIG_IsNewObj(res)) delete ptr;
6091	<	}
6092	<	{
6093	<	try {
6094	<	result = (arg1)->SQL(arg2);
6095	<	} catch (const std::exception& e) {
6096	<	SWIG_exception(SWIG_RuntimeError, e.what());
6089	>	{
6090	>	try {
6091	>	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);
6092	>
6093	>	}catch (const BossSchedFailure & e) {
6094	>	PyErr_SetString ( SchedulerError, e.what() );
6095	>	return NULL;
6096	>	}catch (const std::exception& e) {
6097	>	PyErr_SetString ( BossError, e.what() );
6098	>	return NULL;
6099	>	}
6100		}
6101	<	}
6102	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
6103	<	return resultobj;
6104	<	fail:
23723	<	return NULL;
6101	>	resultobj = PyInt_FromLong((long)result);
6102	>	return resultobj;
6103	>	fail:
6104	>	return NULL;
6105		}
6106
6107
6108	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6109	<	int argc;
6110	<	PyObject *argv[4];
6111	<	int ii;
6112	<
6113	<	if (!PyTuple_Check(args)) SWIG_fail;
6114	<	argc = PyObject_Length(args);
6115	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6116	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
6117	<	}
6118	<	if (argc == 2) {
6119	<	int _v;
6120	<	void *vptr = 0;
6121	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6122	<	_v = SWIG_CheckState(res);
6123	<	if (_v) {
6124	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
6125	<	_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);
6108	>	static PyObject *_wrap_BossAdministratorSession_help(PyObject *self, PyObject *args) {
6109	>	PyObject *resultobj;
6110	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6111	>	std::string result;
6112	>	PyObject * obj0 = 0 ;
6113	>
6114	>	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_help",&obj0)) goto fail;
6115	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6116	>	{
6117	>	try {
6118	>	result = (arg1)->help();
6119	>
6120	>	}catch (const BossSchedFailure & e) {
6121	>	PyErr_SetString ( SchedulerError, e.what() );
6122	>	return NULL;
6123	>	}catch (const std::exception& e) {
6124	>	PyErr_SetString ( BossError, e.what() );
6125	>	return NULL;
6126		}
23766	–	}
6127		}
6128	<	}
6129	<
6130	<	fail:
6131	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_SQL'");
6132	<	return NULL;
6128	>	{
6129	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
6130	>	}
6131	>	return resultobj;
6132	>	fail:
6133	>	return NULL;
6134		}
6135
6136
6137	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_purge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6138	<	PyObject *resultobj = 0;
6139	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6140	<	std::string *arg2 = 0 ;
6141	<	std::string *arg3 = 0 ;
6142	<	std::string *arg4 = 0 ;
6143	<	std::string *arg5 = 0 ;
6144	<	int result;
6145	<	void *argp1 = 0 ;
6146	<	int res1 = 0 ;
6147	<	int res2 = SWIG_OLDOBJ ;
6148	<	int res3 = SWIG_OLDOBJ ;
6149	<	int res4 = SWIG_OLDOBJ ;
6150	<	int res5 = SWIG_OLDOBJ ;
6151	<	PyObject * obj0 = 0 ;
6152	<	PyObject * obj1 = 0 ;
6153	<	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 &""'");
6137	>	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
6138	>	PyObject *resultobj;
6139	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6140	>	std::string arg2 ;
6141	>	bool arg3 = (bool) false ;
6142	>	std::string result;
6143	>	PyObject * obj0 = 0 ;
6144	>	PyObject * obj1 = 0 ;
6145	>	PyObject * obj2 = 0 ;
6146	>
6147	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
6148	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6149	>	{
6150	>	if (PyString_Check(obj1))
6151	>	arg2 = std::string(PyString_AsString(obj1));
6152	>	else
6153	>	SWIG_exception(SWIG_TypeError, "string expected");
6154		}
6155	<	arg4 = ptr;
6156	<	}
6157	<	{
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 &""'");
6155	>	if (obj2) {
6156	>	arg3 = PyInt_AsLong(obj2) ? true : false;
6157	>	if (PyErr_Occurred()) SWIG_fail;
6158		}
6159	<	if (!ptr) {
6160	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "5"" of type '" "std::string const &""'");
6159	>	{
6160	>	try {
6161	>	result = (arg1)->SQL(arg2,arg3);
6162	>
6163	>	}catch (const BossSchedFailure & e) {
6164	>	PyErr_SetString ( SchedulerError, e.what() );
6165	>	return NULL;
6166	>	}catch (const std::exception& e) {
6167	>	PyErr_SetString ( BossError, e.what() );
6168	>	return NULL;
6169	>	}
6170		}
6171	<	arg5 = ptr;
6172	<	}
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());
6171	>	{
6172	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
6173		}
6174	<	}
6175	<	resultobj = SWIG_From_int(static_cast< int >(result));
6176	<	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;
6174	>	return resultobj;
6175	>	fail:
6176	>	return NULL;
6177		}
6178
6179
6180	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_purge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6181	<	PyObject *resultobj = 0;
6182	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6183	<	std::string *arg2 = 0 ;
6184	<	std::string *arg3 = 0 ;
6185	<	std::string *arg4 = 0 ;
6186	<	int result;
6187	<	void *argp1 = 0 ;
6188	<	int res1 = 0 ;
6189	<	int res2 = SWIG_OLDOBJ ;
6190	<	int res3 = SWIG_OLDOBJ ;
6191	<	int res4 = SWIG_OLDOBJ ;
6192	<	PyObject * obj0 = 0 ;
6193	<	PyObject * obj1 = 0 ;
6194	<	PyObject * obj2 = 0 ;
6195	<	PyObject * obj3 = 0 ;
6196	<
6197	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6198	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
6199	<	if (!SWIG_IsOK(res1)) {
6200	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_purge" "', argument " "1"" of type '" "BossAdministratorSession *""'");
6201	<	}
6202	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
6203	<	{
6204	<	std::string *ptr = (std::string *)0;
6205	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
6206	<	if (!SWIG_IsOK(res2)) {
6207	<	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 &""'");
6180	>	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
6181	>	PyObject *resultobj;
6182	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6183	>	std::string *arg2 = 0 ;
6184	>	std::string *arg3 = 0 ;
6185	>	std::string *arg4 = 0 ;
6186	>	std::string const &arg5_defvalue = "0" ;
6187	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
6188	>	int result;
6189	>	std::string temp2 ;
6190	>	std::string temp3 ;
6191	>	std::string temp4 ;
6192	>	std::string temp5 ;
6193	>	PyObject * obj0 = 0 ;
6194	>	PyObject * obj1 = 0 ;
6195	>	PyObject * obj2 = 0 ;
6196	>	PyObject * obj3 = 0 ;
6197	>	PyObject * obj4 = 0 ;
6198	>
6199	>	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6200	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6201	>	{
6202	>	if (PyString_Check(obj1)) {
6203	>	temp2 = std::string(PyString_AsString(obj1));
6204	>	arg2 = &temp2;
6205	>	}else {
6206	>	SWIG_exception(SWIG_TypeError, "string expected");
6207	>	}
6208		}
6209	<	arg4 = ptr;
6210	<	}
6211	<	{
6212	<	try {
6213	<	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
6214	<	} catch (const std::exception& e) {
6215	<	SWIG_exception(SWIG_RuntimeError, e.what());
6209	>	{
6210	>	if (PyString_Check(obj2)) {
6211	>	temp3 = std::string(PyString_AsString(obj2));
6212	>	arg3 = &temp3;
6213	>	}else {
6214	>	SWIG_exception(SWIG_TypeError, "string expected");
6215	>	}
6216		}
6217	<	}
6218	<	resultobj = SWIG_From_int(static_cast< int >(result));
6219	<	if (SWIG_IsNewObj(res2)) delete arg2;
6220	<	if (SWIG_IsNewObj(res3)) delete arg3;
6221	<	if (SWIG_IsNewObj(res4)) delete arg4;
6222	<	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	<	}
6217	>	{
6218	>	if (PyString_Check(obj3)) {
6219	>	temp4 = std::string(PyString_AsString(obj3));
6220	>	arg4 = &temp4;
6221	>	}else {
6222	>	SWIG_exception(SWIG_TypeError, "string expected");
6223		}
23972	–	}
6224		}
6225	<	}
6226	<	if (argc == 5) {
6227	<	int _v;
6228	<	void *vptr = 0;
6229	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
6230	<	_v = SWIG_CheckState(res);
6231	<	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);
6225	>	if (obj4) {
6226	>	{
6227	>	if (PyString_Check(obj4)) {
6228	>	temp5 = std::string(PyString_AsString(obj4));
6229	>	arg5 = &temp5;
6230	>	}else {
6231	>	SWIG_exception(SWIG_TypeError, "string expected");
6232		}
23995	–	}
6233		}
23997	–	}
6234		}
6235	<	}
6236	<
6237	<	fail:
6238	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_purge'");
6239	<	return NULL;
6235	>	{
6236	>	try {
6237	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
6238	>
6239	>	}catch (const BossSchedFailure & e) {
6240	>	PyErr_SetString ( SchedulerError, e.what() );
6241	>	return NULL;
6242	>	}catch (const std::exception& e) {
6243	>	PyErr_SetString ( BossError, e.what() );
6244	>	return NULL;
6245	>	}
6246	>	}
6247	>	resultobj = PyInt_FromLong((long)result);
6248	>	return resultobj;
6249	>	fail:
6250	>	return NULL;
6251		}
6252
6253
6254	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6255	<	PyObject *resultobj = 0;
6256	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6257	<	std::string arg2 ;
6258	<	int result;
6259	<	void *argp1 = 0 ;
6260	<	int res1 = 0 ;
6261	<	PyObject * obj0 = 0 ;
6262	<	PyObject * obj1 = 0 ;
6263	<
6264	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configure",&obj0,&obj1)) SWIG_fail;
6265	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
6266	<	if (!SWIG_IsOK(res1)) {
6267	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_configure" "', argument " "1"" of type '" "BossAdministratorSession *""'");
6268	<	}
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""'");
6254	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
6255	>	PyObject *resultobj;
6256	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
6257	>	std::string arg2 ;
6258	>	int result;
6259	>	PyObject * obj0 = 0 ;
6260	>	PyObject * obj1 = 0 ;
6261	>
6262	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
6263	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6264	>	{
6265	>	if (PyString_Check(obj1))
6266	>	arg2 = std::string(PyString_AsString(obj1));
6267	>	else
6268	>	SWIG_exception(SWIG_TypeError, "string expected");
6269		}
6270	<	arg2 = *ptr;
6271	<	if (SWIG_IsNewObj(res)) delete ptr;
6272	<	}
6273	<	{
6274	<	try {
6275	<	result = (int)(arg1)->configure(arg2);
6276	<	} catch (const std::exception& e) {
6277	<	SWIG_exception(SWIG_RuntimeError, e.what());
6270	>	{
6271	>	try {
6272	>	result = (int)(arg1)->registerPlugins(arg2);
6273	>
6274	>	}catch (const BossSchedFailure & e) {
6275	>	PyErr_SetString ( SchedulerError, e.what() );
6276	>	return NULL;
6277	>	}catch (const std::exception& e) {
6278	>	PyErr_SetString ( BossError, e.what() );
6279	>	return NULL;
6280	>	}
6281		}
6282	<	}
6283	<	resultobj = SWIG_From_int(static_cast< int >(result));
6284	<	return resultobj;
6285	<	fail:
24042	<	return NULL;
6282	>	resultobj = PyInt_FromLong((long)result);
6283	>	return resultobj;
6284	>	fail:
6285	>	return NULL;
6286		}
6287
6288
6289	<	SWIGINTERN PyObject *BossAdministratorSession_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6290	<	PyObject *obj;
6291	<	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
6292	<	SWIG_TypeNewClientData(SWIGTYPE_p_BossAdministratorSession, SWIG_NewClientData(obj));
6293	<	return SWIG_Py_Void();
6289	>	static PyObject * BossAdministratorSession_swigregister(PyObject *self, PyObject *args) {
6290	>	PyObject *obj;
6291	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6292	>	SWIG_TypeClientData(SWIGTYPE_p_BossAdministratorSession, obj);
6293	>	Py_INCREF(obj);
6294	>	return Py_BuildValue((char *)"");
6295		}
24052	–
6296		static PyMethodDef SwigMethods[] = {
6297	<	{ (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
6298	<	{ (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
6299	<	{ (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
6300	<	{ (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
6301	<	{ (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
6302	<	{ (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
6303	<	{ (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
6304	<	{ (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
6305	<	{ (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
6306	<	{ (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
6307	<	{ (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
6308	<	{ (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
6309	<	{ (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
6310	<	{ (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
6311	<	{ (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
6312	<	{ (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
6313	<	{ (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
6314	<	{ (char *)"objectMap_iterator", _wrap_objectMap_iterator, METH_VARARGS, NULL},
6315	<	{ (char *)"objectMap___nonzero__", _wrap_objectMap___nonzero__, METH_VARARGS, NULL},
6316	<	{ (char *)"objectMap___len__", _wrap_objectMap___len__, METH_VARARGS, NULL},
6317	<	{ (char *)"objectMap___getitem__", _wrap_objectMap___getitem__, METH_VARARGS, NULL},
6318	<	{ (char *)"objectMap___setitem__", _wrap_objectMap___setitem__, METH_VARARGS, NULL},
6319	<	{ (char *)"objectMap___delitem__", _wrap_objectMap___delitem__, METH_VARARGS, NULL},
6320	<	{ (char *)"objectMap_has_key", _wrap_objectMap_has_key, METH_VARARGS, NULL},
6321	<	{ (char *)"objectMap_keys", _wrap_objectMap_keys, METH_VARARGS, NULL},
6322	<	{ (char *)"objectMap_values", _wrap_objectMap_values, METH_VARARGS, NULL},
6323	<	{ (char *)"objectMap_items", _wrap_objectMap_items, METH_VARARGS, NULL},
6324	<	{ (char *)"objectMap___contains__", _wrap_objectMap___contains__, METH_VARARGS, NULL},
6325	<	{ (char *)"objectMap_key_iterator", _wrap_objectMap_key_iterator, METH_VARARGS, NULL},
6326	<	{ (char *)"objectMap_value_iterator", _wrap_objectMap_value_iterator, METH_VARARGS, NULL},
6327	<	{ (char *)"new_objectMap", _wrap_new_objectMap, METH_VARARGS, NULL},
6328	<	{ (char *)"objectMap_empty", _wrap_objectMap_empty, METH_VARARGS, NULL},
6329	<	{ (char *)"objectMap_size", _wrap_objectMap_size, METH_VARARGS, NULL},
6330	<	{ (char *)"objectMap_clear", _wrap_objectMap_clear, METH_VARARGS, NULL},
6331	<	{ (char *)"objectMap_swap", _wrap_objectMap_swap, METH_VARARGS, NULL},
6332	<	{ (char *)"objectMap_get_allocator", _wrap_objectMap_get_allocator, METH_VARARGS, NULL},
6333	<	{ (char *)"objectMap_begin", _wrap_objectMap_begin, METH_VARARGS, NULL},
6334	<	{ (char *)"objectMap_end", _wrap_objectMap_end, METH_VARARGS, NULL},
6335	<	{ (char *)"objectMap_rbegin", _wrap_objectMap_rbegin, METH_VARARGS, NULL},
6336	<	{ (char *)"objectMap_rend", _wrap_objectMap_rend, METH_VARARGS, NULL},
6337	<	{ (char *)"objectMap_count", _wrap_objectMap_count, METH_VARARGS, NULL},
6338	<	{ (char *)"objectMap_erase", _wrap_objectMap_erase, METH_VARARGS, NULL},
6339	<	{ (char *)"objectMap_find", _wrap_objectMap_find, METH_VARARGS, NULL},
6340	<	{ (char *)"objectMap_lower_bound", _wrap_objectMap_lower_bound, METH_VARARGS, NULL},
6341	<	{ (char *)"objectMap_upper_bound", _wrap_objectMap_upper_bound, METH_VARARGS, NULL},
6342	<	{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS, NULL},
6343	<	{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS, NULL},
6344	<	{ (char *)"vector_string_iterator", _wrap_vector_string_iterator, METH_VARARGS, NULL},
6345	<	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS, NULL},
6346	<	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS, NULL},
6347	<	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS, NULL},
6348	<	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS, NULL},
6349	<	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS, NULL},
6350	<	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS, NULL},
6351	<	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS, NULL},
6352	<	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS, NULL},
6353	<	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS, NULL},
6354	<	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS, NULL},
6355	<	{ (char *)"vector_string_empty", _wrap_vector_string_empty, METH_VARARGS, NULL},
6356	<	{ (char *)"vector_string_size", _wrap_vector_string_size, METH_VARARGS, NULL},
6357	<	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS, NULL},
6358	<	{ (char *)"vector_string_swap", _wrap_vector_string_swap, METH_VARARGS, NULL},
6359	<	{ (char *)"vector_string_get_allocator", _wrap_vector_string_get_allocator, METH_VARARGS, NULL},
6360	<	{ (char *)"vector_string_begin", _wrap_vector_string_begin, METH_VARARGS, NULL},
6361	<	{ (char *)"vector_string_end", _wrap_vector_string_end, METH_VARARGS, NULL},
6362	<	{ (char *)"vector_string_rbegin", _wrap_vector_string_rbegin, METH_VARARGS, NULL},
6363	<	{ (char *)"vector_string_rend", _wrap_vector_string_rend, METH_VARARGS, NULL},
6364	<	{ (char *)"vector_string_pop_back", _wrap_vector_string_pop_back, METH_VARARGS, NULL},
6365	<	{ (char *)"vector_string_erase", _wrap_vector_string_erase, METH_VARARGS, NULL},
6366	<	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS, NULL},
6367	<	{ (char *)"vector_string_push_back", _wrap_vector_string_push_back, METH_VARARGS, NULL},
6368	<	{ (char *)"vector_string_front", _wrap_vector_string_front, METH_VARARGS, NULL},
6369	<	{ (char *)"vector_string_back", _wrap_vector_string_back, METH_VARARGS, NULL},
6370	<	{ (char *)"vector_string_assign", _wrap_vector_string_assign, METH_VARARGS, NULL},
6371	<	{ (char *)"vector_string_resize", _wrap_vector_string_resize, METH_VARARGS, NULL},
6372	<	{ (char *)"vector_string_insert", _wrap_vector_string_insert, METH_VARARGS, NULL},
6373	<	{ (char *)"vector_string_reserve", _wrap_vector_string_reserve, METH_VARARGS, NULL},
6374	<	{ (char *)"vector_string_capacity", _wrap_vector_string_capacity, METH_VARARGS, NULL},
6375	<	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS, NULL},
6376	<	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS, NULL},
6377	<	{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS, NULL},
6378	<	{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS, NULL},
6379	<	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS, NULL},
6380	<	{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS, NULL},
6381	<	{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS, NULL},
6382	<	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS, NULL},
6383	<	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS, NULL},
6384	<	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS, NULL},
6385	<	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS, NULL},
6386	<	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS, NULL},
6387	<	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS, NULL},
6388	<	{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS, NULL},
6389	<	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS, NULL},
6390	<	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS, NULL},
6391	<	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS, NULL},
6392	<	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS, NULL},
6393	<	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS, NULL},
6394	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS, NULL},
6395	<	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS, NULL},
6396	<	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS, NULL},
6397	<	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS, NULL},
6398	<	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS, NULL},
6399	<	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS, NULL},
6400	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS, NULL},
6401	<	{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS, NULL},
6402	<	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS, NULL},
6403	<	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS, NULL},
6404	<	{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS, NULL},
6405	<	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS, NULL},
6406	<	{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS, NULL},
6407	<	{ (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 }
6297	>	{ (char *)"new_objectMap", _wrap_new_objectMap, METH_VARARGS },
6298	>	{ (char *)"objectMap___len__", _wrap_objectMap___len__, METH_VARARGS },
6299	>	{ (char *)"objectMap_clear", _wrap_objectMap_clear, METH_VARARGS },
6300	>	{ (char *)"objectMap___nonzero__", _wrap_objectMap___nonzero__, METH_VARARGS },
6301	>	{ (char *)"objectMap___getitem__", _wrap_objectMap___getitem__, METH_VARARGS },
6302	>	{ (char *)"objectMap___setitem__", _wrap_objectMap___setitem__, METH_VARARGS },
6303	>	{ (char *)"objectMap___delitem__", _wrap_objectMap___delitem__, METH_VARARGS },
6304	>	{ (char *)"objectMap_has_key", _wrap_objectMap_has_key, METH_VARARGS },
6305	>	{ (char *)"objectMap_keys", _wrap_objectMap_keys, METH_VARARGS },
6306	>	{ (char *)"objectMap_values", _wrap_objectMap_values, METH_VARARGS },
6307	>	{ (char *)"objectMap_items", _wrap_objectMap_items, METH_VARARGS },
6308	>	{ (char *)"objectMap___contains__", _wrap_objectMap___contains__, METH_VARARGS },
6309	>	{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
6310	>	{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
6311	>	{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
6312	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
6313	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
6314	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
6315	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
6316	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
6317	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
6318	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
6319	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
6320	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
6321	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
6322	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
6323	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
6324	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
6325	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
6326	>	{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
6327	>	{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
6328	>	{ (char *)"BossSession_resetDB", _wrap_BossSession_resetDB, METH_VARARGS },
6329	>	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
6330	>	{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
6331	>	{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
6332	>	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
6333	>	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
6334	>	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
6335	>	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
6336	>	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
6337	>	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
6338	>	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
6339	>	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS },
6340	>	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
6341	>	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
6342	>	{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
6343	>	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
6344	>	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
6345	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
6346	>	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
6347	>	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
6348	>	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
6349	>	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
6350	>	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
6351	>	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
6352	>	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
6353	>	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
6354	>	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
6355	>	{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
6356	>	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
6357	>	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
6358	>	{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
6359	>	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
6360	>	{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
6361	>	{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
6362	>	{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
6363	>	{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
6364	>	{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
6365	>	{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
6366	>	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
6367	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
6368	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
6369	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
6370	>	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
6371	>	{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
6372	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
6373	>	{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
6374	>	{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
6375	>	{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
6376	>	{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
6377	>	{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
6378	>	{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
6379	>	{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
6380	>	{ (char *)"BossTask_load", _wrap_BossTask_load, METH_VARARGS },
6381	>	{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
6382	>	{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
6383	>	{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
6384	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
6385	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
6386	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
6387	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
6388	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
6389	>	{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
6390	>	{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
6391	>	{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
6392	>	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
6393	>	{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
6394	>	{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
6395	>	{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
6396	>	{ (char *)"BossAdministratorSession_deleteRTMon", _wrap_BossAdministratorSession_deleteRTMon, METH_VARARGS },
6397	>	{ (char *)"BossAdministratorSession_deleteScheduler", _wrap_BossAdministratorSession_deleteScheduler, METH_VARARGS },
6398	>	{ (char *)"BossAdministratorSession_registerCHTool", _wrap_BossAdministratorSession_registerCHTool, METH_VARARGS },
6399	>	{ (char *)"BossAdministratorSession_registerProgram", _wrap_BossAdministratorSession_registerProgram, METH_VARARGS },
6400	>	{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
6401	>	{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
6402	>	{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
6403	>	{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
6404	>	{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
6405	>	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
6406	>	{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
6407	>	{ NULL, NULL }
6408		};
6409
6410
6411		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6412
6413	<	static void *_p_BossTaskExceptionTo_p_std__exception(void *x) {
6414	<	return (void *)((std::exception *)  ((BossTaskException *) x));
6415	<	}
6416	<	static swig_type_info _swigt__p_BossAdministratorSession = {"_p_BossAdministratorSession", "BossAdministratorSession *", 0, 0, (void*)0, 0};
6417	<	static swig_type_info _swigt__p_BossAttributeContainer = {"_p_BossAttributeContainer", "BossAttributeContainer *", 0, 0, (void*)0, 0};
6418	<	static swig_type_info _swigt__p_BossDatabase = {"_p_BossDatabase", "BossDatabase *", 0, 0, (void*)0, 0};
6419	<	static swig_type_info _swigt__p_BossJob = {"_p_BossJob", "BossJob *", 0, 0, (void*)0, 0};
6420	<	static swig_type_info _swigt__p_BossSession = {"_p_BossSession", "BossSession *", 0, 0, (void*)0, 0};
6421	<	static swig_type_info _swigt__p_BossTask = {"_p_BossTask", "BossTask *", 0, 0, (void*)0, 0};
6422	<	static swig_type_info _swigt__p_BossTaskException = {"_p_BossTaskException", "BossTaskException *", 0, 0, (void*)0, 0};
6423	<	static swig_type_info _swigt__p_XMLDoc = {"_p_XMLDoc", "XMLDoc *", 0, 0, (void*)0, 0};
6424	<	static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
6425	<	static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
6426	<	static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
6427	<	static swig_type_info _swigt__p_job_iterator = {"_p_job_iterator", "job_iterator *", 0, 0, (void*)0, 0};
6428	<	static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
6429	<	static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
6430	<	static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
6431	<	static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
6432	<	static swig_type_info _swigt__p_std__exception = {"_p_std__exception", "std::exception *", 0, 0, (void*)0, 0};
6433	<	static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
6434	<	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};
6435	<	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};
6436	<	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};
6437	<	static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
6438	<	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};
6439	<	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};
6440	<	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};
6441	<	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};
6442	<	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};
6443	<	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};
6444	<	static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
6445	<	static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
6446	<
6447	<	static swig_type_info *swig_type_initial[] = {
6448	<	&_swigt__p_BossAdministratorSession,
6449	<	&_swigt__p_BossAttributeContainer,
6450	<	&_swigt__p_BossDatabase,
6451	<	&_swigt__p_BossJob,
6452	<	&_swigt__p_BossSession,
6453	<	&_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,
6413	>	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
6414	>	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}};
6415	>	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}};
6416	>	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}};
6417	>	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}};
6418	>	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
6419	>	static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
6420	>	static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
6421	>	static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
6422	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
6423	>	static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
6424	>	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
6425	>	static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
6426	>	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}};
6427	>	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}};
6428	>	static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
6429	>	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}};
6430	>	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}};
6431	>	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
6432	>
6433	>	static swig_type_info *swig_types_initial[] = {
6434	>	_swigt__p_XMLDoc,
6435	>	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
6436	>	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
6437	>	_swigt__p_std__vectorTBossTask_p_t,
6438	>	_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
6439	>	_swigt__p_std__ostream,
6440	>	_swigt__p_BossTask,
6441	>	_swigt__p_BossTaskException,
6442	>	_swigt__p_printOption,
6443	>	_swigt__p_BossAttributeContainer,
6444	>	_swigt__p_BossJob,
6445	>	_swigt__p_BossDatabase,
6446	>	_swigt__p_BossSession,
6447	>	_swigt__p_std__vectorTstd__string_t,
6448	>	_swigt__p_std__mapTstd__string_std__string_t,
6449	>	_swigt__p_BossAdministratorSession,
6450	>	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
6451	>	_swigt__p_BossTask__job_iterator,
6452	>	_swigt__p_jobStates,
6453	>	0
6454		};
6455
6456
6457		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6458
6459		static swig_const_info swig_const_table[] = {
6460	<	{0, 0, 0, 0.0, 0, 0}};
6460	>	{ SWIG_PY_INT,     (char *)"RUNNING", (long) RUNNING, 0, 0, 0},
6461	>	{ SWIG_PY_INT,     (char *)"SCHEDULED", (long) SCHEDULED, 0, 0, 0},
6462	>	{ SWIG_PY_INT,     (char *)"SUBMITTED", (long) SUBMITTED, 0, 0, 0},
6463	>	{ SWIG_PY_INT,     (char *)"ALL", (long) ALL, 0, 0, 0},
6464	>	{ SWIG_PY_INT,     (char *)"STATUS_ONLY", (long) STATUS_ONLY, 0, 0, 0},
6465	>	{ SWIG_PY_INT,     (char *)"NORMAL", (long) NORMAL, 0, 0, 0},
6466	>	{ SWIG_PY_INT,     (char *)"SPECIFIC", (long) SPECIFIC, 0, 0, 0},
6467	>	{ SWIG_PY_INT,     (char *)"PROGRAMS", (long) PROGRAMS, 0, 0, 0},
6468	>	{ SWIG_PY_INT,     (char *)"FULL", (long) FULL, 0, 0, 0},
6469	>	{0}};
6470
6471		#ifdef __cplusplus
6472		}
6473		#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	–	* ----------------------------------------------------------------------------- */
6474
6475		#ifdef __cplusplus
6476	<	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);
6476	>	extern "C"
6477		#endif
6478	+	SWIGEXPORT(void) SWIG_init(void) {
6479	+	static PyObject *SWIG_globals = 0;
6480	+	static int       typeinit = 0;
6481	+	PyObject *m, *d;
6482	+	int       i;
6483	+	if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
6484	+	m = Py_InitModule((char *) SWIG_name, SwigMethods);
6485	+	d = PyModule_GetDict(m);
6486
6487	<	/* if there is another module already loaded */
6488	<	if (swig_module.next != &swig_module) {
6489	<	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);
24461	<	#endif
24462	<	}
24463	<	} else {
24464	<	type = swig_module.type_initial[i];
24465	<	}
24466	<
24467	<	/* Insert casting types */
24468	<	cast = swig_module.cast_initial[i];
24469	<	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);
24553	<	}
24554	<	equiv = equiv->next;
24555	<	}
24556	<	}
24557	<	}
24558	<	}
24559	<
24560	<	#ifdef __cplusplus
24561	<	#if 0
24562	<	{
24563	<	/* c-mode */
24564	<	#endif
24565	<	}
24566	<	#endif
24567	<
24568	<
24569	<
24570	<	#ifdef __cplusplus
24571	<	extern "C" {
24572	<	#endif
24573	<
24574	<	/* 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	<	}
6487	>	if (!typeinit) {
6488	>	for (i = 0; swig_types_initial[i]; i++) {
6489	>	swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
6490		}
6491	<	}
6491	>	typeinit = 1;
6492		}
6493	<	}
6494	<
6495	<	#ifdef __cplusplus
6496	<	}
6497	<	#endif
6498	<
6499	<	/* -----------------------------------------------------------------------------*
6500	<	*  Partial Init method
6501	<	* -----------------------------------------------------------------------------*/
6502	<
6503	<	#ifdef __cplusplus
6504	<	extern "C"
6505	<	#endif
6506	<	SWIGEXPORT void SWIG_init(void) {
6507	<	PyObject *m, *d;
6508	<
6509	<	/* Fix SwigMethods to carry the callback ptrs when needed */
6510	<	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)));
6493	>	SWIG_InstallConstants(d,swig_const_table);
6494	>
6495	>
6496	>	// define custom exceptions
6497	>	PyObject *e;
6498	>	PyMethodDef tp_methods = {
6499	>	NULL, NULL, 0, NULL
6500	>	};
6501	>	e = Py_InitModule("BossSession", &tp_methods);
6502	>	// generic BOSS exception
6503	>	BossError = PyErr_NewException("BossSession.BossError", NULL, NULL);
6504	>	Py_INCREF(BossError);
6505	>	PyModule_AddObject(e, "BossError", BossError);
6506	>	// scheduler interaction BOSS exception
6507	>	SchedulerError = PyErr_NewException("BossSession.BossError.SchedulerError", BossError, NULL);
6508	>	Py_INCREF(SchedulerError);
6509	>	PyModule_AddObject(e, "SchedulerError", SchedulerError);
6510	>
6511		}
6512

Diff Legend

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