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.8 by gcodispo, Fri Oct 27 15:24:50 2006 UTC vs.
Revision 1.9 by gcodispo, Mon Oct 30 10:44:38 2006 UTC

#	Line 1 | Line 1
1		/* ----------------------------------------------------------------------------
2		* This file was automatically generated by SWIG (http://www.swig.org).
3	<	* Version 1.3.19
3	>	* Version 1.3.29
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
13
14		#ifdef __cplusplus
15		template<class T> class SwigValueWrapper {
16		T *tt;
17		public:
18	<	inline SwigValueWrapper() : tt(0) { }
19	<	inline ~SwigValueWrapper() { if (tt) delete tt; }
20	<	inline SwigValueWrapper& operator=(const T& t) { tt = new T(t); return *this; }
21	<	inline operator T&() const { return *tt; }
22	<	inline T *operator&() { return tt; }
23	<	};
18	>	SwigValueWrapper() : tt(0) { }
19	>	SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20	>	SwigValueWrapper(const T& t) : tt(new T(t)) { }
21	>	~SwigValueWrapper() { delete tt; }
22	>	SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23	>	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	<	#include "Python.h"
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	<	/***********************************************************************
49	<	* common.swg
50	<	*
51	<	*     This file contains generic SWIG runtime support for pointer
52	<	*     type checking as well as a few commonly used macros to control
53	<	*     external linkage.
54	<	*
55	<	* 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	<	************************************************************************/
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	<	#include <string.h>
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	<	#if defined(_WIN32) || defined(__WIN32__)
73	<	#       if defined(_MSC_VER)
74	<	#               if defined(STATIC_LINKED)
75	<	#                       define SWIGEXPORT(a) a
76	<	#                       define SWIGIMPORT(a) extern a
77	<	#               else
78	<	#                       define SWIGEXPORT(a) __declspec(dllexport) a
79	<	#                       define SWIGIMPORT(a) extern a
80	<	#               endif
81	<	#       else
82	<	#               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
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
83		#endif
84
85	<	#ifdef SWIG_GLOBAL
86	<	#define SWIGRUNTIME(a) SWIGEXPORT(a)
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
126	>
127	>
128	>	/* Python.h has to appear first */
129	>	#include <Python.h>
130	>
131	>	/* -----------------------------------------------------------------------------
132	>	* swigrun.swg
133	>	*
134	>	* This file contains generic CAPI SWIG runtime support for pointer
135	>	* type checking.
136	>	* ----------------------------------------------------------------------------- */
137	>
138	>	/* This should only be incremented when either the layout of swig_type_info changes,
139	>	or for whatever reason, the runtime changes incompatibly */
140	>	#define SWIG_RUNTIME_VERSION "2"
141	>
142	>	/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143	>	#ifdef SWIG_TYPE_TABLE
144	>	# 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 SWIGRUNTIME(a) static a
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
163	>
164	>	#ifndef SWIGRUNTIMEINLINE
165	>	# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166	>	#endif
167	>
168	>	/*  Generic buffer size */
169	>	#ifndef SWIG_BUFFER_SIZE
170	>	# define SWIG_BUFFER_SIZE 1024
171	>	#endif
172	>
173	>	/* Flags for pointer conversions */
174	>	#define SWIG_POINTER_DISOWN        0x1
175	>
176	>	/* 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)
304		#endif
305
306	+
307	+
308	+
309	+	#include <string.h>
310	+
311		#ifdef __cplusplus
312		extern "C" {
313		#endif
#	Line 78 | Line 315 | extern "C" {
315		typedef void *(*swig_converter_func)(void *);
316		typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318	+	/* Structure to store inforomation on one type */
319		typedef struct swig_type_info {
320	<	const char             *name;
321	<	swig_converter_func     converter;
322	<	const char             *str;
323	<	void                   *clientdata;
324	<	swig_dycast_func        dcast;
325	<	struct swig_type_info  *next;
88	<	struct swig_type_info  *prev;
320	>	const char             *name;                 /* mangled name of this type */
321	>	const char             *str;                  /* human readable name of this type */
322	>	swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
323	>	struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
324	>	void                   *clientdata;           /* language specific type data */
325	>	int                    owndata;               /* flag if the structure owns the clientdata */
326		} swig_type_info;
327
328	<	#ifdef SWIG_NOINCLUDE
329	<
330	<	SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
331	<	SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
332	<	SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
333	<	SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
334	<	SWIGIMPORT(const char *)     SWIG_TypeName(const swig_type_info *);
335	<	SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
336	<	SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);
337	<
338	<	#else
339	<
340	<	static swig_type_info *swig_type_list = 0;
328	>	/* 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	>	}
365
366	<	/* Register a type mapping with the type-checking */
367	<	SWIGRUNTIME(swig_type_info *)
368	<	SWIG_TypeRegister(swig_type_info *ti)
369	<	{
370	<	swig_type_info *tc, *head, *ret, *next;
371	<	/* Check to see if this type has already been registered */
372	<	tc = swig_type_list;
373	<	while (tc) {
374	<	if (strcmp(tc->name, ti->name) == 0) {
375	<	/* Already exists in the table.  Just add additional types to the list */
376	<	if (tc->clientdata) ti->clientdata = tc->clientdata;
377	<	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;
366	>	/*
367	>	Check type equivalence in a name list like <name1>|<name2>|...
368	>	Return 0 if not equal, 1 if equal
369	>	*/
370	>	SWIGRUNTIME int
371	>	SWIG_TypeEquiv(const char *nb, const char *tb) {
372	>	int equiv = 0;
373	>	const char* te = tb + strlen(tb);
374	>	const char* ne = nb;
375	>	while (!equiv && *ne) {
376	>	for (nb = ne; *ne; ++ne) {
377	>	if (*ne == '|') break;
378		}
379	<	s = s->next;
380	<	} while (s && (s != ty->next));
381	<	return 0;
379	>	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380	>	if (*ne) ++ne;
381	>	}
382	>	return equiv;
383		}
384
385	<	/* Cast a pointer up an inheritance hierarchy */
386	<	SWIGRUNTIME(void *)
387	<	SWIG_TypeCast(swig_type_info *ty, void *ptr)
388	<	{
389	<	if ((!ty) || (!ty->converter)) return ptr;
390	<	return (*ty->converter)(ptr);
385	>	/*
386	>	Check type equivalence in a name list like <name1>|<name2>|...
387	>	Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388	>	*/
389	>	SWIGRUNTIME int
390	>	SWIG_TypeCompare(const char *nb, const char *tb) {
391	>	int equiv = 0;
392	>	const char* te = tb + strlen(tb);
393	>	const char* ne = nb;
394	>	while (!equiv && *ne) {
395	>	for (nb = ne; *ne; ++ne) {
396	>	if (*ne == '|') break;
397	>	}
398	>	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399	>	if (*ne) ++ne;
400	>	}
401	>	return equiv;
402		}
403
404	<	/* Dynamic pointer casting. Down an inheritance hierarchy */
405	<	SWIGRUNTIME(swig_type_info *)
406	<	SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
407	<	{
404	>
405	>	/* think of this as a c++ template<> or a scheme macro */
406	>	#define SWIG_TypeCheck_Template(comparison, ty)         \
407	>	if (ty) {                                             \
408	>	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) {
454		swig_type_info *lastty = ty;
455		if (!ty || !ty->dcast) return ty;
456		while (ty && (ty->dcast)) {
457	<	ty = (*ty->dcast)(ptr);
458	<	if (ty) lastty = ty;
457	>	ty = (*ty->dcast)(ptr);
458	>	if (ty) lastty = ty;
459		}
460		return lastty;
461		}
462
463	<	/* Return the name associated with this type */
464	<	SWIGRUNTIME(const char *)
463	>	/*
464	>	Return the name associated with this type
465	>	*/
466	>	SWIGRUNTIMEINLINE const char *
467		SWIG_TypeName(const swig_type_info *ty) {
468		return ty->name;
469		}
470
471	<	/* Search for a swig_type_info structure */
472	<	SWIGRUNTIME(swig_type_info *)
473	<	SWIG_TypeQuery(const char *name) {
474	<	swig_type_info *ty = swig_type_list;
475	<	while (ty) {
476	<	if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
477	<	if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
478	<	ty = ty->prev;
471	>	/*
472	>	Return the pretty name associated with this type,
473	>	that is an unmangled type name in a form presentable to the user.
474	>	*/
475	>	SWIGRUNTIME const char *
476	>	SWIG_TypePrettyName(const swig_type_info *type) {
477	>	/* The "str" field contains the equivalent pretty names of the
478	>	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;
488		}
489	<	return 0;
489	>	else
490	>	return type->name;
491		}
492
493	<	/* Set the clientdata field for a type */
494	<	SWIGRUNTIME(void)
493	>	/*
494	>	Set the clientdata field for a type
495	>	*/
496	>	SWIGRUNTIME void
497		SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498	<	swig_type_info *tc, *equiv;
499	<	if (ti->clientdata == clientdata) return;
498	>	swig_cast_info *cast = ti->cast;
499	>	/* if (ti->clientdata == clientdata) return; */
500		ti->clientdata = clientdata;
501	<	equiv = ti->next;
502	<	while (equiv) {
503	<	if (!equiv->converter) {
504	<	tc = swig_type_list;
505	<	while (tc) {
506	<	if ((strcmp(tc->name, equiv->name) == 0))
223	<	SWIG_TypeClientData(tc,clientdata);
224	<	tc = tc->prev;
501	>
502	>	while (cast) {
503	>	if (!cast->converter) {
504	>	swig_type_info *tc = cast->type;
505	>	if (!tc->clientdata) {
506	>	SWIG_TypeClientData(tc, clientdata);
507		}
508	+	}
509	+	cast = cast->next;
510	+	}
511	+	}
512	+	SWIGRUNTIME void
513	+	SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514	+	SWIG_TypeClientData(ti, clientdata);
515	+	ti->owndata = 1;
516	+	}
517	+
518	+	/*
519	+	Search for a swig_type_info structure only by mangled name
520	+	Search is a O(log #types)
521	+
522	+	We start searching at module start, and finish searching when start == end.
523	+	Note: if start == end at the beginning of the function, we go all the way around
524	+	the circular list.
525	+	*/
526	+	SWIGRUNTIME swig_type_info *
527	+	SWIG_MangledTypeQueryModule(swig_module_info *start,
528	+	swig_module_info *end,
529	+	const char *name) {
530	+	swig_module_info *iter = start;
531	+	do {
532	+	if (iter->size) {
533	+	register size_t l = 0;
534	+	register size_t r = iter->size - 1;
535	+	do {
536	+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
537	+	register size_t i = (l + r) >> 1;
538	+	const char *iname = iter->types[i]->name;
539	+	if (iname) {
540	+	register int compare = strcmp(name, iname);
541	+	if (compare == 0) {
542	+	return iter->types[i];
543	+	} else if (compare < 0) {
544	+	if (i) {
545	+	r = i - 1;
546	+	} else {
547	+	break;
548	+	}
549	+	} else if (compare > 0) {
550	+	l = i + 1;
551	+	}
552	+	} else {
553	+	break; /* should never happen */
554	+	}
555	+	} while (l <= r);
556		}
557	<	equiv = equiv->next;
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];
588	>	}
589	>	iter = iter->next;
590	>	} while (iter != end);
591	>	}
592	>
593	>	/* neither found a match */
594	>	return 0;
595	>	}
596	>
597	>	/*
598	>	Pack binary data into a string
599	>	*/
600	>	SWIGRUNTIME char *
601	>	SWIG_PackData(char *c, void *ptr, size_t sz) {
602	>	static const char hex[17] = "0123456789abcdef";
603	>	register const unsigned char *u = (unsigned char *) ptr;
604	>	register const unsigned char *eu =  u + sz;
605	>	for (; u != eu; ++u) {
606	>	register unsigned char uu = *u;
607	>	*(c++) = hex[(uu & 0xf0) >> 4];
608	>	*(c++) = hex[uu & 0xf];
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;
691	+	}
692	+	}
693	+	return SWIG_UnpackData(++c,ptr,sz);
694		}
230	–	#endif
695
696		#ifdef __cplusplus
697		}
698	+	#endif
699	+
700	+	/*  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	<	/***********************************************************************
730	<	* python.swg
731	<	*
732	<	*     This file contains the runtime support for Python modules
733	<	*     and includes code for managing global variables and pointer
734	<	*     type checking.
735	<	*
736	<	* Author : David Beazley (beazley@cs.uchicago.edu)
737	<	************************************************************************/
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);
745	>	}
746	>	#endif
747
748	<	#include "Python.h"
748	>	/* Add PyObject_Del for old Pythons */
749	>	#if PY_VERSION_HEX < 0x01060000
750	>	# define PyObject_Del(op) PyMem_DEL((op))
751	>	#endif
752	>	#ifndef PyObject_DEL
753	>	# define PyObject_DEL PyObject_Del
754	>	#endif
755	>
756	>	/* A crude PyExc_StopIteration exception for old Pythons */
757	>	#if PY_VERSION_HEX < 0x02020000
758	>	# ifndef PyExc_StopIteration
759	>	#  define PyExc_StopIteration PyExc_RuntimeError
760	>	# endif
761	>	# ifndef PyObject_GenericGetAttr
762	>	#  define PyObject_GenericGetAttr 0
763	>	# endif
764	>	#endif
765	>	/* Py_NotImplemented is defined in 2.1 and up. */
766	>	#if PY_VERSION_HEX < 0x02010000
767	>	# ifndef Py_NotImplemented
768	>	#  define Py_NotImplemented PyExc_RuntimeError
769	>	# endif
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
936	>
937	>	/* -----------------------------------------------------------------------------
938	>	* Python API portion that goes into the runtime
939	>	* ----------------------------------------------------------------------------- */
940
941		#ifdef __cplusplus
942		extern "C" {
943	+	#if 0
944	+	} /* cc-mode */
945	+	#endif
946		#endif
947
948	<	#define SWIG_PY_INT     1
949	<	#define SWIG_PY_FLOAT   2
950	<	#define SWIG_PY_STRING  3
948	>	/* -----------------------------------------------------------------------------
949	>	* Constant declarations
950	>	* ----------------------------------------------------------------------------- */
951	>
952	>	/* Constant Types */
953		#define SWIG_PY_POINTER 4
954		#define SWIG_PY_BINARY  5
955
259	–	/* Flags for pointer conversion */
260	–
261	–	#define SWIG_POINTER_EXCEPTION     0x1
262	–	#define SWIG_POINTER_DISOWN        0x2
263	–
264	–	/* Exception handling in wrappers */
265	–	#define SWIG_fail   goto fail
266	–
956		/* 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;
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 SWIG_NOINCLUDE
966	>	#ifdef __cplusplus
967	>	#if 0
968	>	{ /* cc-mode */
969	>	#endif
970	>	}
971	>	#endif
972
973	<	SWIGEXPORT(PyObject *)        SWIG_newvarlink(void);
974	<	SWIGEXPORT(void)              SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
975	<	SWIGEXPORT(int)               SWIG_ConvertPtr(PyObject *, void **, swig_type_info *, int);
976	<	SWIGEXPORT(int)               SWIG_ConvertPacked(PyObject *, void *, int sz, swig_type_info *, int);
977	<	SWIGEXPORT(char *)            SWIG_PackData(char *c, void *, int);
978	<	SWIGEXPORT(char *)            SWIG_UnpackData(char *c, void *, int);
979	<	SWIGEXPORT(PyObject *)        SWIG_NewPointerObj(void *, swig_type_info *,int own);
980	<	SWIGEXPORT(PyObject *)        SWIG_NewPackedObj(void *, int sz, swig_type_info *);
981	<	SWIGEXPORT(void)              SWIG_InstallConstants(PyObject *d, swig_const_info constants[]);
973	>
974	>	/* -----------------------------------------------------------------------------
975	>	* 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)
1019	>
1020	>	#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
1021	>	#define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg
1022	>	#define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)
1023	>	#define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024	>	#define SWIG_fail                                       goto fail
1025	>
1026	>
1027	>	/* Runtime API implementation */
1028	>
1029	>	/* Error manipulation */
1030	>
1031	>	SWIGINTERN void
1032	>	SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033	>	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034	>	PyErr_SetObject(errtype, obj);
1035	>	Py_DECREF(obj);
1036	>	SWIG_PYTHON_THREAD_END_BLOCK;
1037	>	}
1038	>
1039	>	SWIGINTERN void
1040	>	SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041	>	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042	>	PyErr_SetString(errtype, (char *) msg);
1043	>	SWIG_PYTHON_THREAD_END_BLOCK;
1044	>	}
1045	>
1046	>	#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047	>
1048	>	/* Set a constant value */
1049	>
1050	>	SWIGINTERN void
1051	>	SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052	>	PyDict_SetItemString(d, (char*) name, obj);
1053	>	Py_DECREF(obj);
1054	>	}
1055	>
1056	>	/* Append a value to the result obj */
1057	>
1058	>	SWIGINTERN PyObject*
1059	>	SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060	>	#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061	>	if (!result) {
1062	>	result = obj;
1063	>	} else if (result == Py_None) {
1064	>	Py_DECREF(result);
1065	>	result = obj;
1066	>	} else {
1067	>	if (!PyList_Check(result)) {
1068	>	PyObject *o2 = result;
1069	>	result = PyList_New(1);
1070	>	PyList_SetItem(result, 0, o2);
1071	>	}
1072	>	PyList_Append(result,obj);
1073	>	Py_DECREF(obj);
1074	>	}
1075	>	return result;
1076		#else
1077	+	PyObject*   o2;
1078	+	PyObject*   o3;
1079	+	if (!result) {
1080	+	result = obj;
1081	+	} else if (result == Py_None) {
1082	+	Py_DECREF(result);
1083	+	result = obj;
1084	+	} else {
1085	+	if (!PyTuple_Check(result)) {
1086	+	o2 = result;
1087	+	result = PyTuple_New(1);
1088	+	PyTuple_SET_ITEM(result, 0, o2);
1089	+	}
1090	+	o3 = PyTuple_New(1);
1091	+	PyTuple_SET_ITEM(o3, 0, obj);
1092	+	o2 = result;
1093	+	result = PySequence_Concat(o2, o3);
1094	+	Py_DECREF(o2);
1095	+	Py_DECREF(o3);
1096	+	}
1097	+	return result;
1098	+	#endif
1099	+	}
1100	+
1101	+	/* Unpack the argument tuple */
1102	+
1103	+	SWIGINTERN int
1104	+	SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105	+	{
1106	+	if (!args) {
1107	+	if (!min && !max) {
1108	+	return 1;
1109	+	} else {
1110	+	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111	+	name, (min == max ? "" : "at least "), min);
1112	+	return 0;
1113	+	}
1114	+	}
1115	+	if (!PyTuple_Check(args)) {
1116	+	PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117	+	return 0;
1118	+	} else {
1119	+	register int l = PyTuple_GET_SIZE(args);
1120	+	if (l < min) {
1121	+	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122	+	name, (min == max ? "" : "at least "), min, l);
1123	+	return 0;
1124	+	} else if (l > max) {
1125	+	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126	+	name, (min == max ? "" : "at most "), max, l);
1127	+	return 0;
1128	+	} else {
1129	+	register int i;
1130	+	for (i = 0; i < l; ++i) {
1131	+	objs[i] = PyTuple_GET_ITEM(args, i);
1132	+	}
1133	+	for (; l < max; ++l) {
1134	+	objs[l] = 0;
1135	+	}
1136	+	return i + 1;
1137	+	}
1138	+	}
1139	+	}
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
1147	+
1148	+	/*
1149	+	Helper for static pointer initialization for both C and C++ code, for example
1150	+	static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151	+	*/
1152	+	#ifdef __cplusplus
1153	+	#define SWIG_STATIC_POINTER(var)  var
1154	+	#else
1155	+	#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1156	+	#endif
1157
1158		/* -----------------------------------------------------------------------------
1159	<	* global variable support code.
1159	>	* Pointer declarations
1160		* ----------------------------------------------------------------------------- */
1161
1162	<	typedef struct swig_globalvar {
1163	<	char       *name;                  /* Name of global variable */
1164	<	PyObject *(*get_attr)(void);       /* Return the current value */
1165	<	int       (*set_attr)(PyObject *); /* Set the value */
1166	<	struct swig_globalvar *next;
299	<	} swig_globalvar;
1162	>	/* Flags for new pointer objects */
1163	>	#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1164	>	#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165	>
1166	>	#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1167
1168	<	typedef struct swig_varlinkobject {
1168	>	#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 {
1304		PyObject_HEAD
1305	<	swig_globalvar *vars;
1306	<	} swig_varlinkobject;
1305	>	void *ptr;
1306	>	swig_type_info *ty;
1307	>	int own;
1308	>	PyObject *next;
1309	>	} PySwigObject;
1310
1311	<	static PyObject *
1312	<	swig_varlink_repr(swig_varlinkobject *v) {
1313	<	v = v;
1314	<	return PyString_FromString("<Global variables>");
1311	>	SWIGRUNTIME PyObject *
1312	>	PySwigObject_long(PySwigObject *v)
1313	>	{
1314	>	return PyLong_FromVoidPtr(v->ptr);
1315		}
1316
1317	<	static int
1318	<	swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
1319	<	swig_globalvar  *var;
1320	<	flags = flags;
1321	<	fprintf(fp,"Global variables { ");
1322	<	for (var = v->vars; var; var=var->next) {
1323	<	fprintf(fp,"%s", var->name);
1324	<	if (var->next) fprintf(fp,", ");
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	<	fprintf(fp," }\n");
322	<	return 0;
1332	>	return res;
1333		}
1334
1335	<	static PyObject *
1336	<	swig_varlink_getattr(swig_varlinkobject *v, char *n) {
1337	<	swig_globalvar *var = v->vars;
1338	<	while (var) {
1339	<	if (strcmp(var->name,n) == 0) {
1340	<	return (*var->get_attr)();
1341	<	}
1342	<	var = var->next;
1343	<	}
1344	<	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
1345	<	return NULL;
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	<	static int
1395	<	swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
1396	<	swig_globalvar *var = v->vars;
1397	<	while (var) {
1398	<	if (strcmp(var->name,n) == 0) {
1399	<	return (*var->set_attr)(p);
1400	<	}
1401	<	var = var->next;
1402	<	}
1403	<	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
1404	<	return 1;
1405	<	}
1406	<
1407	<	statichere PyTypeObject varlinktype = {
1408	<	PyObject_HEAD_INIT(0)
1409	<	0,
1410	<	(char *)"swigvarlink",                      /* Type name    */
1411	<	sizeof(swig_varlinkobject),         /* Basic size   */
1412	<	0,                                  /* Itemsize     */
1413	<	0,                                  /* Deallocator  */
1414	<	(printfunc) swig_varlink_print,     /* Print        */
1415	<	(getattrfunc) swig_varlink_getattr, /* get attr     */
1416	<	(setattrfunc) swig_varlink_setattr, /* Set attr     */
1417	<	0,                                  /* tp_compare   */
1418	<	(reprfunc) swig_varlink_repr,       /* tp_repr      */
1419	<	0,                                  /* tp_as_number */
1420	<	0,                                  /* tp_as_mapping*/
1421	<	0,                                  /* tp_hash      */
1394	>	SWIGRUNTIME int
1395	>	PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396	>	{
1397	>	void *i = v->ptr;
1398	>	void *j = w->ptr;
1399	>	return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400	>	}
1401	>
1402	>	SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403	>
1404	>	SWIGRUNTIME PyTypeObject*
1405	>	PySwigObject_type(void) {
1406	>	static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407	>	return type;
1408	>	}
1409	>
1410	>	SWIGRUNTIMEINLINE int
1411	>	PySwigObject_Check(PyObject *op) {
1412	>	return ((op)->ob_type == PySwigObject_type())
1413	>	|| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414	>	}
1415	>
1416	>	SWIGRUNTIME PyObject *
1417	>	PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418	>
1419	>	SWIGRUNTIME void
1420	>	PySwigObject_dealloc(PyObject *v)
1421	>	{
1422	>	PySwigObject *sobj = (PySwigObject *) v;
1423	>	PyObject *next = sobj->next;
1424	>	if (sobj->own) {
1425	>	swig_type_info *ty = sobj->ty;
1426	>	PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427	>	PyObject *destroy = data ? data->destroy : 0;
1428	>	if (destroy) {
1429	>	/* destroy is always a VARARGS method */
1430	>	PyObject *res;
1431	>	if (data->delargs) {
1432	>	/* we need to create a temporal object to carry the destroy operation */
1433	>	PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434	>	res = SWIG_Python_CallFunctor(destroy, tmp);
1435	>	Py_DECREF(tmp);
1436	>	} else {
1437	>	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438	>	PyObject *mself = PyCFunction_GET_SELF(destroy);
1439	>	res = ((*meth)(mself, v));
1440	>	}
1441	>	Py_XDECREF(res);
1442	>	} else {
1443	>	const char *name = SWIG_TypePrettyName(ty);
1444	>	#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445	>	printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446	>	#endif
1447	>	}
1448	>	}
1449	>	Py_XDECREF(next);
1450	>	PyObject_DEL(v);
1451	>	}
1452	>
1453	>	SWIGRUNTIME PyObject*
1454	>	PySwigObject_append(PyObject* v, PyObject* next)
1455	>	{
1456	>	PySwigObject *sobj = (PySwigObject *) v;
1457	>	#ifndef METH_O
1458	>	PyObject *tmp = 0;
1459	>	if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460	>	next = tmp;
1461	>	#endif
1462	>	if (!PySwigObject_Check(next)) {
1463	>	return NULL;
1464	>	}
1465	>	sobj->next = next;
1466	>	Py_INCREF(next);
1467	>	return SWIG_Py_Void();
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();
1508	>	}
1509	>
1510	>	SWIGINTERN PyObject*
1511	>	PySwigObject_own(PyObject *v, PyObject *args)
1512	>	{
1513	>	PyObject *val = 0;
1514	>	#if (PY_VERSION_HEX < 0x02020000)
1515	>	if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516	>	#else
1517	>	if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518	>	#endif
1519	>	{
1520	>	return NULL;
1521	>	}
1522	>	else
1523	>	{
1524	>	PySwigObject *sobj = (PySwigObject *)v;
1525	>	PyObject *obj = PyBool_FromLong(sobj->own);
1526	>	if (val) {
1527	>	#ifdef METH_NOARGS
1528	>	if (PyObject_IsTrue(val)) {
1529	>	PySwigObject_acquire(v);
1530	>	} else {
1531	>	PySwigObject_disown(v);
1532	>	}
1533	>	#else
1534	>	if (PyObject_IsTrue(val)) {
1535	>	PySwigObject_acquire(v,args);
1536	>	} else {
1537	>	PySwigObject_disown(v,args);
1538	>	}
1539	>	#endif
1540	>	}
1541	>	return obj;
1542	>	}
1543	>	}
1544	>
1545	>	#ifdef METH_O
1546	>	static PyMethodDef
1547	>	swigobject_methods[] = {
1548	>	{(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1549	>	{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1550	>	{(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551	>	{(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
1552	>	{(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1553	>	{(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1554	>	{0, 0, 0, 0}
1555		};
1556	+	#else
1557	+	static PyMethodDef
1558	+	swigobject_methods[] = {
1559	+	{(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1560	+	{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1561	+	{(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1562	+	{(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1563	+	{(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1564	+	{(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1565	+	{0, 0, 0, 0}
1566	+	};
1567	+	#endif
1568
1569	<	/* Create a variable linking object for use later */
1570	<	SWIGRUNTIME(PyObject *)
1571	<	SWIG_newvarlink(void) {
1572	<	swig_varlinkobject *result = 0;
1573	<	result = PyMem_NEW(swig_varlinkobject,1);
1574	<	varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
1575	<	result->ob_type = &varlinktype;
1576	<	result->vars = 0;
1577	<	result->ob_refcnt = 0;
1578	<	Py_XINCREF((PyObject *) result);
1579	<	return ((PyObject*) result);
1580	<	}
1581	<
1582	<	SWIGRUNTIME(void)
1583	<	SWIG_addvarlink(PyObject *p, char *name,
1584	<	PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
1585	<	swig_varlinkobject *v;
1586	<	swig_globalvar *gv;
1587	<	v= (swig_varlinkobject *) p;
1588	<	gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
1589	<	gv->name = (char *) malloc(strlen(name)+1);
1590	<	strcpy(gv->name,name);
1591	<	gv->get_attr = get_attr;
1592	<	gv->set_attr = set_attr;
1593	<	gv->next = v->vars;
1594	<	v->vars = gv;
1595	<	}
1596	<
1597	<	/* Pack binary data into a string */
1598	<	SWIGRUNTIME(char *)
1599	<	SWIG_PackData(char *c, void *ptr, int sz) {
1600	<	static char hex[17] = "0123456789abcdef";
1601	<	int i;
1602	<	unsigned char *u = (unsigned char *) ptr;
1603	<	register unsigned char uu;
1604	<	for (i = 0; i < sz; i++,u++) {
1605	<	uu = *u;
1606	<	*(c++) = hex[(uu & 0xf0) >> 4];
1607	<	*(c++) = hex[uu & 0xf];
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 c;
1680	>	return &pyswigobject_type;
1681		}
1682
1683	<	/* Unpack binary data from a string */
1684	<	SWIGRUNTIME(char *)
1685	<	SWIG_UnpackData(char *c, void *ptr, int sz) {
1686	<	register unsigned char uu = 0;
1687	<	register int d;
1688	<	unsigned char *u = (unsigned char *) ptr;
1689	<	int i;
1690	<	for (i = 0; i < sz; i++, u++) {
1691	<	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;
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 c;
1693	>	return (PyObject *)sobj;
1694		}
1695
1696	<	/* Convert a pointer value */
1697	<	SWIGRUNTIME(int)
1698	<	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;
1696	>	/* -----------------------------------------------------------------------------
1697	>	* Implements a simple Swig Packed type, and use it instead of string
1698	>	* ----------------------------------------------------------------------------- */
1699
1700	<	if (!obj) return 0;
1701	<	if (obj == Py_None) {
1702	<	*ptr = 0;
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	>	}
1765	>
1766	>	SWIGRUNTIME void
1767	>	PySwigPacked_dealloc(PyObject *v)
1768	>	{
1769	>	if (PySwigPacked_Check(v)) {
1770	>	PySwigPacked *sobj = (PySwigPacked *) v;
1771	>	free(sobj->pack);
1772	>	}
1773	>	PyObject_DEL(v);
1774	>	}
1775	>
1776	>	SWIGRUNTIME PyTypeObject*
1777	>	_PySwigPacked_type(void) {
1778	>	static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779	>	static PyTypeObject pyswigpacked_type;
1780	>	static int type_init = 0;
1781	>	if (!type_init) {
1782	>	const PyTypeObject tmp
1783	>	= {
1784	>	PyObject_HEAD_INIT(NULL)
1785	>	0,                                  /* ob_size */
1786	>	(char *)"PySwigPacked",             /* tp_name */
1787	>	sizeof(PySwigPacked),               /* tp_basicsize */
1788	>	0,                                  /* tp_itemsize */
1789	>	(destructor)PySwigPacked_dealloc,   /* tp_dealloc */
1790	>	(printfunc)PySwigPacked_print,      /* tp_print */
1791	>	(getattrfunc)0,                     /* tp_getattr */
1792	>	(setattrfunc)0,                     /* tp_setattr */
1793	>	(cmpfunc)PySwigPacked_compare,      /* tp_compare */
1794	>	(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;
1842	>	}
1843	>	return &pyswigpacked_type;
1844	>	}
1845	>
1846	>	SWIGRUNTIME PyObject *
1847	>	PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848	>	{
1849	>	PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850	>	if (sobj) {
1851	>	void *pack = malloc(size);
1852	>	if (pack) {
1853	>	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	>	}
1864	>
1865	>	SWIGRUNTIME swig_type_info *
1866	>	PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867	>	{
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 {
1874		return 0;
1875		}
1876	<	#ifdef SWIG_COBJECT_TYPES
1877	<	if (!(PyCObject_Check(obj))) {
1878	<	if (!SWIG_this)
1879	<	SWIG_this = PyString_FromString("this");
1880	<	pyobj = obj;
1881	<	obj = PyObject_GetAttr(obj,SWIG_this);
1882	<	newref = 1;
1883	<	if (!obj) goto type_error;
1884	<	if (!PyCObject_Check(obj)) {
1885	<	Py_DECREF(obj);
1886	<	goto type_error;
1876	>	}
1877	>
1878	>	/* -----------------------------------------------------------------------------
1879	>	* pointers/data manipulation
1880	>	* ----------------------------------------------------------------------------- */
1881	>
1882	>	SWIGRUNTIMEINLINE PyObject *
1883	>	_SWIG_This(void)
1884	>	{
1885	>	return PyString_FromString("this");
1886	>	}
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	>	}
1927		}
460	–	}
461	–	*ptr = PyCObject_AsVoidPtr(obj);
462	–	c = (char *) PyCObject_GetDesc(obj);
463	–	if (newref) Py_DECREF(obj);
464	–	goto cobject;
1928		#else
1929	<	if (!(PyString_Check(obj))) {
1930	<	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)) {
1929	>	obj = PyObject_GetAttr(pyobj,SWIG_This());
1930	>	if (obj) {
1931		Py_DECREF(obj);
475	–	goto type_error;
476	–	}
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;
1932		} else {
1933	<	if (newref) { Py_DECREF(obj); }
1934	<	goto type_error;
1933	>	if (PyErr_Occurred()) PyErr_Clear();
1934	>	return 0;
1935		}
489	–	}
490	–	c++;
491	–	c = SWIG_UnpackData(c,ptr,sizeof(void *));
492	–	if (newref) { Py_DECREF(obj); }
1936		#endif
1937	+	if (obj && !PySwigObject_Check(obj)) {
1938	+	/* a PyObject is called 'this', try to get the 'real this'
1939	+	PySwigObject from it */
1940	+	return SWIG_Python_GetSwigThis(obj);
1941	+	}
1942	+	return (PySwigObject *)obj;
1943	+	}
1944	+	}
1945
1946	<	#ifdef SWIG_COBJECT_TYPES
496	<	cobject:
497	<	#endif
1946	>	/* Acquire a pointer value */
1947
1948	<	if (ty) {
1949	<	tc = SWIG_TypeCheck(c,ty);
1950	<	if (!tc) goto type_error;
1951	<	*ptr = SWIG_TypeCast(tc,(void*) *ptr);
1948	>	SWIGRUNTIME int
1949	>	SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950	>	if (own) {
1951	>	PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952	>	if (sobj) {
1953	>	int oldown = sobj->own;
1954	>	sobj->own = own;
1955	>	return oldown;
1956	>	}
1957		}
1958	+	return 0;
1959	+	}
1960	+
1961	+	/* Convert a pointer value */
1962
1963	<	if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1964	<	PyObject *zero = PyInt_FromLong(0);
1965	<	PyObject_SetAttrString(pyobj,(char*)"thisown",zero);
1966	<	Py_DECREF(zero);
1963	>	SWIGRUNTIME int
1964	>	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	>	}
2038		}
2039	<	return 0;
2039	>	}
2040	>
2041	>	/* Convert a function ptr value */
2042
2043	<	type_error:
2044	<	if (flags & SWIG_POINTER_EXCEPTION) {
2043	>	SWIGRUNTIME int
2044	>	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	>	}
2057		if (ty) {
2058	<	char *temp = (char *) malloc(64+strlen(ty->name));
2059	<	sprintf(temp,"Type error. Expected %s", ty->name);
2060	<	PyErr_SetString(PyExc_TypeError, temp);
518	<	free((char *) temp);
2058	>	swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059	>	if (!tc) return SWIG_ERROR;
2060	>	*ptr = SWIG_TypeCast(tc,vptr);
2061		} else {
2062	<	PyErr_SetString(PyExc_TypeError,"Expected a pointer");
2062	>	*ptr = vptr;
2063		}
2064	+	return SWIG_OK;
2065		}
523	–	return -1;
2066		}
2067
2068		/* Convert a packed value value */
2069	<	SWIGRUNTIME(int)
2070	<	SWIG_ConvertPacked(PyObject *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
2071	<	swig_type_info *tc;
2072	<	char  *c;
2073	<
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);
2069	>
2070	>	SWIGRUNTIME int
2071	>	SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072	>	swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073	>	if (!to) return SWIG_ERROR;
2074		if (ty) {
2075	<	tc = SWIG_TypeCheck(c,ty);
2076	<	if (!tc) goto type_error;
2075	>	if (to != ty) {
2076	>	/* check type cast? */
2077	>	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078	>	if (!tc) return SWIG_ERROR;
2079	>	}
2080		}
2081	<	return 0;
2081	>	return SWIG_OK;
2082	>	}
2083	>
2084	>	/* -----------------------------------------------------------------------------
2085	>	* Create a new pointer object
2086	>	* ----------------------------------------------------------------------------- */
2087
2088	<	type_error:
2088	>	/*
2089	>	Create a new instance object, whitout calling __init__, and set the
2090	>	'this' attribute.
2091	>	*/
2092
2093	<	if (flags) {
2094	<	if (ty) {
2095	<	char *temp = (char *) malloc(64+strlen(ty->name));
2096	<	sprintf(temp,"Type error. Expected %s", ty->name);
2097	<	PyErr_SetString(PyExc_TypeError, temp);
2098	<	free((char *) temp);
2093	>	SWIGRUNTIME PyObject*
2094	>	SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095	>	{
2096	>	#if (PY_VERSION_HEX >= 0x02020000)
2097	>	PyObject *inst = 0;
2098	>	PyObject *newraw = data->newraw;
2099	>	if (newraw) {
2100	>	inst = PyObject_Call(newraw, data->newargs, NULL);
2101	>	if (inst) {
2102	>	#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103	>	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104	>	if (dictptr != NULL) {
2105	>	PyObject *dict = *dictptr;
2106	>	if (dict == NULL) {
2107	>	dict = PyDict_New();
2108	>	*dictptr = dict;
2109	>	PyDict_SetItem(dict, SWIG_This(), swig_this);
2110	>	}
2111	>	}
2112	>	#else
2113	>	PyObject *key = SWIG_This();
2114	>	PyObject_SetAttr(inst, key, swig_this);
2115	>	#endif
2116	>	}
2117	>	} else {
2118	>	PyObject *dict = PyDict_New();
2119	>	PyDict_SetItem(dict, SWIG_This(), swig_this);
2120	>	inst = PyInstance_NewRaw(data->newargs, dict);
2121	>	Py_DECREF(dict);
2122	>	}
2123	>	return inst;
2124	>	#else
2125	>	#if (PY_VERSION_HEX >= 0x02010000)
2126	>	PyObject *inst;
2127	>	PyObject *dict = PyDict_New();
2128	>	PyDict_SetItem(dict, SWIG_This(), swig_this);
2129	>	inst = PyInstance_NewRaw(data->newargs, dict);
2130	>	Py_DECREF(dict);
2131	>	return (PyObject *) inst;
2132	>	#else
2133	>	PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134	>	if (inst == NULL) {
2135	>	return NULL;
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	>	}
2176	>
2177	>
2178	>	SWIGINTERN PyObject *
2179	>	SWIG_Python_InitShadowInstance(PyObject *args) {
2180	>	PyObject *obj[2];
2181	>	if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182	>	return NULL;
2183	>	} else {
2184	>	PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185	>	if (sthis) {
2186	>	PySwigObject_append((PyObject*) sthis, obj[1]);
2187		} else {
2188	<	PyErr_SetString(PyExc_TypeError,"Expected a pointer");
2188	>	SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189		}
2190	+	return SWIG_Py_Void();
2191		}
556	–	return -1;
2192		}
2193
2194		/* Create a new pointer object */
2195	<	SWIGRUNTIME(PyObject *)
2196	<	SWIG_NewPointerObj(void *ptr, swig_type_info *type, int own) {
2197	<	PyObject *robj;
2195	>
2196	>	SWIGRUNTIME PyObject *
2197	>	SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198		if (!ptr) {
2199	<	Py_INCREF(Py_None);
2200	<	return Py_None;
2199	>	return SWIG_Py_Void();
2200	>	} 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;
2212		}
2213	<	#ifdef SWIG_COBJECT_TYPES
2214	<	robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL);
2213	>	}
2214	>
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);
2237		#else
2238	<	{
2239	<	char result[1024];
2240	<	char *r = result;
2241	<	*(r++) = '_';
2242	<	r = SWIG_PackData(r,&ptr,sizeof(void *));
2243	<	strcpy(r,type->name);
2244	<	robj = PyString_FromString(result);
2238	>	type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239	>	(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240	>	if (PyErr_Occurred()) {
2241	>	PyErr_Clear();
2242	>	type_pointer = (void *)0;
2243	>	}
2244	>	#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;
2273	+	}
2274	+	if (PyDict_SetItemString(dict, name, o))
2275	+	return SWIG_ERROR;
2276	+	Py_DECREF(o);
2277	+	return SWIG_OK;
2278	+	}
2279		#endif
2280	<	if (!robj || (robj == Py_None)) return robj;
2281	<	if (type->clientdata) {
2282	<	PyObject *inst;
2283	<	PyObject *args = Py_BuildValue((char*)"(O)", robj);
2284	<	Py_DECREF(robj);
2285	<	inst = PyObject_CallObject((PyObject *) type->clientdata, args);
2286	<	Py_DECREF(args);
2287	<	if (inst) {
2288	<	if (own) {
2289	<	PyObject *n = PyInt_FromLong(1);
2290	<	PyObject_SetAttrString(inst,(char*)"thisown",n);
2291	<	Py_DECREF(n);
591	<	}
592	<	robj = inst;
2280	>
2281	>	SWIGRUNTIME void
2282	>	SWIG_Python_DestroyModule(void *vptr)
2283	>	{
2284	>	swig_module_info *swig_module = (swig_module_info *) vptr;
2285	>	swig_type_info **types = swig_module->types;
2286	>	size_t i;
2287	>	for (i =0; i < swig_module->size; ++i) {
2288	>	swig_type_info *ty = types[i];
2289	>	if (ty->owndata) {
2290	>	PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291	>	if (data) PySwigClientData_Del(data);
2292		}
2293		}
2294	<	return robj;
2294	>	Py_DECREF(SWIG_This());
2295		}
2296
2297	<	SWIGRUNTIME(PyObject *)
2298	<	SWIG_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
2299	<	char result[1024];
2300	<	char *r = result;
2301	<	if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
2302	<	*(r++) = '_';
2303	<	r = SWIG_PackData(r,ptr,sz);
2304	<	strcpy(r,type->name);
2305	<	return PyString_FromString(result);
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	<	/* Install Constants */
2312	<	SWIGRUNTIME(void)
2313	<	SWIG_InstallConstants(PyObject *d, swig_const_info constants[]) {
2314	<	int i;
2315	<	PyObject *obj;
2316	<	for (i = 0; constants[i].type; i++) {
2317	<	switch(constants[i].type) {
2318	<	case SWIG_PY_INT:
2319	<	obj = PyInt_FromLong(constants[i].lvalue);
2320	<	break;
2321	<	case SWIG_PY_FLOAT:
2322	<	obj = PyFloat_FromDouble(constants[i].dvalue);
2323	<	break;
2324	<	case SWIG_PY_STRING:
2325	<	obj = PyString_FromString((char *) constants[i].pvalue);
2326	<	break;
2327	<	case SWIG_PY_POINTER:
2328	<	obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
2329	<	break;
2330	<	case SWIG_PY_BINARY:
2331	<	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
2332	<	break;
631	<	default:
632	<	obj = 0;
633	<	break;
634	<	}
635	<	if (obj) {
636	<	PyDict_SetItemString(d,constants[i].name,obj);
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);
2363	+	}
2364	+	Py_DECREF(old_str);
2365	+	}
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;
2382	+	}
2383	+	}
2384	+
2385	+	SWIGRUNTIMEINLINE const char *
2386	+	PySwigObject_GetDesc(PyObject *self)
2387	+	{
2388	+	PySwigObject *v = (PySwigObject *)self;
2389	+	swig_type_info *ty = v ? v->ty : 0;
2390	+	return ty ? ty->str : (char*)"";
2391	+	}
2392	+
2393	+	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	+	}
2427	+	}
2428	+
2429	+
2430	+	/* Convert a pointer value, signal an exception on a type mismatch */
2431	+	SWIGRUNTIME void *
2432	+	SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433	+	void *result;
2434	+	if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435	+	PyErr_Clear();
2436	+	if (flags & SWIG_POINTER_EXCEPTION) {
2437	+	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438	+	SWIG_Python_ArgFail(argnum);
2439	+	}
2440	+	}
2441	+	return result;
2442		}
2443
642	–	#endif
2444
2445		#ifdef __cplusplus
2446	+	#if 0
2447	+	{ /* cc-mode */
2448	+	#endif
2449		}
2450		#endif
2451
2452
2453
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
2457
2458
2459
2460	+	#define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2461
2462
2463		/* -------- TYPES TABLE (BEGIN) -------- */
2464
2465	<	#define  SWIGTYPE_p_XMLDoc swig_types[0]
2466	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[1]
2467	<	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[2]
2468	<	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[3]
2469	<	#define  SWIGTYPE_p_BossTask swig_types[4]
2470	<	#define  SWIGTYPE_p_BossTaskException swig_types[5]
2471	<	#define  SWIGTYPE_p_std__ostream swig_types[6]
2472	<	#define  SWIGTYPE_p_BossAttributeContainer swig_types[7]
2473	<	#define  SWIGTYPE_p_printOption swig_types[8]
2474	<	#define  SWIGTYPE_p_BossJob swig_types[9]
2475	<	#define  SWIGTYPE_p_BossDatabase swig_types[10]
2476	<	#define  SWIGTYPE_p_BossSession swig_types[11]
2477	<	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[12]
2478	<	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[13]
2479	<	#define  SWIGTYPE_p_BossAdministratorSession swig_types[14]
2480	<	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[15]
2481	<	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[16]
2482	<	#define  SWIGTYPE_p_jobStates swig_types[17]
2483	<	static swig_type_info *swig_types[19];
2465	>	#define SWIGTYPE_p_BossAdministratorSession swig_types[0]
2466	>	#define SWIGTYPE_p_BossAttributeContainer swig_types[1]
2467	>	#define SWIGTYPE_p_BossDatabase swig_types[2]
2468	>	#define SWIGTYPE_p_BossJob swig_types[3]
2469	>	#define SWIGTYPE_p_BossSession swig_types[4]
2470	>	#define SWIGTYPE_p_BossTask swig_types[5]
2471	>	#define SWIGTYPE_p_BossTaskException swig_types[6]
2472	>	#define SWIGTYPE_p_XMLDoc swig_types[7]
2473	>	#define SWIGTYPE_p_allocator_type swig_types[8]
2474	>	#define SWIGTYPE_p_char swig_types[9]
2475	>	#define SWIGTYPE_p_difference_type swig_types[10]
2476	>	#define SWIGTYPE_p_job_iterator swig_types[11]
2477	>	#define SWIGTYPE_p_key_type swig_types[12]
2478	>	#define SWIGTYPE_p_mapped_type swig_types[13]
2479	>	#define SWIGTYPE_p_p_PyObject swig_types[14]
2480	>	#define SWIGTYPE_p_size_type swig_types[15]
2481	>	#define SWIGTYPE_p_std__exception swig_types[16]
2482	>	#define SWIGTYPE_p_std__invalid_argument swig_types[17]
2483	>	#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]
2484	>	#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)
2499
2500		/* -------- TYPES TABLE (END) -------- */
2501
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
2507
2508		/*-----------------------------------------------
2509		@(target):= _BossSession.so
#	Line 684 | Line 2512 | static swig_type_info *swig_types[19];
2512
2513		#define SWIG_name    "_BossSession"
2514
2515	<	#define  SWIG_MemoryError    1
688	<	#define  SWIG_IOError        2
689	<	#define  SWIG_RuntimeError   3
690	<	#define  SWIG_IndexError     4
691	<	#define  SWIG_TypeError      5
692	<	#define  SWIG_DivisionByZero 6
693	<	#define  SWIG_OverflowError  7
694	<	#define  SWIG_SyntaxError    8
695	<	#define  SWIG_ValueError     9
696	<	#define  SWIG_SystemError   10
697	<	#define  SWIG_UnknownError  99
2515	>	#define SWIGVERSION 0x010329
2516
2517
2518	<	static void _SWIG_exception(int code, const char *msg) {
2519	<	switch(code) {
2520	<	case SWIG_MemoryError:
2521	<	PyErr_SetString(PyExc_MemoryError,msg);
2522	<	break;
2523	<	case SWIG_IOError:
2524	<	PyErr_SetString(PyExc_IOError,msg);
2525	<	break;
2526	<	case SWIG_RuntimeError:
2527	<	PyErr_SetString(PyExc_RuntimeError,msg);
2528	<	break;
2529	<	case SWIG_IndexError:
2530	<	PyErr_SetString(PyExc_IndexError,msg);
2531	<	break;
2532	<	case SWIG_TypeError:
2533	<	PyErr_SetString(PyExc_TypeError,msg);
2534	<	break;
2535	<	case SWIG_DivisionByZero:
2536	<	PyErr_SetString(PyExc_ZeroDivisionError,msg);
2537	<	break;
2538	<	case SWIG_OverflowError:
2539	<	PyErr_SetString(PyExc_OverflowError,msg);
2540	<	break;
2541	<	case SWIG_SyntaxError:
2542	<	PyErr_SetString(PyExc_SyntaxError,msg);
2543	<	break;
2544	<	case SWIG_ValueError:
2545	<	PyErr_SetString(PyExc_ValueError,msg);
2546	<	break;
2547	<	case SWIG_SystemError:
2548	<	PyErr_SetString(PyExc_SystemError,msg);
2549	<	break;
2550	<	default:
2551	<	PyErr_SetString(PyExc_RuntimeError,msg);
2552	<	break;
2553	<	}
2518	>	#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2519	>	#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2520	>
2521	>
2522	>	#include <stdexcept>
2523	>
2524	>
2525	>	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	>	}
2569	>
2570	>
2571	>	namespace swig {
2572	>	struct PyObject_var : PyObject_ptr {
2573	>	PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2574	>
2575	>	PyObject_var & operator = (PyObject* obj)
2576	>	{
2577	>	Py_XDECREF(_obj);
2578	>	_obj = obj;
2579	>	return *this;
2580	>	}
2581	>	};
2582		}
2583
2584	<	#define SWIG_exception(a,b) { _SWIG_exception(a,b); SWIG_fail; }
2584	>
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	>
2602
2603
2604		#include <string>
2605	+	#include <stdexcept>
2606
2607
2608		#include <string>
2609
2610	<	PyObject* SwigInt_FromBool(bool b) {
2611	<	return PyInt_FromLong(b ? 1L : 0L);
2610	>
2611	>	#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	<	double SwigNumber_Check(PyObject* o) {
2721	<	return PyFloat_Check(o) || PyInt_Check(o) || PyLong_Check(o);
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	<	double SwigNumber_AsDouble(PyObject* o) {
2765	<	return PyFloat_Check(o) ? PyFloat_AsDouble(o)
2766	<	: (PyInt_Check(o) ?   double(PyInt_AsLong(o))
2767	<	: double(PyLong_AsLong(o)));
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	<	PyObject* SwigString_FromString(const std::string& s) {
2801	<	return PyString_FromStringAndSize(s.data(),s.size());
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	<	std::string SwigString_AsString(PyObject* o) {
2845	<	return std::string(PyString_AsString(o));
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;
2853	>	}
2854	>
2855	>
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));
2863	>	}
2864	>
2865	>
2866	>	SWIGINTERNINLINE PyObject*
2867	>	SWIG_From_bool  (bool value)
2868	>	{
2869	>	return PyBool_FromLong(value ? 1 : 0);
2870	>	}
2871	>
2872	>
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;
2909	>	}
2910	>
2911	>
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;
2919		}
2920
2921
765	–	#include <vector>
766	–	#include <algorithm>
2922		#include <stdexcept>
2923
2924
2925	+	#include <algorithm>
2926	+
2927	+
2928	+	#include <vector>
2929	+
2930	+
2931	+	#include <utility>
2932	+
2933	+
2934		#include <map>
2935		#include <algorithm>
2936		#include <stdexcept>
2937
2938	<	bool std_maplstd_stringcstd_string_g___nonzero_____(std::map<std::string,std::string > *self){
2939	<	return !(self->empty());
2940	<	}
2941	<	std::string std_maplstd_stringcstd_string_g___getitem_____(std::map<std::string,std::string > *self,std::string key){
2942	<	std::map<std::string,std::string >::iterator i = self->find(key);
2943	<	if (i != self->end())
2944	<	return i->second;
2945	<	else
2946	<	throw std::out_of_range("key not found");
2947	<	}
2948	<	void std_maplstd_stringcstd_string_g___setitem_____(std::map<std::string,std::string > *self,std::string key,std::string x){
2949	<	(*self)[key] = x;
2950	<	}
2951	<	void std_maplstd_stringcstd_string_g___delitem_____(std::map<std::string,std::string > *self,std::string key){
2952	<	std::map<std::string,std::string >::iterator i = self->find(key);
2953	<	if (i != self->end())
2954	<	self->erase(i);
2955	<	else
2956	<	throw std::out_of_range("key not found");
2957	<	}
2958	<	bool std_maplstd_stringcstd_string_g_has_key___(std::map<std::string,std::string > *self,std::string key){
2959	<	std::map<std::string,std::string >::iterator i = self->find(key);
2960	<	return i != self->end();
2961	<	}
2962	<	PyObject *std_maplstd_stringcstd_string_g_keys___(std::map<std::string,std::string > *self){
2963	<	PyObject* keyList = PyList_New(self->size());
2964	<	std::map<std::string,std::string >::iterator i;
2965	<	unsigned int j;
2966	<	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
2967	<	PyList_SetItem(keyList,j,
2968	<	SwigString_FromString(i->first));
2969	<	}
2970	<	return keyList;
2971	<	}
2972	<	PyObject *std_maplstd_stringcstd_string_g_values___(std::map<std::string,std::string > *self){
2973	<	PyObject* valueList = PyList_New(self->size());
2974	<	std::map<std::string,std::string >::iterator i;
2975	<	unsigned int j;
2976	<	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
2977	<	PyList_SetItem(valueList,j,
2978	<	SwigString_FromString(i->second));
2979	<	}
2980	<	return valueList;
2981	<	}
2982	<	PyObject *std_maplstd_stringcstd_string_g_items___(std::map<std::string,std::string > *self){
2983	<	PyObject* itemList = PyList_New(self->size());
2984	<	std::map<std::string,std::string >::iterator i;
2985	<	unsigned int j;
2986	<	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
2987	<	PyObject* item = PyTuple_New(2);
2988	<	PyTuple_SetItem(item,0,
2989	<	SwigString_FromString(i->first));
2990	<	PyTuple_SetItem(item,1,
2991	<	SwigString_FromString(i->second));
2992	<	PyList_SetItem(itemList,j,item);
2993	<	}
2994	<	return itemList;
2995	<	}
2996	<	bool std_maplstd_stringcstd_string_g___contains_____(std::map<std::string,std::string > *self,std::string key){
2997	<	std::map<std::string,std::string >::iterator i = self->find(key);
2998	<	return i != self->end();
2999	<	}
3000	<	PyObject *std_maplstd_stringcstd_string_g___iter_____(std::map<std::string,std::string > *self){
3001	<	#if PY_VERSION_HEX >= 0x02020000
3002	<	PyObject* keyList = PyList_New(self->size());
3003	<	std::map<std::string,std::string >::iterator i;
3004	<	unsigned int j;
3005	<	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
3006	<	PyList_SetItem(keyList,j,
3007	<	SwigString_FromString(i->first));
3008	<	}
3009	<	PyObject* iter = PyObject_GetIter(keyList);
3010	<	Py_DECREF(keyList);
3011	<	return iter;
3012	<	#else
3013	<	throw std::runtime_error("Python 2.2 or later is needed"
3014	<	" for iterator support");
3015	<	#endif
3016	<	}
2938	>
2939	>	namespace swig {
2940	>	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
4480		#include "BossSession.h"
4481		#include "BossAdministratorSession.h"
#	Line 862 | Line 4488 | PyObject *std_maplstd_stringcstd_string_
4488		#include "BossProgramExec.h"
4489		#include "BossDatabase.h"
4490
4491	<	PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
4491	>
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){
4545		PyObject *  my_list = PyList_New( my_vec.size());
4546		unsigned int index = 0;
4547		for ( std::vector<std::string>::const_iterator it = my_vec.begin ();
#	Line 871 | Line 4550 | PyObject *BossSession_show(BossSession *
4550		}
4551		return my_list;
4552		}
4553	<	PyObject *BossSession_showCHTools__SWIG_1(BossSession *self){
4553	>	SWIGINTERN PyObject *BossSession_CHTools(BossSession *self){
4554		std::vector<std::string> my_vec = self->showCHTools();
4555		return BossSession_show( self, my_vec );
4556		}
4557	<	PyObject *BossSession_showProgramTypes__SWIG_1(BossSession *self){
4557	>	SWIGINTERN PyObject *BossSession_ProgramTypes(BossSession *self){
4558		std::vector<std::string> my_vec = self->showProgramTypes();
4559		return BossSession_show( self, my_vec );
4560		}
4561	<	PyObject *BossSession_showRTMon__SWIG_1(BossSession *self){
4561	>	SWIGINTERN PyObject *BossSession_RTMons(BossSession *self){
4562		std::vector<std::string> my_vec = self->showRTMon();
4563		return BossSession_show( self, my_vec );
4564		}
4565	<	PyObject *BossSession_showSchedulers__SWIG_1(BossSession *self){
4565	>	SWIGINTERN PyObject *BossSession_schedulers(BossSession *self){
4566		std::vector<std::string> my_vec = self->showSchedulers();
4567		return BossSession_show( self, my_vec );
4568		}
4569	<	PyObject *BossSession_listMatch__SWIG_1(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
4569	>	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){
4570		std::vector<std::string> my_vec = self->listMatch( scheduler,
4571		schclassad,
4572		keepfile,
#	Line 895 | Line 4574 | PyObject *BossSession_listMatch__SWIG_1(
4574		jobid);
4575		return BossSession_show( self, my_vec );
4576		}
4577	<	PyObject *BossSession_queryTasks(BossSession *self,int filter_opt,std::string const &taskRange,std::string const &jobRange,std::string const &subn,std::string type,std::string user,std::string after,std::string before,bool avoidCheck){
4577	>	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){
4578		if ( !avoidCheck ) {
4579		self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
4580		type, user, after, before);
#	Line 916 | Line 4595 | PyObject *BossSession_queryTasks(BossSes
4595		//       }
4596		return  job_dict;
4597		}
4598	<	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
4598	>
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){
4625		std::string tmp;
4626		BossAttributeContainer::const_iterator it_end = obj.end ();
4627		for (BossAttributeContainer::const_iterator it = obj.begin ();
#	Line 931 | Line 4636 | PyObject *BossTask_appendToPyDict(BossTa
4636		}
4637		return dict;
4638		}
4639	<	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
4639	>	SWIGINTERN PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator &jit){
4640
4641		PyObject * job_dict = PyDict_New();
4642		std::string tmp;
#	Line 953 | Line 4658 | PyObject *BossTask_jobDict(BossTask cons
4658		}
4659		return job_dict;
4660		}
4661	<	PyObject *BossTask_jobsMap__SWIG_1(BossTask const *self){
4661	>	SWIGINTERN PyObject *BossTask_jobsDict(BossTask const *self){
4662
4663		PyObject * job_dict = PyDict_New();
4664		for (BossTask::job_iterator jit = self->job_begin ();
#	Line 965 | Line 4670 | PyObject *BossTask_jobsMap__SWIG_1(BossT
4670		}
4671		return job_dict;
4672		}
4673	<	PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator &programs_it){
4673	>	SWIGINTERN PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >::const_iterator &programs_it){
4674
4675		PyObject * job_dict = PyDict_New();
4676
#	Line 989 | Line 4694 | PyObject *BossTask_progDict(BossTask con
4694		}
4695		return job_dict;
4696		}
4697	<	PyObject *BossTask_jobPrograms(BossTask const *self,std::string const &jobid){
4697	>	SWIGINTERN PyObject *BossTask_jobPrograms(BossTask const *self,std::string const &jobid){
4698
4699		const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
4700		std::map< std::string, std::map< std::string, std::string > > ret_val;
#	Line 1015 | Line 4720 | PyObject *BossTask_jobPrograms(BossTask
4720		#ifdef __cplusplus
4721		extern "C" {
4722		#endif
4723	<	static PyObject *_wrap_new_objectMap__SWIG_0(PyObject *self, PyObject *args) {
4724	<	PyObject *resultobj;
4725	<	std::map<std::string,std::string > *result;
4726	<
4727	<	if(!PyArg_ParseTuple(args,(char *)":new_objectMap")) goto fail;
4728	<	{
4729	<	try {
4730	<	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
4731	<
4732	<	}catch (const std::exception& e) {
4733	<	SWIG_exception(SWIG_RuntimeError, e.what());
4723	>	SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4724	>	PyObject *resultobj = 0;
4725	>	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4726	>	void *argp1 = 0 ;
4727	>	int res1 = 0 ;
4728	>	PyObject * obj0 = 0 ;
4729	>
4730	>	if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
4731	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
4732	>	if (!SWIG_IsOK(res1)) {
4733	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4734	>	}
4735	>	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4736	>	{
4737	>	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;
4775		}
4776	+	}
4777	+
4778	+	} catch (const std::exception& e) {
4779	+	SWIG_exception(SWIG_RuntimeError, e.what());
4780		}
4781	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
4782	<	return resultobj;
4783	<	fail:
4784	<	return NULL;
4781	>	}
4782	>	resultobj = result;
4783	>	return resultobj;
4784	>	fail:
4785	>	return NULL;
4786		}
4787
4788
4789	<	static PyObject *_wrap_new_objectMap__SWIG_1(PyObject *self, PyObject *args) {
4790	<	PyObject *resultobj;
4791	<	std::map<std::string,std::string > *arg1 = 0 ;
4792	<	std::map<std::string,std::string > *result;
4793	<	std::map<std::string,std::string > temp1 ;
4794	<	std::map<std::string,std::string > *m1 ;
4795	<	PyObject * obj0 = 0 ;
4796	<
4797	<	if(!PyArg_ParseTuple(args,(char *)"O:new_objectMap",&obj0)) goto fail;
4798	<	{
4799	<	if (PyDict_Check(obj0)) {
4800	<	PyObject* items = PyMapping_Items(obj0);
4801	<	unsigned int size = PyList_Size(items);
4802	<	temp1 = std::map<std::string,std::string >();
4803	<	arg1 = &temp1;
4804	<	for (unsigned int i=0; i<size; i++) {
4805	<	PyObject* pair = PySequence_GetItem(items,i);
4806	<	PyObject* key = PySequence_GetItem(pair,0);
4807	<	PyObject* o = PySequence_GetItem(pair,1);
4808	<	if (PyString_Check(key) && PyString_Check(o)) {
4809	<	temp1[SwigString_AsString(key)] = SwigString_AsString(o);
4810	<	Py_DECREF(key);
4811	<	Py_DECREF(o);
4812	<	Py_DECREF(pair);
4813	<	}else {
4814	<	Py_DECREF(key);
4815	<	Py_DECREF(o);
4816	<	Py_DECREF(pair);
4817	<	Py_DECREF(items);
4818	<	PyErr_SetString(PyExc_TypeError,
4819	<	"map<""std::string"",""std::string""> expected");
4820	<	SWIG_fail;
4821	<	}
1071	<	}
1072	<	Py_DECREF(items);
1073	<	}else if (SWIG_ConvertPtr(obj0,(void **) &m1,
1074	<	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
1075	<	arg1 = m1;
1076	<	}else {
1077	<	PyErr_SetString(PyExc_TypeError,
1078	<	"map<""std::string"",""std::string""> expected");
1079	<	SWIG_fail;
4789	>	SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4790	>	PyObject *resultobj = 0;
4791	>	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4792	>	size_t arg2 ;
4793	>	swig::PySwigIterator *result = 0 ;
4794	>	void *argp1 = 0 ;
4795	>	int res1 = 0 ;
4796	>	size_t val2 ;
4797	>	int ecode2 = 0 ;
4798	>	PyObject * obj0 = 0 ;
4799	>	PyObject * obj1 = 0 ;
4800	>
4801	>	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
4802	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4803	>	if (!SWIG_IsOK(res1)) {
4804	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4805	>	}
4806	>	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4807	>	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
4808	>	if (!SWIG_IsOK(ecode2)) {
4809	>	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
4810	>	}
4811	>	arg2 = static_cast< size_t >(val2);
4812	>	{
4813	>	try {
4814	>	try {
4815	>	result = (swig::PySwigIterator *)(arg1)->incr(arg2);
4816	>	}
4817	>	catch(swig::stop_iteration &_e) {
4818	>	{
4819	>	(void)_e;
4820	>	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4821	>	SWIG_fail;
4822		}
4823	+	}
4824	+
4825	+	} catch (const std::exception& e) {
4826	+	SWIG_exception(SWIG_RuntimeError, e.what());
4827		}
4828	<	{
4829	<	try {
4830	<	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
4831	<
4832	<	}catch (const std::exception& e) {
4833	<	SWIG_exception(SWIG_RuntimeError, e.what());
4828	>	}
4829	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4830	>	return resultobj;
4831	>	fail:
4832	>	return NULL;
4833	>	}
4834	>
4835	>
4836	>	SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4837	>	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;
4860		}
4861	+	}
4862	+
4863	+	} catch (const std::exception& e) {
4864	+	SWIG_exception(SWIG_RuntimeError, e.what());
4865		}
4866	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
4867	<	return resultobj;
4868	<	fail:
4869	<	return NULL;
4866	>	}
4867	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4868	>	return resultobj;
4869	>	fail:
4870	>	return NULL;
4871		}
4872
4873
4874	<	static PyObject *_wrap_new_objectMap(PyObject *self, PyObject *args) {
4875	<	int argc;
4876	<	PyObject *argv[2];
4877	<	int ii;
4878	<
4879	<	argc = PyObject_Length(args);
4880	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
4881	<	argv[ii] = PyTuple_GetItem(args,ii);
4874	>	SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
4875	>	int argc;
4876	>	PyObject *argv[3];
4877	>	int ii;
4878	>
4879	>	if (!PyTuple_Check(args)) SWIG_fail;
4880	>	argc = PyObject_Length(args);
4881	>	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);
4891		}
4892	<	if (argc == 0) {
4893	<	return _wrap_new_objectMap__SWIG_0(self,args);
4892	>	}
4893	>	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	>	}
4906		}
4907	<	if (argc == 1) {
4908	<	int _v;
4907	>	}
4908	>
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	<	/* native sequence? */
4946	<	if (PyDict_Check(argv[0])) {
4947	<	PyObject* items = PyMapping_Items(argv[0]);
1115	<	unsigned int size = PyList_Size(items);
1116	<	if (size == 0) {
1117	<	/* an empty dictionary can be of any type */
1118	<	_v = 1;
1119	<	}else {
1120	<	/* check the first element only */
1121	<	PyObject* pair = PySequence_GetItem(items,0);
1122	<	PyObject* key = PySequence_GetItem(pair,0);
1123	<	PyObject* o = PySequence_GetItem(pair,1);
1124	<	if (PyString_Check(key) && PyString_Check(o))
1125	<	_v = 1;
1126	<	else
1127	<	_v = 0;
1128	<	Py_DECREF(key);
1129	<	Py_DECREF(o);
1130	<	Py_DECREF(pair);
1131	<	}
1132	<	Py_DECREF(items);
1133	<	}else {
1134	<	/* wrapped map? */
1135	<	std::map<std::string,std::string >* m;
1136	<	if (SWIG_ConvertPtr(argv[0],(void **) &m,
1137	<	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1)
1138	<	_v = 1;
1139	<	else
1140	<	_v = 0;
1141	<	}
4945	>	(void)_e;
4946	>	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4947	>	SWIG_fail;
4948		}
4949	<	if (_v) {
4950	<	return _wrap_new_objectMap__SWIG_1(self,args);
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) {
4982	>	{
4983	>	(void)_e;
4984	>	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4985	>	SWIG_fail;
4986		}
4987	+	}
4988	+
4989	+	} catch (const std::exception& e) {
4990	+	SWIG_exception(SWIG_RuntimeError, e.what());
4991		}
4992	<
4993	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_objectMap'");
4994	<	return NULL;
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	<	static PyObject *_wrap_objectMap___len__(PyObject *self, PyObject *args) {
5001	<	PyObject *resultobj;
5002	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5003	<	unsigned int result;
5004	<	std::map<std::string,std::string > temp1 ;
5005	<	std::map<std::string,std::string > *m1 ;
5006	<	PyObject * obj0 = 0 ;
5007	<
5008	<	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___len__",&obj0)) goto fail;
5009	<	{
5010	<	if (PyDict_Check(obj0)) {
5011	<	PyObject* items = PyMapping_Items(obj0);
5012	<	unsigned int size = PyList_Size(items);
5013	<	temp1 = std::map<std::string,std::string >();
5014	<	arg1 = &temp1;
5015	<	for (unsigned int i=0; i<size; i++) {
5016	<	PyObject* pair = PySequence_GetItem(items,i);
5017	<	PyObject* key = PySequence_GetItem(pair,0);
5018	<	PyObject* o = PySequence_GetItem(pair,1);
5019	<	if (PyString_Check(key) && PyString_Check(o)) {
5020	<	temp1[SwigString_AsString(key)] = SwigString_AsString(o);
5021	<	Py_DECREF(key);
5022	<	Py_DECREF(o);
5023	<	Py_DECREF(pair);
5024	<	}else {
5025	<	Py_DECREF(key);
5026	<	Py_DECREF(o);
5027	<	Py_DECREF(pair);
5028	<	Py_DECREF(items);
5029	<	PyErr_SetString(PyExc_TypeError,
5030	<	"map<""std::string"",""std::string""> expected");
5031	<	SWIG_fail;
5032	<	}
5033	<	}
5034	<	Py_DECREF(items);
5035	<	}else if (SWIG_ConvertPtr(obj0,(void **) &m1,
5036	<	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
5037	<	arg1 = m1;
5038	<	}else {
5039	<	PyErr_SetString(PyExc_TypeError,
5040	<	"map<""std::string"",""std::string""> expected");
5041	<	SWIG_fail;
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;
5185		}
5186	+	}
5187	+
5188	+	} catch (const std::exception& e) {
5189	+	SWIG_exception(SWIG_RuntimeError, e.what());
5190		}
5191	<	{
5192	<	try {
5193	<	result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
5194	<
5195	<	}catch (const std::exception& e) {
5196	<	SWIG_exception(SWIG_RuntimeError, e.what());
5191	>	}
5192	>	resultobj = result;
5193	>	return resultobj;
5194	>	fail:
5195	>	return NULL;
5196	>	}
5197	>
5198	>
5199	>	SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5200	>	PyObject *resultobj = 0;
5201	>	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5202	>	PyObject *result = 0 ;
5203	>	void *argp1 = 0 ;
5204	>	int res1 = 0 ;
5205	>	PyObject * obj0 = 0 ;
5206	>
5207	>	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
5208	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5209	>	if (!SWIG_IsOK(res1)) {
5210	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5211	>	}
5212	>	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5213	>	{
5214	>	try {
5215	>	try {
5216	>	result = (PyObject *)(arg1)->previous();
5217	>	}
5218	>	catch(swig::stop_iteration &_e) {
5219	>	{
5220	>	(void)_e;
5221	>	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5222	>	SWIG_fail;
5223		}
5224	+	}
5225	+
5226	+	} catch (const std::exception& e) {
5227	+	SWIG_exception(SWIG_RuntimeError, e.what());
5228		}
5229	<	resultobj = PyInt_FromLong((long)result);
5230	<	return resultobj;
5231	<	fail:
5232	<	return NULL;
5229	>	}
5230	>	resultobj = result;
5231	>	return resultobj;
5232	>	fail:
5233	>	return NULL;
5234		}
5235
5236
5237	<	static PyObject *_wrap_objectMap_clear(PyObject *self, PyObject *args) {
5238	<	PyObject *resultobj;
5239	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5240	<	PyObject * obj0 = 0 ;
5241	<
5242	<	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_clear",&obj0)) goto fail;
5243	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5244	<	{
5245	<	try {
5246	<	(arg1)->clear();
5247	<
5248	<	}catch (const std::exception& e) {
5249	<	SWIG_exception(SWIG_RuntimeError, e.what());
5237	>	SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5238	>	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;
5270		}
5271	+	}
5272	+
5273	+	} catch (const std::exception& e) {
5274	+	SWIG_exception(SWIG_RuntimeError, e.what());
5275		}
5276	<	Py_INCREF(Py_None); resultobj = Py_None;
5277	<	return resultobj;
5278	<	fail:
5279	<	return NULL;
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	<	static PyObject *_wrap_objectMap___nonzero__(PyObject *self, PyObject *args) {
5285	<	PyObject *resultobj;
5286	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5287	<	bool result;
5288	<	PyObject * obj0 = 0 ;
5289	<
5290	<	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___nonzero__",&obj0)) goto fail;
5291	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5292	<	{
5293	<	try {
5294	<	result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
5295	<
5296	<	}catch (const std::exception& e) {
5297	<	SWIG_exception(SWIG_RuntimeError, e.what());
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());
5355	>	}
5356	>	}
5357	>	resultobj = SWIG_From_bool(static_cast< bool >(result));
5358	>	return resultobj;
5359	>	fail:
5360	>	return NULL;
5361	>	}
5362	>
5363	>
5364	>	SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5365	>	PyObject *resultobj = 0;
5366	>	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5367	>	ptrdiff_t arg2 ;
5368	>	swig::PySwigIterator *result = 0 ;
5369	>	void *argp1 = 0 ;
5370	>	int res1 = 0 ;
5371	>	ptrdiff_t val2 ;
5372	>	int ecode2 = 0 ;
5373	>	PyObject * obj0 = 0 ;
5374	>	PyObject * obj1 = 0 ;
5375	>
5376	>	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
5377	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
5378	>	if (!SWIG_IsOK(res1)) {
5379	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5380	>	}
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;
5400		}
5401	+	}
5402	+
5403	+	} catch (const std::exception& e) {
5404	+	SWIG_exception(SWIG_RuntimeError, e.what());
5405		}
5406	<	resultobj = PyInt_FromLong((long)result);
5407	<	return resultobj;
5408	<	fail:
5409	<	return NULL;
5406	>	}
5407	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5408	>	return resultobj;
5409	>	fail:
5410	>	return NULL;
5411		}
5412
5413
5414	<	static PyObject *_wrap_objectMap___getitem__(PyObject *self, PyObject *args) {
5415	<	PyObject *resultobj;
5416	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5417	<	std::string arg2 ;
5418	<	std::string result;
5419	<	PyObject * obj0 = 0 ;
5420	<	PyObject * obj1 = 0 ;
5421	<
5422	<	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___getitem__",&obj0,&obj1)) goto fail;
5423	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5424	<	{
5425	<	if (PyString_Check(obj1))
5426	<	arg2 = std::string(PyString_AsString(obj1));
5427	<	else
5428	<	SWIG_exception(SWIG_TypeError, "string expected");
5414	>	SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5415	>	PyObject *resultobj = 0;
5416	>	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5417	>	ptrdiff_t arg2 ;
5418	>	swig::PySwigIterator *result = 0 ;
5419	>	void *argp1 = 0 ;
5420	>	int res1 = 0 ;
5421	>	ptrdiff_t val2 ;
5422	>	int ecode2 = 0 ;
5423	>	PyObject * obj0 = 0 ;
5424	>	PyObject * obj1 = 0 ;
5425	>
5426	>	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
5427	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
5428	>	if (!SWIG_IsOK(res1)) {
5429	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5430	>	}
5431	>	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;
5450	>	}
5451	>	}
5452	>
5453	>	} catch (const std::exception& e) {
5454	>	SWIG_exception(SWIG_RuntimeError, e.what());
5455		}
5456	<	{
5457	<	try {
5458	<	result = std_maplstd_stringcstd_string_g___getitem_____(arg1,arg2);
5459	<
5460	<	}catch (std::out_of_range& e) {
5461	<	PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
5462	<	SWIG_fail;
5456	>	}
5457	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5458	>	return resultobj;
5459	>	fail:
5460	>	return NULL;
5461	>	}
5462	>
5463	>
5464	>	SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5465	>	PyObject *resultobj = 0;
5466	>	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5467	>	ptrdiff_t arg2 ;
5468	>	swig::PySwigIterator *result = 0 ;
5469	>	void *argp1 = 0 ;
5470	>	int res1 = 0 ;
5471	>	ptrdiff_t val2 ;
5472	>	int ecode2 = 0 ;
5473	>	PyObject * obj0 = 0 ;
5474	>	PyObject * obj1 = 0 ;
5475	>
5476	>	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
5477	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5478	>	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());
5502		}
5503	<	{
5504	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5503	>	}
5504	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5505	>	return resultobj;
5506	>	fail:
5507	>	return NULL;
5508	>	}
5509	>
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;
5544	>	}
5545	>	}
5546	>
5547	>	} catch (const std::exception& e) {
5548	>	SWIG_exception(SWIG_RuntimeError, e.what());
5549		}
5550	<	return resultobj;
5551	<	fail:
5552	<	return NULL;
5550	>	}
5551	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5552	>	return resultobj;
5553	>	fail:
5554	>	return NULL;
5555		}
5556
5557
5558	<	static PyObject *_wrap_objectMap___setitem__(PyObject *self, PyObject *args) {
5559	<	PyObject *resultobj;
5560	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5561	<	std::string arg2 ;
5562	<	std::string arg3 ;
5563	<	PyObject * obj0 = 0 ;
5564	<	PyObject * obj1 = 0 ;
5565	<	PyObject * obj2 = 0 ;
5566	<
5567	<	if(!PyArg_ParseTuple(args,(char *)"OOO:objectMap___setitem__",&obj0,&obj1,&obj2)) goto fail;
5568	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5569	<	{
5570	<	if (PyString_Check(obj1))
5571	<	arg2 = std::string(PyString_AsString(obj1));
5572	<	else
5573	<	SWIG_exception(SWIG_TypeError, "string expected");
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	<	if (PyString_Check(obj2))
5592	<	arg3 = std::string(PyString_AsString(obj2));
5593	<	else
5594	<	SWIG_exception(SWIG_TypeError, "string expected");
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	<	try {
5622	<	std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
5623	<
5624	<	}catch (const std::exception& e) {
5625	<	SWIG_exception(SWIG_RuntimeError, e.what());
5626	<	}
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	<	Py_INCREF(Py_None); resultobj = Py_None;
5636	<	return resultobj;
5637	<	fail:
5638	<	return NULL;
5635	>	}
5636	>
5637	>	fail:
5638	>	Py_INCREF(Py_NotImplemented);
5639	>	return Py_NotImplemented;
5640		}
5641
5642
5643	<	static PyObject *_wrap_objectMap___delitem__(PyObject *self, PyObject *args) {
5644	<	PyObject *resultobj;
5645	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5646	<	std::string arg2 ;
5647	<	PyObject * obj0 = 0 ;
5648	<	PyObject * obj1 = 0 ;
5649	<
5650	<	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___delitem__",&obj0,&obj1)) goto fail;
5651	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5652	<	{
5653	<	if (PyString_Check(obj1))
5654	<	arg2 = std::string(PyString_AsString(obj1));
5655	<	else
5656	<	SWIG_exception(SWIG_TypeError, "string expected");
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	<	try {
5674	<	std_maplstd_stringcstd_string_g___delitem_____(arg1,arg2);
5675	<
5676	<	}catch (std::out_of_range& e) {
5677	<	PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
5678	<	SWIG_fail;
5679	<	}
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	<	Py_INCREF(Py_None); resultobj = Py_None;
5701	<	return resultobj;
5702	<	fail:
5703	<	return NULL;
5700	>	}
5701	>	resultobj = SWIG_From_bool(static_cast< bool >(result));
5702	>	return resultobj;
5703	>	fail:
5704	>	return NULL;
5705		}
5706
5707
5708	<	static PyObject *_wrap_objectMap_has_key(PyObject *self, PyObject *args) {
5709	<	PyObject *resultobj;
5710	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5711	<	std::string arg2 ;
5712	<	bool result;
5713	<	PyObject * obj0 = 0 ;
5714	<	PyObject * obj1 = 0 ;
5715	<
5716	<	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap_has_key",&obj0,&obj1)) goto fail;
5717	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5718	<	{
5719	<	if (PyString_Check(obj1))
5720	<	arg2 = std::string(PyString_AsString(obj1));
5721	<	else
5722	<	SWIG_exception(SWIG_TypeError, "string expected");
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	<	try {
5730	<	result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
5731	<
5732	<	}catch (const std::exception& e) {
5733	<	SWIG_exception(SWIG_RuntimeError, e.what());
5734	<	}
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	<	resultobj = PyInt_FromLong((long)result);
5760	<	return resultobj;
5761	<	fail:
5762	<	return NULL;
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	<	static PyObject *_wrap_objectMap_keys(PyObject *self, PyObject *args) {
5787	<	PyObject *resultobj;
5788	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5789	<	PyObject *result;
5790	<	PyObject * obj0 = 0 ;
5791	<
5792	<	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_keys",&obj0)) goto fail;
5793	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5794	<	{
5795	<	try {
5796	<	result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
5797	<
5798	<	}catch (const std::exception& e) {
5799	<	SWIG_exception(SWIG_RuntimeError, e.what());
5800	<	}
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	<	resultobj = result;
5812	<	return resultobj;
5813	<	fail:
5814	<	return NULL;
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	<	static PyObject *_wrap_objectMap_values(PyObject *self, PyObject *args) {
5852	<	PyObject *resultobj;
5853	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5854	<	PyObject *result;
5855	<	PyObject * obj0 = 0 ;
5856	<
5857	<	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_values",&obj0)) goto fail;
5858	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5859	<	{
5860	<	try {
5861	<	result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
5862	<
5863	<	}catch (const std::exception& e) {
5864	<	SWIG_exception(SWIG_RuntimeError, e.what());
5865	<	}
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	<	resultobj = result;
5874	<	return resultobj;
5875	<	fail:
5876	<	return NULL;
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	<	static PyObject *_wrap_objectMap_items(PyObject *self, PyObject *args) {
5901	<	PyObject *resultobj;
5902	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5903	<	PyObject *result;
5904	<	PyObject * obj0 = 0 ;
5905	<
5906	<	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_items",&obj0)) goto fail;
5907	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5908	<	{
5909	<	try {
5910	<	result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
5911	<
5912	<	}catch (const std::exception& e) {
5913	<	SWIG_exception(SWIG_RuntimeError, e.what());
5914	<	}
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	<	resultobj = result;
5924	<	return resultobj;
5925	<	fail:
5926	<	return NULL;
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	<	static PyObject *_wrap_objectMap___contains__(PyObject *self, PyObject *args) {
5945	<	PyObject *resultobj;
5946	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5947	<	std::string arg2 ;
5948	<	bool result;
5949	<	PyObject * obj0 = 0 ;
5950	<	PyObject * obj1 = 0 ;
5951	<
5952	<	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___contains__",&obj0,&obj1)) goto fail;
5953	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5954	<	{
5955	<	if (PyString_Check(obj1))
5956	<	arg2 = std::string(PyString_AsString(obj1));
5957	<	else
5958	<	SWIG_exception(SWIG_TypeError, "string expected");
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	<	try {
5966	<	result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
5967	<
5968	<	}catch (const std::exception& e) {
5969	<	SWIG_exception(SWIG_RuntimeError, e.what());
5970	<	}
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	<	resultobj = PyInt_FromLong((long)result);
5993	<	return resultobj;
5994	<	fail:
5995	<	return NULL;
5992	>	}
5993	>	resultobj = result;
5994	>	return resultobj;
5995	>	fail:
5996	>	return NULL;
5997		}
5998
5999
6000	<	static PyObject *_wrap_objectMap___iter__(PyObject *self, PyObject *args) {
6001	<	PyObject *resultobj;
6002	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6003	<	PyObject *result;
6004	<	PyObject * obj0 = 0 ;
6005	<
6006	<	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___iter__",&obj0)) goto fail;
6007	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6008	<	{
6009	<	try {
6010	<	result = (PyObject *)std_maplstd_stringcstd_string_g___iter_____(arg1);
6011	<
6012	<	}catch (std::runtime_error& e) {
6013	<	PyErr_SetString(PyExc_RuntimeError,const_cast<char*>(e.what()));
6014	<	SWIG_fail;
6015	<	}
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	<	resultobj = result;
6021	<	return resultobj;
6022	<	fail:
6023	<	return NULL;
6020	>	}
6021	>	resultobj = result;
6022	>	return resultobj;
6023	>	fail:
6024	>	return NULL;
6025		}
6026
6027
6028	<	static PyObject *_wrap_delete_objectMap(PyObject *self, PyObject *args) {
6029	<	PyObject *resultobj;
6030	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6031	<	PyObject * obj0 = 0 ;
6032	<
6033	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_objectMap",&obj0)) goto fail;
6034	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6035	<	{
6036	<	try {
6037	<	delete arg1;
6038	<
6039	<	}catch (const std::exception& e) {
6040	<	SWIG_exception(SWIG_RuntimeError, e.what());
6041	<	}
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	<	Py_INCREF(Py_None); resultobj = Py_None;
6052	<	return resultobj;
6053	<	fail:
6054	<	return NULL;
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	<	static PyObject * objectMap_swigregister(PyObject *self, PyObject *args) {
6073	<	PyObject *obj;
6074	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6075	<	SWIG_TypeClientData(SWIGTYPE_p_std__mapTstd__string_std__string_t, obj);
6076	<	Py_INCREF(obj);
6077	<	return Py_BuildValue((char *)"");
6078	<	}
6079	<	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
6080	<	PyObject *resultobj;
6081	<	BossSession *arg1 = (BossSession *) 0 ;
6082	<	std::vector<std::string > *arg2 = 0 ;
6083	<	PyObject *result;
6084	<	PyObject * obj0 = 0 ;
6085	<	PyObject * obj1 = 0 ;
6086	<
6087	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
6088	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6089	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6090	<	if (arg2 == NULL) {
6091	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
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	<	try {
6096	<	result = (PyObject *)BossSession_show(arg1,*arg2);
6097	<
6098	<	}catch (const std::exception& e) {
6099	<	SWIG_exception(SWIG_RuntimeError, e.what());
6100	<	}
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	<	resultobj = result;
6125	<	return resultobj;
6126	<	fail:
6127	<	return NULL;
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	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_1(PyObject *self, PyObject *args) {
6133	<	PyObject *resultobj;
6134	<	BossSession *arg1 = (BossSession *) 0 ;
6135	<	PyObject *result;
6136	<	PyObject * obj0 = 0 ;
6137	<
6138	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
6139	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6140	<	{
6141	<	try {
1583	<	result = (PyObject *)BossSession_showCHTools__SWIG_1(arg1);
1584	<
1585	<	}catch (const std::exception& e) {
1586	<	SWIG_exception(SWIG_RuntimeError, e.what());
1587	<	}
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	<	resultobj = result;
6144	<	return resultobj;
6145	<	fail:
6146	<	return NULL;
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	<	static PyObject *_wrap_BossSession_showCHTools(PyObject *self, PyObject *args) {
6152	<	int argc;
6153	<	PyObject *argv[2];
6154	<	int ii;
6155	<
6156	<	argc = PyObject_Length(args);
6157	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6158	<	argv[ii] = PyTuple_GetItem(args,ii);
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 (argc == 1) {
6166	<	int _v;
1607	<	{
1608	<	void *ptr;
1609	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1610	<	_v = 0;
1611	<	PyErr_Clear();
1612	<	}else {
1613	<	_v = 1;
1614	<	}
1615	<	}
1616	<	if (_v) {
1617	<	return _wrap_BossSession_showCHTools__SWIG_1(self,args);
1618	<	}
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	<
6169	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showCHTools'");
6170	<	return NULL;
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	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_1(PyObject *self, PyObject *args) {
6187	<	PyObject *resultobj;
6188	<	BossSession *arg1 = (BossSession *) 0 ;
6189	<	PyObject *result;
6190	<	PyObject * obj0 = 0 ;
6191	<
6192	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
6193	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6194	<	{
6195	<	try {
6196	<	result = (PyObject *)BossSession_showProgramTypes__SWIG_1(arg1);
6197	<
6198	<	}catch (const std::exception& e) {
6199	<	SWIG_exception(SWIG_RuntimeError, e.what());
6200	<	}
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	<	resultobj = result;
6207	<	return resultobj;
6208	<	fail:
6209	<	return NULL;
6206	>	}
6207	>
6208	>	fail:
6209	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_objectMap'");
6210	>	return NULL;
6211		}
6212
6213
6214	<	static PyObject *_wrap_BossSession_showProgramTypes(PyObject *self, PyObject *args) {
6215	<	int argc;
6216	<	PyObject *argv[2];
6217	<	int ii;
6218	<
6219	<	argc = PyObject_Length(args);
6220	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6221	<	argv[ii] = PyTuple_GetItem(args,ii);
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	<	if (argc == 1) {
6235	<	int _v;
6236	<	{
6237	<	void *ptr;
6238	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
6239	<	_v = 0;
6240	<	PyErr_Clear();
6241	<	}else {
6242	<	_v = 1;
6243	<	}
6244	<	}
6245	<	if (_v) {
6246	<	return _wrap_BossSession_showProgramTypes__SWIG_1(self,args);
6247	<	}
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	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showProgramTypes'");
6264	<	return NULL;
6262	>	}
6263	>	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6264	>	return resultobj;
6265	>	fail:
6266	>	return NULL;
6267		}
6268
6269
6270	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_1(PyObject *self, PyObject *args) {
6271	<	PyObject *resultobj;
6272	<	BossSession *arg1 = (BossSession *) 0 ;
6273	<	PyObject *result;
6274	<	PyObject * obj0 = 0 ;
6275	<
6276	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
6277	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6278	<	{
6279	<	try {
6280	<	result = (PyObject *)BossSession_showRTMon__SWIG_1(arg1);
6281	<
6282	<	}catch (const std::exception& e) {
6283	<	SWIG_exception(SWIG_RuntimeError, e.what());
6284	<	}
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	<	resultobj = result;
6290	<	return resultobj;
6291	<	fail:
6292	<	return NULL;
6289	>	}
6290	>	resultobj = SWIG_Py_Void();
6291	>	return resultobj;
6292	>	fail:
6293	>	return NULL;
6294		}
6295
6296
6297	<	static PyObject *_wrap_BossSession_showRTMon(PyObject *self, PyObject *args) {
6298	<	int argc;
6299	<	PyObject *argv[2];
6300	<	int ii;
6301	<
6302	<	argc = PyObject_Length(args);
6303	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6304	<	argv[ii] = PyTuple_GetItem(args,ii);
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	<	if (argc == 1) {
6329	<	int _v;
6330	<	{
6331	<	void *ptr;
6332	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
6333	<	_v = 0;
6334	<	PyErr_Clear();
6335	<	}else {
6336	<	_v = 1;
6337	<	}
6338	<	}
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());
6383	>	}
6384	>	}
6385	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
6386	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6387	>	return resultobj;
6388	>	fail:
6389	>	return NULL;
6390	>	}
6391	>
6392	>
6393	>	SWIGINTERN PyObject *_wrap_objectMap_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6394	>	PyObject *resultobj = 0;
6395	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6396	>	std::map<std::string,std::string >::const_iterator result;
6397	>	void *argp1 = 0 ;
6398	>	int res1 = 0 ;
6399	>	PyObject * obj0 = 0 ;
6400	>
6401	>	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_begin",&obj0)) SWIG_fail;
6402	>	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 );
6403	>	if (!SWIG_IsOK(res1)) {
6404	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_begin" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6405	>	}
6406	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6407	>	{
6408	>	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());
6412	>	}
6413	>	}
6414	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
6415	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6416	>	return resultobj;
6417	>	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);
6438	>	}
6439	>	}
6440	>	if (argc == 1) {
6441	>	int _v;
6442	>	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));
6443	>	_v = SWIG_CheckState(res);
6444	>	if (_v) {
6445	>	return _wrap_objectMap_begin__SWIG_1(self, args);
6446	>	}
6447	>	}
6448	>
6449	>	fail:
6450	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_begin'");
6451	>	return NULL;
6452	>	}
6453	>
6454	>
6455	>	SWIGINTERN PyObject *_wrap_objectMap_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6456	>	PyObject *resultobj = 0;
6457	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6458	>	std::map<std::string,std::string >::iterator result;
6459	>	void *argp1 = 0 ;
6460	>	int res1 = 0 ;
6461	>	PyObject * obj0 = 0 ;
6462	>
6463	>	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_end",&obj0)) SWIG_fail;
6464	>	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 );
6465	>	if (!SWIG_IsOK(res1)) {
6466	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_end" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6467	>	}
6468	>	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());
6474	>	}
6475	>	}
6476	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
6477	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6478	>	return resultobj;
6479	>	fail:
6480	>	return NULL;
6481	>	}
6482	>
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());
6503	>	}
6504	>	}
6505	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
6506	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6507	>	return resultobj;
6508	>	fail:
6509	>	return NULL;
6510	>	}
6511	>
6512	>
6513	>	SWIGINTERN PyObject *_wrap_objectMap_end(PyObject *self, PyObject *args) {
6514	>	int argc;
6515	>	PyObject *argv[2];
6516	>	int ii;
6517	>
6518	>	if (!PyTuple_Check(args)) SWIG_fail;
6519	>	argc = PyObject_Length(args);
6520	>	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6521	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
6522	>	}
6523	>	if (argc == 1) {
6524	>	int _v;
6525	>	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));
6526	>	_v = SWIG_CheckState(res);
6527	>	if (_v) {
6528	>	return _wrap_objectMap_end__SWIG_0(self, args);
6529	>	}
6530	>	}
6531	>	if (argc == 1) {
6532	>	int _v;
6533	>	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));
6534	>	_v = SWIG_CheckState(res);
6535	>	if (_v) {
6536	>	return _wrap_objectMap_end__SWIG_1(self, args);
6537	>	}
6538	>	}
6539	>
6540	>	fail:
6541	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_end'");
6542	>	return NULL;
6543	>	}
6544	>
6545	>
6546	>	SWIGINTERN PyObject *_wrap_objectMap_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6547	>	PyObject *resultobj = 0;
6548	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6549	>	std::map<std::string,std::string >::reverse_iterator result;
6550	>	void *argp1 = 0 ;
6551	>	int res1 = 0 ;
6552	>	PyObject * obj0 = 0 ;
6553	>
6554	>	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rbegin",&obj0)) SWIG_fail;
6555	>	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 );
6556	>	if (!SWIG_IsOK(res1)) {
6557	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rbegin" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6558	>	}
6559	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6560	>	{
6561	>	try {
6562	>	result = (arg1)->rbegin();
6563	>	} catch (const std::exception& e) {
6564	>	SWIG_exception(SWIG_RuntimeError, e.what());
6565	>	}
6566	>	}
6567	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::reverse_iterator & >(result)),
6568	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6569	>	return resultobj;
6570	>	fail:
6571	>	return NULL;
6572	>	}
6573	>
6574	>
6575	>	SWIGINTERN PyObject *_wrap_objectMap_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6576	>	PyObject *resultobj = 0;
6577	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6578	>	std::map<std::string,std::string >::const_reverse_iterator result;
6579	>	void *argp1 = 0 ;
6580	>	int res1 = 0 ;
6581	>	PyObject * obj0 = 0 ;
6582	>
6583	>	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rbegin",&obj0)) SWIG_fail;
6584	>	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 );
6585	>	if (!SWIG_IsOK(res1)) {
6586	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rbegin" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6587	>	}
6588	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6589	>	{
6590	>	try {
6591	>	result = ((std::map<std::string,std::string > const *)arg1)->rbegin();
6592	>	} catch (const std::exception& e) {
6593	>	SWIG_exception(SWIG_RuntimeError, e.what());
6594	>	}
6595	>	}
6596	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_reverse_iterator & >(result)),
6597	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6598	>	return resultobj;
6599	>	fail:
6600	>	return NULL;
6601	>	}
6602	>
6603	>
6604	>	SWIGINTERN PyObject *_wrap_objectMap_rbegin(PyObject *self, PyObject *args) {
6605	>	int argc;
6606	>	PyObject *argv[2];
6607	>	int ii;
6608	>
6609	>	if (!PyTuple_Check(args)) SWIG_fail;
6610	>	argc = PyObject_Length(args);
6611	>	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6612	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
6613	>	}
6614	>	if (argc == 1) {
6615	>	int _v;
6616	>	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));
6617	>	_v = SWIG_CheckState(res);
6618	>	if (_v) {
6619	>	return _wrap_objectMap_rbegin__SWIG_0(self, args);
6620	>	}
6621	>	}
6622	>	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);
6628	>	}
6629	>	}
6630	>
6631	>	fail:
6632	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_rbegin'");
6633	>	return NULL;
6634	>	}
6635	>
6636	>
6637	>	SWIGINTERN PyObject *_wrap_objectMap_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6638	>	PyObject *resultobj = 0;
6639	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6640	>	std::map<std::string,std::string >::reverse_iterator result;
6641	>	void *argp1 = 0 ;
6642	>	int res1 = 0 ;
6643	>	PyObject * obj0 = 0 ;
6644	>
6645	>	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rend",&obj0)) SWIG_fail;
6646	>	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 );
6647	>	if (!SWIG_IsOK(res1)) {
6648	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rend" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6649	>	}
6650	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6651	>	{
6652	>	try {
6653	>	result = (arg1)->rend();
6654	>	} catch (const std::exception& e) {
6655	>	SWIG_exception(SWIG_RuntimeError, e.what());
6656	>	}
6657	>	}
6658	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::reverse_iterator & >(result)),
6659	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6660	>	return resultobj;
6661	>	fail:
6662	>	return NULL;
6663	>	}
6664	>
6665	>
6666	>	SWIGINTERN PyObject *_wrap_objectMap_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6667	>	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());
6685	>	}
6686	>	}
6687	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_reverse_iterator & >(result)),
6688	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6689	>	return resultobj;
6690	>	fail:
6691	>	return NULL;
6692	>	}
6693	>
6694	>
6695	>	SWIGINTERN PyObject *_wrap_objectMap_rend(PyObject *self, PyObject *args) {
6696	>	int argc;
6697	>	PyObject *argv[2];
6698	>	int ii;
6699	>
6700	>	if (!PyTuple_Check(args)) SWIG_fail;
6701	>	argc = PyObject_Length(args);
6702	>	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6703	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
6704	>	}
6705	>	if (argc == 1) {
6706	>	int _v;
6707	>	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));
6708	>	_v = SWIG_CheckState(res);
6709	>	if (_v) {
6710	>	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);
6719	>	}
6720	>	}
6721	>
6722	>	fail:
6723	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_rend'");
6724	>	return NULL;
6725	>	}
6726	>
6727	>
6728	>	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6729	>	PyObject *resultobj = 0;
6730	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6731	>	std::map<std::string,std::string >::key_type *arg2 = 0 ;
6732	>	std::map<std::string,std::string >::size_type result;
6733	>	void *argp1 = 0 ;
6734	>	int res1 = 0 ;
6735	>	int res2 = SWIG_OLDOBJ ;
6736	>	PyObject * obj0 = 0 ;
6737	>	PyObject * obj1 = 0 ;
6738	>
6739	>	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_erase",&obj0,&obj1)) SWIG_fail;
6740	>	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 );
6741	>	if (!SWIG_IsOK(res1)) {
6742	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6743	>	}
6744	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6745	>	{
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());
6761	>	}
6762	>	}
6763	>	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6764	>	if (SWIG_IsNewObj(res2)) delete arg2;
6765	>	return resultobj;
6766	>	fail:
6767	>	if (SWIG_IsNewObj(res2)) delete arg2;
6768	>	return NULL;
6769	>	}
6770	>
6771	>
6772	>	SWIGINTERN PyObject *_wrap_objectMap_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6773	>	PyObject *resultobj = 0;
6774	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6775	>	std::map<std::string,std::string >::key_type *arg2 = 0 ;
6776	>	std::map<std::string,std::string >::size_type result;
6777	>	void *argp1 = 0 ;
6778	>	int res1 = 0 ;
6779	>	int res2 = SWIG_OLDOBJ ;
6780	>	PyObject * obj0 = 0 ;
6781	>	PyObject * obj1 = 0 ;
6782	>
6783	>	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_count",&obj0,&obj1)) SWIG_fail;
6784	>	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 );
6785	>	if (!SWIG_IsOK(res1)) {
6786	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_count" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6787	>	}
6788	>	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 &""'");
6797	>	}
6798	>	arg2 = ptr;
6799	>	}
6800	>	{
6801	>	try {
6802	>	result = ((std::map<std::string,std::string > const *)arg1)->count((std::map<std::string,std::string >::key_type const &)*arg2);
6803	>	} catch (const std::exception& e) {
6804	>	SWIG_exception(SWIG_RuntimeError, e.what());
6805	>	}
6806	>	}
6807	>	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6808	>	if (SWIG_IsNewObj(res2)) delete arg2;
6809	>	return resultobj;
6810	>	fail:
6811	>	if (SWIG_IsNewObj(res2)) delete arg2;
6812	>	return NULL;
6813	>	}
6814	>
6815	>
6816	>	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6817	>	PyObject *resultobj = 0;
6818	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6819	>	std::map<std::string,std::string >::iterator arg2 ;
6820	>	void *argp1 = 0 ;
6821	>	int res1 = 0 ;
6822	>	swig::PySwigIterator *iter2 = 0 ;
6823	>	int res2 ;
6824	>	PyObject * obj0 = 0 ;
6825	>	PyObject * obj1 = 0 ;
6826	>
6827	>	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_erase",&obj0,&obj1)) SWIG_fail;
6828	>	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 );
6829	>	if (!SWIG_IsOK(res1)) {
6830	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6831	>	}
6832	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6833	>	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6834	>	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""'");
6842	>	}
6843	>	}
6844	>	{
6845	>	try {
6846	>	(arg1)->erase(arg2);
6847	>	} catch (const std::exception& e) {
6848	>	SWIG_exception(SWIG_RuntimeError, e.what());
6849	>	}
6850	>	}
6851	>	resultobj = SWIG_Py_Void();
6852	>	return resultobj;
6853	>	fail:
6854	>	return NULL;
6855	>	}
6856	>
6857	>
6858	>	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6859	>	PyObject *resultobj = 0;
6860	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6861	>	std::map<std::string,std::string >::iterator arg2 ;
6862	>	std::map<std::string,std::string >::iterator arg3 ;
6863	>	void *argp1 = 0 ;
6864	>	int res1 = 0 ;
6865	>	swig::PySwigIterator *iter2 = 0 ;
6866	>	int res2 ;
6867	>	swig::PySwigIterator *iter3 = 0 ;
6868	>	int res3 ;
6869	>	PyObject * obj0 = 0 ;
6870	>	PyObject * obj1 = 0 ;
6871	>	PyObject * obj2 = 0 ;
6872	>
6873	>	if (!PyArg_ParseTuple(args,(char *)"OOO:objectMap_erase",&obj0,&obj1,&obj2)) SWIG_fail;
6874	>	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 );
6875	>	if (!SWIG_IsOK(res1)) {
6876	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6877	>	}
6878	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6879	>	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
6880	>	if (!SWIG_IsOK(res2) || !iter2) {
6881	>	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::iterator""'");
6882	>	} else {
6883	>	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);
6884	>	if (iter_t) {
6885	>	arg2 = iter_t->get_current();
6886	>	} else {
6887	>	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::iterator""'");
6888	>	}
6889	>	}
6890	>	res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
6891	>	if (!SWIG_IsOK(res3) || !iter3) {
6892	>	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "3"" of type '" "std::map<std::string,std::string >::iterator""'");
6893	>	} 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""'");
6899	>	}
6900	>	}
6901	>	{
6902	>	try {
6903	>	(arg1)->erase(arg2,arg3);
6904	>	} catch (const std::exception& e) {
6905	>	SWIG_exception(SWIG_RuntimeError, e.what());
6906	>	}
6907	>	}
6908	>	resultobj = SWIG_Py_Void();
6909	>	return resultobj;
6910	>	fail:
6911	>	return NULL;
6912	>	}
6913	>
6914	>
6915	>	SWIGINTERN PyObject *_wrap_objectMap_erase(PyObject *self, PyObject *args) {
6916	>	int argc;
6917	>	PyObject *argv[4];
6918	>	int ii;
6919	>
6920	>	if (!PyTuple_Check(args)) SWIG_fail;
6921	>	argc = PyObject_Length(args);
6922	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6923	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
6924	>	}
6925	>	if (argc == 2) {
6926	>	int _v;
6927	>	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));
6928	>	_v = SWIG_CheckState(res);
6929	>	if (_v) {
6930	>	swig::PySwigIterator *iter = 0;
6931	>	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));
6962		if (_v) {
6963	<	return _wrap_BossSession_showRTMon__SWIG_1(self,args);
6963	>	return _wrap_objectMap_erase__SWIG_2(self, args);
6964		}
6965	+	}
6966		}
6967	<
6968	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showRTMon'");
6969	<	return NULL;
6967	>	}
6968	>
6969	>	fail:
6970	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_erase'");
6971	>	return NULL;
6972		}
6973
6974
6975	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_1(PyObject *self, PyObject *args) {
6976	<	PyObject *resultobj;
6977	<	BossSession *arg1 = (BossSession *) 0 ;
6978	<	PyObject *result;
6979	<	PyObject * obj0 = 0 ;
6980	<
6981	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
6982	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
6983	<	{
6984	<	try {
6985	<	result = (PyObject *)BossSession_showSchedulers__SWIG_1(arg1);
6986	<
6987	<	}catch (const std::exception& e) {
6988	<	SWIG_exception(SWIG_RuntimeError, e.what());
6989	<	}
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	<	resultobj = result;
6999	<	return resultobj;
7000	<	fail:
7001	<	return NULL;
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	<	static PyObject *_wrap_BossSession_showSchedulers(PyObject *self, PyObject *args) {
7021	<	int argc;
7022	<	PyObject *argv[2];
7023	<	int ii;
7024	<
7025	<	argc = PyObject_Length(args);
7026	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
7027	<	argv[ii] = PyTuple_GetItem(args,ii);
7020	>	SWIGINTERN PyObject *_wrap_objectMap_find__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7021	>	PyObject *resultobj = 0;
7022	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7023	>	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7024	>	std::map<std::string,std::string >::const_iterator result;
7025	>	void *argp1 = 0 ;
7026	>	int res1 = 0 ;
7027	>	int res2 = SWIG_OLDOBJ ;
7028	>	PyObject * obj0 = 0 ;
7029	>	PyObject * obj1 = 0 ;
7030	>
7031	>	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_find",&obj0,&obj1)) SWIG_fail;
7032	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7033	>	if (!SWIG_IsOK(res1)) {
7034	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_find" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
7035	>	}
7036	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7037	>	{
7038	>	std::string *ptr = (std::string *)0;
7039	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7040	>	if (!SWIG_IsOK(res2)) {
7041	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_find" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7042	>	}
7043	>	if (!ptr) {
7044	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_find" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7045	>	}
7046	>	arg2 = ptr;
7047	>	}
7048	>	{
7049	>	try {
7050	>	result = ((std::map<std::string,std::string > const *)arg1)->find((std::map<std::string,std::string >::key_type const &)*arg2);
7051	>	} catch (const std::exception& e) {
7052	>	SWIG_exception(SWIG_RuntimeError, e.what());
7053	>	}
7054	>	}
7055	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
7056	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7057	>	if (SWIG_IsNewObj(res2)) delete arg2;
7058	>	return resultobj;
7059	>	fail:
7060	>	if (SWIG_IsNewObj(res2)) delete arg2;
7061	>	return NULL;
7062	>	}
7063	>
7064	>
7065	>	SWIGINTERN PyObject *_wrap_objectMap_find(PyObject *self, PyObject *args) {
7066	>	int argc;
7067	>	PyObject *argv[3];
7068	>	int ii;
7069	>
7070	>	if (!PyTuple_Check(args)) SWIG_fail;
7071	>	argc = PyObject_Length(args);
7072	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7073	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
7074	>	}
7075	>	if (argc == 2) {
7076	>	int _v;
7077	>	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7078	>	_v = SWIG_CheckState(res);
7079	>	if (_v) {
7080	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7081	>	_v = SWIG_CheckState(res);
7082	>	if (_v) {
7083	>	return _wrap_objectMap_find__SWIG_0(self, args);
7084	>	}
7085	>	}
7086	>	}
7087	>	if (argc == 2) {
7088	>	int _v;
7089	>	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7090	>	_v = SWIG_CheckState(res);
7091	>	if (_v) {
7092	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7093	>	_v = SWIG_CheckState(res);
7094	>	if (_v) {
7095	>	return _wrap_objectMap_find__SWIG_1(self, args);
7096	>	}
7097	>	}
7098	>	}
7099	>
7100	>	fail:
7101	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_find'");
7102	>	return NULL;
7103	>	}
7104	>
7105	>
7106	>	SWIGINTERN PyObject *_wrap_objectMap_lower_bound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7107	>	PyObject *resultobj = 0;
7108	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7109	>	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7110	>	std::map<std::string,std::string >::iterator result;
7111	>	void *argp1 = 0 ;
7112	>	int res1 = 0 ;
7113	>	int res2 = SWIG_OLDOBJ ;
7114	>	PyObject * obj0 = 0 ;
7115	>	PyObject * obj1 = 0 ;
7116	>
7117	>	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_lower_bound",&obj0,&obj1)) SWIG_fail;
7118	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7119	>	if (!SWIG_IsOK(res1)) {
7120	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_lower_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
7121	>	}
7122	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7123	>	{
7124	>	std::string *ptr = (std::string *)0;
7125	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7126	>	if (!SWIG_IsOK(res2)) {
7127	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7128	>	}
7129	>	if (!ptr) {
7130	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7131	>	}
7132	>	arg2 = ptr;
7133	>	}
7134	>	{
7135	>	try {
7136	>	result = (arg1)->lower_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7137	>	} catch (const std::exception& e) {
7138	>	SWIG_exception(SWIG_RuntimeError, e.what());
7139	>	}
7140	>	}
7141	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
7142	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7143	>	if (SWIG_IsNewObj(res2)) delete arg2;
7144	>	return resultobj;
7145	>	fail:
7146	>	if (SWIG_IsNewObj(res2)) delete arg2;
7147	>	return NULL;
7148	>	}
7149	>
7150	>
7151	>	SWIGINTERN PyObject *_wrap_objectMap_lower_bound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7152	>	PyObject *resultobj = 0;
7153	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7154	>	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7155	>	std::map<std::string,std::string >::const_iterator result;
7156	>	void *argp1 = 0 ;
7157	>	int res1 = 0 ;
7158	>	int res2 = SWIG_OLDOBJ ;
7159	>	PyObject * obj0 = 0 ;
7160	>	PyObject * obj1 = 0 ;
7161	>
7162	>	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_lower_bound",&obj0,&obj1)) SWIG_fail;
7163	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7164	>	if (!SWIG_IsOK(res1)) {
7165	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_lower_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
7166	>	}
7167	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7168	>	{
7169	>	std::string *ptr = (std::string *)0;
7170	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7171	>	if (!SWIG_IsOK(res2)) {
7172	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7173	>	}
7174	>	if (!ptr) {
7175	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7176	>	}
7177	>	arg2 = ptr;
7178	>	}
7179	>	{
7180	>	try {
7181	>	result = ((std::map<std::string,std::string > const *)arg1)->lower_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7182	>	} catch (const std::exception& e) {
7183	>	SWIG_exception(SWIG_RuntimeError, e.what());
7184	>	}
7185	>	}
7186	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
7187	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7188	>	if (SWIG_IsNewObj(res2)) delete arg2;
7189	>	return resultobj;
7190	>	fail:
7191	>	if (SWIG_IsNewObj(res2)) delete arg2;
7192	>	return NULL;
7193	>	}
7194	>
7195	>
7196	>	SWIGINTERN PyObject *_wrap_objectMap_lower_bound(PyObject *self, PyObject *args) {
7197	>	int argc;
7198	>	PyObject *argv[3];
7199	>	int ii;
7200	>
7201	>	if (!PyTuple_Check(args)) SWIG_fail;
7202	>	argc = PyObject_Length(args);
7203	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7204	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
7205	>	}
7206	>	if (argc == 2) {
7207	>	int _v;
7208	>	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7209	>	_v = SWIG_CheckState(res);
7210	>	if (_v) {
7211	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7212	>	_v = SWIG_CheckState(res);
7213	>	if (_v) {
7214	>	return _wrap_objectMap_lower_bound__SWIG_0(self, args);
7215	>	}
7216	>	}
7217	>	}
7218	>	if (argc == 2) {
7219	>	int _v;
7220	>	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7221	>	_v = SWIG_CheckState(res);
7222	>	if (_v) {
7223	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7224	>	_v = SWIG_CheckState(res);
7225	>	if (_v) {
7226	>	return _wrap_objectMap_lower_bound__SWIG_1(self, args);
7227	>	}
7228	>	}
7229	>	}
7230	>
7231	>	fail:
7232	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_lower_bound'");
7233	>	return NULL;
7234	>	}
7235	>
7236	>
7237	>	SWIGINTERN PyObject *_wrap_objectMap_upper_bound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7238	>	PyObject *resultobj = 0;
7239	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7240	>	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7241	>	std::map<std::string,std::string >::iterator result;
7242	>	void *argp1 = 0 ;
7243	>	int res1 = 0 ;
7244	>	int res2 = SWIG_OLDOBJ ;
7245	>	PyObject * obj0 = 0 ;
7246	>	PyObject * obj1 = 0 ;
7247	>
7248	>	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_upper_bound",&obj0,&obj1)) SWIG_fail;
7249	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7250	>	if (!SWIG_IsOK(res1)) {
7251	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_upper_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
7252	>	}
7253	>	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7254	>	{
7255	>	std::string *ptr = (std::string *)0;
7256	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7257	>	if (!SWIG_IsOK(res2)) {
7258	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_upper_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7259	>	}
7260	>	if (!ptr) {
7261	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_upper_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7262	>	}
7263	>	arg2 = ptr;
7264	>	}
7265	>	{
7266	>	try {
7267	>	result = (arg1)->upper_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7268	>	} catch (const std::exception& e) {
7269	>	SWIG_exception(SWIG_RuntimeError, e.what());
7270		}
7271	<	if (argc == 1) {
7272	<	int _v;
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 {
7764		{
7765	<	void *ptr;
7766	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
1769	<	_v = 0;
1770	<	PyErr_Clear();
1771	<	}else {
1772	<	_v = 1;
1773	<	}
7765	>	std::vector<std::string >::value_type const &_result_ref = std_vector_Sl_std_string_Sg____getitem__((std::vector<std::string > const *)arg1,arg2);
7766	>	result = (std::vector<std::string >::value_type *) &_result_ref;
7767		}
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);
8444	+	}
8445	+	}
8446	+
8447	+	fail:
8448	+	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_rend'");
8449	+	return NULL;
8450	+	}
8451	+
8452	+
8453	+	SWIGINTERN PyObject *_wrap_new_vector_string__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8454	+	PyObject *resultobj = 0;
8455	+	std::vector<std::string >::size_type arg1 ;
8456	+	std::vector<std::string > *result = 0 ;
8457	+	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());
8472	+	}
8473	+	}
8474	+	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
8475	+	return resultobj;
8476	+	fail:
8477	+	return NULL;
8478	+	}
8479	+
8480	+
8481	+	SWIGINTERN PyObject *_wrap_vector_string_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8482	+	PyObject *resultobj = 0;
8483	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8484	+	void *argp1 = 0 ;
8485	+	int res1 = 0 ;
8486	+	PyObject * obj0 = 0 ;
8487	+
8488	+	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_pop_back",&obj0)) SWIG_fail;
8489	+	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8490	+	if (!SWIG_IsOK(res1)) {
8491	+	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_pop_back" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8492	+	}
8493	+	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8494	+	{
8495	+	try {
8496	+	(arg1)->pop_back();
8497	+	} catch (const std::exception& e) {
8498	+	SWIG_exception(SWIG_RuntimeError, e.what());
8499	+	}
8500	+	}
8501	+	resultobj = SWIG_Py_Void();
8502	+	return resultobj;
8503	+	fail:
8504	+	return NULL;
8505	+	}
8506	+
8507	+
8508	+	SWIGINTERN PyObject *_wrap_vector_string_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8509	+	PyObject *resultobj = 0;
8510	+	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());
8535	+	}
8536	+	}
8537	+	resultobj = SWIG_Py_Void();
8538	+	return resultobj;
8539	+	fail:
8540	+	return NULL;
8541	+	}
8542	+
8543	+
8544	+	SWIGINTERN PyObject *_wrap_vector_string_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8545	+	PyObject *resultobj = 0;
8546	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8547	+	std::vector<std::string >::iterator arg2 ;
8548	+	std::vector<std::string >::iterator result;
8549	+	void *argp1 = 0 ;
8550	+	int res1 = 0 ;
8551	+	swig::PySwigIterator *iter2 = 0 ;
8552	+	int res2 ;
8553	+	PyObject * obj0 = 0 ;
8554	+	PyObject * obj1 = 0 ;
8555	+
8556	+	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_erase",&obj0,&obj1)) SWIG_fail;
8557	+	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8558	+	if (!SWIG_IsOK(res1)) {
8559	+	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_erase" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8560	+	}
8561	+	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8562	+	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
8563	+	if (!SWIG_IsOK(res2) || !iter2) {
8564	+	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_erase" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
8565	+	} else {
8566	+	swig::PySwigIterator_T<std::vector<std::string >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter2);
8567	+	if (iter_t) {
8568	+	arg2 = iter_t->get_current();
8569	+	} else {
8570	+	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_erase" "', argument " "2"" of type '" "std::vector<std::string >::iterator""'");
8571	+	}
8572	+	}
8573	+	{
8574	+	try {
8575	+	result = (arg1)->erase(arg2);
8576	+	} catch (const std::exception& e) {
8577	+	SWIG_exception(SWIG_RuntimeError, e.what());
8578	+	}
8579	+	}
8580	+	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
8581	+	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8582	+	return resultobj;
8583	+	fail:
8584	+	return NULL;
8585	+	}
8586	+
8587	+
8588	+	SWIGINTERN PyObject *_wrap_vector_string_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8589	+	PyObject *resultobj = 0;
8590	+	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8591	+	std::vector<std::string >::iterator arg2 ;
8592	+	std::vector<std::string >::iterator arg3 ;
8593	+	std::vector<std::string >::iterator result;
8594	+	void *argp1 = 0 ;
8595	+	int res1 = 0 ;
8596	+	swig::PySwigIterator *iter2 = 0 ;
8597	+	int res2 ;
8598	+	swig::PySwigIterator *iter3 = 0 ;
8599	+	int res3 ;
8600	+	PyObject * obj0 = 0 ;
8601	+	PyObject * obj1 = 0 ;
8602	+	PyObject * obj2 = 0 ;
8603	+
8604	+	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_erase",&obj0,&obj1,&obj2)) SWIG_fail;
8605	+	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());
8637	+	}
8638	+	}
8639	+	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
8640	+	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8641	+	return resultobj;
8642	+	fail:
8643	+	return NULL;
8644	+	}
8645	+
8646	+
8647	+	SWIGINTERN PyObject *_wrap_vector_string_erase(PyObject *self, PyObject *args) {
8648	+	int argc;
8649	+	PyObject *argv[4];
8650	+	int ii;
8651	+
8652	+	if (!PyTuple_Check(args)) SWIG_fail;
8653	+	argc = PyObject_Length(args);
8654	+	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8655	+	argv[ii] = PyTuple_GET_ITEM(args,ii);
8656	+	}
8657	+	if (argc == 2) {
8658	+	int _v;
8659	+	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8660	+	_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	+	}
8668	+	}
8669	+	}
8670	+	if (argc == 3) {
8671	+	int _v;
8672	+	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
8673	+	_v = SWIG_CheckState(res);
8674	+	if (_v) {
8675	+	swig::PySwigIterator *iter = 0;
8676	+	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
8677	+	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter) != 0));
8678	+	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_BossSession_showSchedulers__SWIG_1(self,args);
8683	>	return _wrap_vector_string_erase__SWIG_1(self, args);
8684		}
8685	+	}
8686		}
8687	<
8688	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_showSchedulers'");
8689	<	return NULL;
8687	>	}
8688	>
8689	>	fail:
8690	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_erase'");
8691	>	return NULL;
8692		}
8693
8694
8695	<	static PyObject *_wrap_BossSession_listMatch__SWIG_1(PyObject *self, PyObject *args) {
8696	<	PyObject *resultobj;
8697	<	BossSession *arg1 = (BossSession *) 0 ;
8698	<	std::string *arg2 = 0 ;
8699	<	std::string *arg3 = 0 ;
8700	<	std::string const &arg4_defvalue = "" ;
8701	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
8702	<	std::string const &arg5_defvalue = "" ;
8703	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
8704	<	bool arg6 = (bool) false ;
8705	<	PyObject *result;
8706	<	std::string temp2 ;
8707	<	std::string temp3 ;
8708	<	std::string temp4 ;
8709	<	std::string temp5 ;
8710	<	PyObject * obj0 = 0 ;
8711	<	PyObject * obj1 = 0 ;
8712	<	PyObject * obj2 = 0 ;
8713	<	PyObject * obj3 = 0 ;
8714	<	PyObject * obj4 = 0 ;
8715	<	PyObject * obj5 = 0 ;
8716	<
8717	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
8718	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
8695	>	SWIGINTERN PyObject *_wrap_new_vector_string__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8696	>	PyObject *resultobj = 0;
8697	>	std::vector<std::string >::size_type arg1 ;
8698	>	std::vector<std::string >::value_type *arg2 = 0 ;
8699	>	std::vector<std::string > *result = 0 ;
8700	>	size_t val1 ;
8701	>	int ecode1 = 0 ;
8702	>	int res2 = SWIG_OLDOBJ ;
8703	>	PyObject * obj0 = 0 ;
8704	>	PyObject * obj1 = 0 ;
8705	>
8706	>	if (!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) SWIG_fail;
8707	>	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
8708	>	if (!SWIG_IsOK(ecode1)) {
8709	>	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 &""'");
8720	>	}
8721	>	arg2 = ptr;
8722	>	}
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());
8728	>	}
8729	>	}
8730	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
8731	>	if (SWIG_IsNewObj(res2)) delete arg2;
8732	>	return resultobj;
8733	>	fail:
8734	>	if (SWIG_IsNewObj(res2)) delete arg2;
8735	>	return NULL;
8736	>	}
8737	>
8738	>
8739	>	SWIGINTERN PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
8740	>	int argc;
8741	>	PyObject *argv[3];
8742	>	int ii;
8743	>
8744	>	if (!PyTuple_Check(args)) SWIG_fail;
8745	>	argc = PyObject_Length(args);
8746	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
8747	>	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;
8754		{
8755	<	if (PyString_Check(obj1)) {
8756	<	temp2 = std::string(PyString_AsString(obj1));
8757	<	arg2 = &temp2;
8758	<	}else {
8759	<	SWIG_exception(SWIG_TypeError, "string expected");
8760	<	}
8755	>	int res = SWIG_AsVal_size_t(argv[0], NULL);
8756	>	_v = SWIG_CheckState(res);
8757	>	}
8758	>	if (_v) {
8759	>	return _wrap_new_vector_string__SWIG_2(self, args);
8760	>	}
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);
8768		}
8769	+	}
8770	+	if (argc == 2) {
8771	+	int _v;
8772		{
8773	<	if (PyString_Check(obj2)) {
8774	<	temp3 = std::string(PyString_AsString(obj2));
1820	<	arg3 = &temp3;
1821	<	}else {
1822	<	SWIG_exception(SWIG_TypeError, "string expected");
1823	<	}
8773	>	int res = SWIG_AsVal_size_t(argv[0], NULL);
8774	>	_v = SWIG_CheckState(res);
8775		}
8776	<	if (obj3) {
8777	<	{
8778	<	if (PyString_Check(obj3)) {
8779	<	temp4 = std::string(PyString_AsString(obj3));
8780	<	arg4 = &temp4;
8781	<	}else {
1831	<	SWIG_exception(SWIG_TypeError, "string expected");
1832	<	}
1833	<	}
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	>	}
8782		}
8783	<	if (obj4) {
8784	<	{
8785	<	if (PyString_Check(obj4)) {
8786	<	temp5 = std::string(PyString_AsString(obj4));
8787	<	arg5 = &temp5;
8788	<	}else {
8789	<	SWIG_exception(SWIG_TypeError, "string expected");
8790	<	}
8791	<	}
8783	>	}
8784	>
8785	>	fail:
8786	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_vector_string'");
8787	>	return NULL;
8788	>	}
8789	>
8790	>
8791	>	SWIGINTERN PyObject *_wrap_vector_string_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8792	>	PyObject *resultobj = 0;
8793	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8794	>	std::vector<std::string >::value_type *arg2 = 0 ;
8795	>	void *argp1 = 0 ;
8796	>	int res1 = 0 ;
8797	>	int res2 = SWIG_OLDOBJ ;
8798	>	PyObject * obj0 = 0 ;
8799	>	PyObject * obj1 = 0 ;
8800	>
8801	>	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_push_back",&obj0,&obj1)) SWIG_fail;
8802	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8803	>	if (!SWIG_IsOK(res1)) {
8804	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_push_back" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8805	>	}
8806	>	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8807	>	{
8808	>	std::string *ptr = (std::string *)0;
8809	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
8810	>	if (!SWIG_IsOK(res2)) {
8811	>	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 (obj5) {
8814	<	arg6 = PyInt_AsLong(obj5) ? true : false;
1847	<	if (PyErr_Occurred()) SWIG_fail;
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 &""'");
8815		}
8816	<	{
8817	<	try {
8818	<	result = (PyObject *)BossSession_listMatch__SWIG_1(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
8819	<
8820	<	}catch (const std::exception& e) {
8821	<	SWIG_exception(SWIG_RuntimeError, e.what());
8822	<	}
8816	>	arg2 = ptr;
8817	>	}
8818	>	{
8819	>	try {
8820	>	(arg1)->push_back((std::vector<std::string >::value_type const &)*arg2);
8821	>	} catch (const std::exception& e) {
8822	>	SWIG_exception(SWIG_RuntimeError, e.what());
8823		}
8824	<	resultobj = result;
8825	<	return resultobj;
8826	<	fail:
8827	<	return NULL;
8824	>	}
8825	>	resultobj = SWIG_Py_Void();
8826	>	if (SWIG_IsNewObj(res2)) delete arg2;
8827	>	return resultobj;
8828	>	fail:
8829	>	if (SWIG_IsNewObj(res2)) delete arg2;
8830	>	return NULL;
8831		}
8832
8833
8834	<	static PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
8835	<	int argc;
8836	<	PyObject *argv[7];
8837	<	int ii;
8838	<
8839	<	argc = PyObject_Length(args);
8840	<	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
8841	<	argv[ii] = PyTuple_GetItem(args,ii);
8834	>	SWIGINTERN PyObject *_wrap_vector_string_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8835	>	PyObject *resultobj = 0;
8836	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8837	>	std::vector<std::string >::value_type *result = 0 ;
8838	>	void *argp1 = 0 ;
8839	>	int res1 = 0 ;
8840	>	PyObject * obj0 = 0 ;
8841	>
8842	>	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_front",&obj0)) SWIG_fail;
8843	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8844	>	if (!SWIG_IsOK(res1)) {
8845	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_front" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
8846	>	}
8847	>	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8848	>	{
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());
8856		}
8857	<	if ((argc >= 3) && (argc <= 6)) {
8858	<	int _v;
8859	<	{
8860	<	void *ptr;
8861	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossSession, 0) == -1) {
8862	<	_v = 0;
8863	<	PyErr_Clear();
8864	<	}else {
8865	<	_v = 1;
8866	<	}
8867	<	}
8857	>	}
8858	>	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
8859	>	return resultobj;
8860	>	fail:
8861	>	return NULL;
8862	>	}
8863	>
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());
8887	>	}
8888	>	}
8889	>	resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
8890	>	return resultobj;
8891	>	fail:
8892	>	return NULL;
8893	>	}
8894	>
8895	>
8896	>	SWIGINTERN PyObject *_wrap_vector_string_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8897	>	PyObject *resultobj = 0;
8898	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8899	>	std::vector<std::string >::size_type arg2 ;
8900	>	std::vector<std::string >::value_type *arg3 = 0 ;
8901	>	void *argp1 = 0 ;
8902	>	int res1 = 0 ;
8903	>	size_t val2 ;
8904	>	int ecode2 = 0 ;
8905	>	int res3 = SWIG_OLDOBJ ;
8906	>	PyObject * obj0 = 0 ;
8907	>	PyObject * obj1 = 0 ;
8908	>	PyObject * obj2 = 0 ;
8909	>
8910	>	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_assign",&obj0,&obj1,&obj2)) SWIG_fail;
8911	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
8912	>	if (!SWIG_IsOK(res1)) {
8913	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_assign" "', argument " "1"" of type '" "std::vector<std::string > *""'");
8914	>	}
8915	>	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
8916	>	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8917	>	if (!SWIG_IsOK(ecode2)) {
8918	>	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string_assign" "', argument " "2"" of type '" "std::vector<std::string >::size_type""'");
8919	>	}
8920	>	arg2 = static_cast< std::vector<std::string >::size_type >(val2);
8921	>	{
8922	>	std::string *ptr = (std::string *)0;
8923	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
8924	>	if (!SWIG_IsOK(res3)) {
8925	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_string_assign" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
8926	>	}
8927	>	if (!ptr) {
8928	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_assign" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
8929	>	}
8930	>	arg3 = ptr;
8931	>	}
8932	>	{
8933	>	try {
8934	>	(arg1)->assign(arg2,(std::vector<std::string >::value_type const &)*arg3);
8935	>	} catch (const std::exception& e) {
8936	>	SWIG_exception(SWIG_RuntimeError, e.what());
8937	>	}
8938	>	}
8939	>	resultobj = SWIG_Py_Void();
8940	>	if (SWIG_IsNewObj(res3)) delete arg3;
8941	>	return resultobj;
8942	>	fail:
8943	>	if (SWIG_IsNewObj(res3)) delete arg3;
8944	>	return NULL;
8945	>	}
8946	>
8947	>
8948	>	SWIGINTERN PyObject *_wrap_vector_string_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8949	>	PyObject *resultobj = 0;
8950	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
8951	>	std::vector<std::string >::size_type arg2 ;
8952	>	std::vector<std::string >::value_type *arg3 = 0 ;
8953	>	void *argp1 = 0 ;
8954	>	int res1 = 0 ;
8955	>	size_t val2 ;
8956	>	int ecode2 = 0 ;
8957	>	int res3 = SWIG_OLDOBJ ;
8958	>	PyObject * obj0 = 0 ;
8959	>	PyObject * obj1 = 0 ;
8960	>	PyObject * obj2 = 0 ;
8961	>
8962	>	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());
8989	>	}
8990	>	}
8991	>	resultobj = SWIG_Py_Void();
8992	>	if (SWIG_IsNewObj(res3)) delete arg3;
8993	>	return resultobj;
8994	>	fail:
8995	>	if (SWIG_IsNewObj(res3)) delete arg3;
8996	>	return NULL;
8997	>	}
8998	>
8999	>
9000	>	SWIGINTERN PyObject *_wrap_vector_string_resize(PyObject *self, PyObject *args) {
9001	>	int argc;
9002	>	PyObject *argv[4];
9003	>	int ii;
9004	>
9005	>	if (!PyTuple_Check(args)) SWIG_fail;
9006	>	argc = PyObject_Length(args);
9007	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9008	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
9009	>	}
9010	>	if (argc == 2) {
9011	>	int _v;
9012	>	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
9013	>	_v = SWIG_CheckState(res);
9014	>	if (_v) {
9015	>	{
9016	>	int res = SWIG_AsVal_size_t(argv[1], NULL);
9017	>	_v = SWIG_CheckState(res);
9018	>	}
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	<	{
1886	<	_v = PyString_Check(argv[1]) ? 1 : 0;
1887	<	}
1888	<	if (_v) {
1889	<	{
1890	<	_v = PyString_Check(argv[2]) ? 1 : 0;
1891	<	}
1892	<	if (_v) {
1893	<	if (argc <= 3) {
1894	<	return _wrap_BossSession_listMatch__SWIG_1(self,args);
1895	<	}
1896	<	{
1897	<	_v = PyString_Check(argv[3]) ? 1 : 0;
1898	<	}
1899	<	if (_v) {
1900	<	if (argc <= 4) {
1901	<	return _wrap_BossSession_listMatch__SWIG_1(self,args);
1902	<	}
1903	<	{
1904	<	_v = PyString_Check(argv[4]) ? 1 : 0;
1905	<	}
1906	<	if (_v) {
1907	<	if (argc <= 5) {
1908	<	return _wrap_BossSession_listMatch__SWIG_1(self,args);
1909	<	}
1910	<	{
1911	<	_v = (PyInt_Check(argv[5]) || PyLong_Check(argv[5])) ? 1 : 0;
1912	<	}
1913	<	if (_v) {
1914	<	return _wrap_BossSession_listMatch__SWIG_1(self,args);
1915	<	}
1916	<	}
1917	<	}
1918	<	}
1919	<	}
9037	>	return _wrap_vector_string_resize__SWIG_1(self, args);
9038		}
9039	+	}
9040		}
9041	<
9042	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossSession_listMatch'");
9043	<	return NULL;
9041	>	}
9042	>
9043	>	fail:
9044	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_resize'");
9045	>	return NULL;
9046		}
9047
9048
9049	<	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
9050	<	PyObject *resultobj;
9051	<	BossSession *arg1 = (BossSession *) 0 ;
9052	<	int arg2 = (int) SCHEDULED ;
9053	<	std::string const &arg3_defvalue = "all" ;
9054	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
9055	<	std::string const &arg4_defvalue = "all" ;
9056	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
9057	<	std::string const &arg5_defvalue = "" ;
9058	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
9059	<	std::string arg6 = (std::string) "" ;
9060	<	std::string arg7 = (std::string) "" ;
9061	<	std::string arg8 = (std::string) "" ;
9062	<	std::string arg9 = (std::string) "" ;
9063	<	bool arg10 = (bool) false ;
9064	<	PyObject *result;
9065	<	std::string temp3 ;
9066	<	std::string temp4 ;
9067	<	std::string temp5 ;
9068	<	PyObject * obj0 = 0 ;
9069	<	PyObject * obj2 = 0 ;
9070	<	PyObject * obj3 = 0 ;
9071	<	PyObject * obj4 = 0 ;
9072	<	PyObject * obj5 = 0 ;
9073	<	PyObject * obj6 = 0 ;
9074	<	PyObject * obj7 = 0 ;
9075	<	PyObject * obj8 = 0 ;
9076	<	PyObject * obj9 = 0 ;
9077	<
9078	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
1958	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1959	<	if (obj2) {
1960	<	{
1961	<	if (PyString_Check(obj2)) {
1962	<	temp3 = std::string(PyString_AsString(obj2));
1963	<	arg3 = &temp3;
1964	<	}else {
1965	<	SWIG_exception(SWIG_TypeError, "string expected");
1966	<	}
1967	<	}
9049	>	SWIGINTERN PyObject *_wrap_vector_string_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9050	>	PyObject *resultobj = 0;
9051	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
9052	>	std::vector<std::string >::iterator arg2 ;
9053	>	std::vector<std::string >::value_type *arg3 = 0 ;
9054	>	std::vector<std::string >::iterator result;
9055	>	void *argp1 = 0 ;
9056	>	int res1 = 0 ;
9057	>	swig::PySwigIterator *iter2 = 0 ;
9058	>	int res2 ;
9059	>	int res3 = SWIG_OLDOBJ ;
9060	>	PyObject * obj0 = 0 ;
9061	>	PyObject * obj1 = 0 ;
9062	>	PyObject * obj2 = 0 ;
9063	>
9064	>	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string_insert",&obj0,&obj1,&obj2)) SWIG_fail;
9065	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
9066	>	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	<	if (obj3) {
9081	<	{
9082	<	if (PyString_Check(obj3)) {
9083	<	temp4 = std::string(PyString_AsString(obj3));
9084	<	arg4 = &temp4;
9085	<	}else {
1975	<	SWIG_exception(SWIG_TypeError, "string expected");
1976	<	}
1977	<	}
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 (obj4) {
9088	<	{
1981	<	if (PyString_Check(obj4)) {
1982	<	temp5 = std::string(PyString_AsString(obj4));
1983	<	arg5 = &temp5;
1984	<	}else {
1985	<	SWIG_exception(SWIG_TypeError, "string expected");
1986	<	}
1987	<	}
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	<	if (obj5) {
9091	<	{
9092	<	if (PyString_Check(obj5))
9093	<	arg6 = std::string(PyString_AsString(obj5));
9094	<	else
9095	<	SWIG_exception(SWIG_TypeError, "string expected");
9096	<	}
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());
9097		}
9098	<	if (obj6) {
9099	<	{
9100	<	if (PyString_Check(obj6))
9101	<	arg7 = std::string(PyString_AsString(obj6));
9102	<	else
9103	<	SWIG_exception(SWIG_TypeError, "string expected");
9104	<	}
9098	>	}
9099	>	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
9100	>	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
9101	>	if (SWIG_IsNewObj(res3)) delete arg3;
9102	>	return resultobj;
9103	>	fail:
9104	>	if (SWIG_IsNewObj(res3)) delete arg3;
9105	>	return NULL;
9106	>	}
9107	>
9108	>
9109	>	SWIGINTERN PyObject *_wrap_vector_string_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9110	>	PyObject *resultobj = 0;
9111	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
9112	>	std::vector<std::string >::iterator arg2 ;
9113	>	std::vector<std::string >::size_type arg3 ;
9114	>	std::vector<std::string >::value_type *arg4 = 0 ;
9115	>	void *argp1 = 0 ;
9116	>	int res1 = 0 ;
9117	>	swig::PySwigIterator *iter2 = 0 ;
9118	>	int res2 ;
9119	>	size_t val3 ;
9120	>	int ecode3 = 0 ;
9121	>	int res4 = SWIG_OLDOBJ ;
9122	>	PyObject * obj0 = 0 ;
9123	>	PyObject * obj1 = 0 ;
9124	>	PyObject * obj2 = 0 ;
9125	>	PyObject * obj3 = 0 ;
9126	>
9127	>	if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9128	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
9129	>	if (!SWIG_IsOK(res1)) {
9130	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_insert" "', argument " "1"" of type '" "std::vector<std::string > *""'");
9131	>	}
9132	>	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
9133	>	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
9134	>	if (!SWIG_IsOK(res2) || !iter2) {
9135	>	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	<	if (obj7) {
9144	<	{
9145	<	if (PyString_Check(obj7))
9146	<	arg8 = std::string(PyString_AsString(obj7));
9147	<	else
9148	<	SWIG_exception(SWIG_TypeError, "string expected");
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 &""'");
9157	>	}
9158	>	arg4 = ptr;
9159	>	}
9160	>	{
9161	>	try {
9162	>	(arg1)->insert(arg2,arg3,(std::vector<std::string >::value_type const &)*arg4);
9163	>	} catch (const std::exception& e) {
9164	>	SWIG_exception(SWIG_RuntimeError, e.what());
9165	>	}
9166	>	}
9167	>	resultobj = SWIG_Py_Void();
9168	>	if (SWIG_IsNewObj(res4)) delete arg4;
9169	>	return resultobj;
9170	>	fail:
9171	>	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);
9199		}
9200	+	}
9201		}
9202	<	if (obj8) {
9202	>	}
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) {
9212		{
9213	<	if (PyString_Check(obj8))
9214	<	arg9 = std::string(PyString_AsString(obj8));
2017	<	else
2018	<	SWIG_exception(SWIG_TypeError, "string expected");
9213	>	int res = SWIG_AsVal_size_t(argv[2], NULL);
9214	>	_v = SWIG_CheckState(res);
9215		}
9216	+	if (_v) {
9217	+	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
9218	+	_v = SWIG_CheckState(res);
9219	+	if (_v) {
9220	+	return _wrap_vector_string_insert__SWIG_1(self, args);
9221	+	}
9222	+	}
9223	+	}
9224		}
9225	<	if (obj9) {
9226	<	arg10 = PyInt_AsLong(obj9) ? true : false;
9227	<	if (PyErr_Occurred()) SWIG_fail;
9225	>	}
9226	>
9227	>	fail:
9228	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_insert'");
9229	>	return NULL;
9230	>	}
9231	>
9232	>
9233	>	SWIGINTERN PyObject *_wrap_vector_string_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9234	>	PyObject *resultobj = 0;
9235	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
9236	>	std::vector<std::string >::size_type arg2 ;
9237	>	void *argp1 = 0 ;
9238	>	int res1 = 0 ;
9239	>	size_t val2 ;
9240	>	int ecode2 = 0 ;
9241	>	PyObject * obj0 = 0 ;
9242	>	PyObject * obj1 = 0 ;
9243	>
9244	>	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_reserve",&obj0,&obj1)) SWIG_fail;
9245	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
9246	>	if (!SWIG_IsOK(res1)) {
9247	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_reserve" "', argument " "1"" of type '" "std::vector<std::string > *""'");
9248	>	}
9249	>	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
9250	>	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());
9260		}
9261	<	{
9262	<	try {
9263	<	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
9264	<
9265	<	}catch (const std::exception& e) {
9266	<	SWIG_exception(SWIG_RuntimeError, e.what());
9267	<	}
9261	>	}
9262	>	resultobj = SWIG_Py_Void();
9263	>	return resultobj;
9264	>	fail:
9265	>	return NULL;
9266	>	}
9267	>
9268	>
9269	>	SWIGINTERN PyObject *_wrap_vector_string_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9270	>	PyObject *resultobj = 0;
9271	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
9272	>	std::vector<std::string >::size_type result;
9273	>	void *argp1 = 0 ;
9274	>	int res1 = 0 ;
9275	>	PyObject * obj0 = 0 ;
9276	>
9277	>	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_capacity",&obj0)) SWIG_fail;
9278	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
9279	>	if (!SWIG_IsOK(res1)) {
9280	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_capacity" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
9281	>	}
9282	>	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
9283	>	{
9284	>	try {
9285	>	result = ((std::vector<std::string > const *)arg1)->capacity();
9286	>	} catch (const std::exception& e) {
9287	>	SWIG_exception(SWIG_RuntimeError, e.what());
9288		}
9289	<	resultobj = result;
9290	<	return resultobj;
9291	<	fail:
9292	<	return NULL;
9289	>	}
9290	>	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9291	>	return resultobj;
9292	>	fail:
9293	>	return NULL;
9294		}
9295
9296
9297	<	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
9298	<	PyObject *resultobj;
9299	<	std::string arg1 = (std::string) "" ;
9300	<	BossSession *result;
9301	<	PyObject * obj0 = 0 ;
9302	<
9303	<	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
9304	<	if (obj0) {
9305	<	{
9306	<	if (PyString_Check(obj0))
9307	<	arg1 = std::string(PyString_AsString(obj0));
9308	<	else
9309	<	SWIG_exception(SWIG_TypeError, "string expected");
9310	<	}
9297	>	SWIGINTERN PyObject *_wrap_delete_vector_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9298	>	PyObject *resultobj = 0;
9299	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
9300	>	void *argp1 = 0 ;
9301	>	int res1 = 0 ;
9302	>	PyObject * obj0 = 0 ;
9303	>
9304	>	if (!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) SWIG_fail;
9305	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_DISOWN |  0 );
9306	>	if (!SWIG_IsOK(res1)) {
9307	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vector_string" "', argument " "1"" of type '" "std::vector<std::string > *""'");
9308	>	}
9309	>	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
9310	>	{
9311	>	try {
9312	>	delete arg1;
9313	>
9314	>	} catch (const std::exception& e) {
9315	>	SWIG_exception(SWIG_RuntimeError, e.what());
9316		}
9317	<	{
9318	<	try {
9319	<	result = (BossSession *)new BossSession(arg1);
9320	<
9321	<	}catch (const std::exception& e) {
9322	<	SWIG_exception(SWIG_RuntimeError, e.what());
9323	<	}
9317	>	}
9318	>	resultobj = SWIG_Py_Void();
9319	>	return resultobj;
9320	>	fail:
9321	>	return NULL;
9322	>	}
9323	>
9324	>
9325	>	SWIGINTERN PyObject *vector_string_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9326	>	PyObject *obj;
9327	>	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
9328	>	SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_NewClientData(obj));
9329	>	return SWIG_Py_Void();
9330	>	}
9331	>
9332	>	SWIGINTERN PyObject *_wrap_new_BossSession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9333	>	PyObject *resultobj = 0;
9334	>	std::string arg1 ;
9335	>	BossSession *result = 0 ;
9336	>	PyObject * obj0 = 0 ;
9337	>
9338	>	if (!PyArg_ParseTuple(args,(char *)"O:new_BossSession",&obj0)) SWIG_fail;
9339	>	{
9340	>	std::string *ptr = (std::string *)0;
9341	>	int res = SWIG_AsPtr_std_string(obj0, &ptr);
9342	>	if (!SWIG_IsOK(res) || !ptr) {
9343	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BossSession" "', argument " "1"" of type '" "std::string""'");
9344		}
9345	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
9346	<	return resultobj;
9347	<	fail:
9348	<	return NULL;
9345	>	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());
9353	>	}
9354	>	}
9355	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossSession, SWIG_POINTER_NEW |  0 );
9356	>	return resultobj;
9357	>	fail:
9358	>	return NULL;
9359		}
9360
9361
9362	<	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
9363	<	PyObject *resultobj;
9364	<	BossSession *arg1 = (BossSession *) 0 ;
9365	<	PyObject * obj0 = 0 ;
9366	<
9367	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
9368	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9369	<	{
9370	<	try {
9371	<	delete arg1;
2080	<
2081	<	}catch (const std::exception& e) {
2082	<	SWIG_exception(SWIG_RuntimeError, e.what());
2083	<	}
9362	>	SWIGINTERN PyObject *_wrap_new_BossSession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9363	>	PyObject *resultobj = 0;
9364	>	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());
9372		}
9373	<	Py_INCREF(Py_None); resultobj = Py_None;
9374	<	return resultobj;
9375	<	fail:
9376	<	return NULL;
9373	>	}
9374	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossSession, SWIG_POINTER_NEW |  0 );
9375	>	return resultobj;
9376	>	fail:
9377	>	return NULL;
9378		}
9379
9380
9381	<	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
9382	<	PyObject *resultobj;
9383	<	BossSession *arg1 = (BossSession *) 0 ;
9384	<	PyObject * obj0 = 0 ;
9385	<
9386	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
9387	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9388	<	{
9389	<	try {
9390	<	(arg1)->clear();
9391	<
9392	<	}catch (const std::exception& e) {
9393	<	SWIG_exception(SWIG_RuntimeError, e.what());
9394	<	}
9381	>	SWIGINTERN PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
9382	>	int argc;
9383	>	PyObject *argv[2];
9384	>	int ii;
9385	>
9386	>	if (!PyTuple_Check(args)) SWIG_fail;
9387	>	argc = PyObject_Length(args);
9388	>	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
9389	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
9390	>	}
9391	>	if (argc == 0) {
9392	>	return _wrap_new_BossSession__SWIG_1(self, args);
9393	>	}
9394	>	if (argc == 1) {
9395	>	int _v;
9396	>	int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
9397	>	_v = SWIG_CheckState(res);
9398	>	if (_v) {
9399	>	return _wrap_new_BossSession__SWIG_0(self, args);
9400		}
9401	<	Py_INCREF(Py_None); resultobj = Py_None;
9402	<	return resultobj;
9403	<	fail:
9404	<	return NULL;
9401	>	}
9402	>
9403	>	fail:
9404	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BossSession'");
9405	>	return NULL;
9406		}
9407
9408
9409	<	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
9410	<	PyObject *resultobj;
9411	<	BossSession *arg1 = (BossSession *) 0 ;
9412	<	std::string const &arg2_defvalue = "" ;
9413	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
9414	<	BossTask *result;
9415	<	std::string temp2 ;
9416	<	PyObject * obj0 = 0 ;
9417	<	PyObject * obj1 = 0 ;
9418	<
9419	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
9420	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9421	<	if (obj1) {
9422	<	{
9423	<	if (PyString_Check(obj1)) {
9424	<	temp2 = std::string(PyString_AsString(obj1));
9425	<	arg2 = &temp2;
9426	<	}else {
9427	<	SWIG_exception(SWIG_TypeError, "string expected");
2133	<	}
2134	<	}
9409	>	SWIGINTERN PyObject *_wrap_delete_BossSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9410	>	PyObject *resultobj = 0;
9411	>	BossSession *arg1 = (BossSession *) 0 ;
9412	>	void *argp1 = 0 ;
9413	>	int res1 = 0 ;
9414	>	PyObject * obj0 = 0 ;
9415	>
9416	>	if (!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) SWIG_fail;
9417	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, SWIG_POINTER_DISOWN |  0 );
9418	>	if (!SWIG_IsOK(res1)) {
9419	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BossSession" "', argument " "1"" of type '" "BossSession *""'");
9420	>	}
9421	>	arg1 = reinterpret_cast< BossSession * >(argp1);
9422	>	{
9423	>	try {
9424	>	delete arg1;
9425	>
9426	>	} catch (const std::exception& e) {
9427	>	SWIG_exception(SWIG_RuntimeError, e.what());
9428		}
9429	<	{
9430	<	try {
9431	<	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
9432	<
9433	<	}catch (const std::exception& e) {
9434	<	SWIG_exception(SWIG_RuntimeError, e.what());
9435	<	}
9429	>	}
9430	>	resultobj = SWIG_Py_Void();
9431	>	return resultobj;
9432	>	fail:
9433	>	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());
9455		}
9456	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
9457	<	return resultobj;
9458	<	fail:
9459	<	return NULL;
9456	>	}
9457	>	resultobj = SWIG_Py_Void();
9458	>	return resultobj;
9459	>	fail:
9460	>	return NULL;
9461		}
9462
9463
9464	<	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
9465	<	PyObject *resultobj;
9466	<	BossSession *arg1 = (BossSession *) 0 ;
9467	<	BossTask *arg2 = (BossTask *) 0 ;
9468	<	PyObject * obj0 = 0 ;
9469	<	PyObject * obj1 = 0 ;
9470	<
9471	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
9472	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9473	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9474	<	{
9475	<	try {
9476	<	(arg1)->destroyBossTask(arg2);
9477	<
9478	<	}catch (const std::exception& e) {
9479	<	SWIG_exception(SWIG_RuntimeError, e.what());
9480	<	}
9464	>	SWIGINTERN PyObject *_wrap_BossSession_makeBossTask__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9465	>	PyObject *resultobj = 0;
9466	>	BossSession *arg1 = (BossSession *) 0 ;
9467	>	std::string *arg2 = 0 ;
9468	>	BossTask *result = 0 ;
9469	>	void *argp1 = 0 ;
9470	>	int res1 = 0 ;
9471	>	int res2 = SWIG_OLDOBJ ;
9472	>	PyObject * obj0 = 0 ;
9473	>	PyObject * obj1 = 0 ;
9474	>
9475	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_makeBossTask",&obj0,&obj1)) SWIG_fail;
9476	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9477	>	if (!SWIG_IsOK(res1)) {
9478	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_makeBossTask" "', argument " "1"" of type '" "BossSession *""'");
9479	>	}
9480	>	arg1 = reinterpret_cast< BossSession * >(argp1);
9481	>	{
9482	>	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	<	Py_INCREF(Py_None); resultobj = Py_None;
9488	<	return resultobj;
9489	<	fail:
9490	<	return NULL;
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());
9497	>	}
9498	>	}
9499	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, 0 |  0 );
9500	>	if (SWIG_IsNewObj(res2)) delete arg2;
9501	>	return resultobj;
9502	>	fail:
9503	>	if (SWIG_IsNewObj(res2)) delete arg2;
9504	>	return NULL;
9505		}
9506
9507
9508	<	static PyObject *_wrap_BossSession_showCHTools__SWIG_0(PyObject *self, PyObject *args) {
9509	<	PyObject *resultobj;
9510	<	BossSession *arg1 = (BossSession *) 0 ;
9511	<	SwigValueWrapper< std::vector<std::string > > result;
9512	<	PyObject * obj0 = 0 ;
9513	<
9514	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showCHTools",&obj0)) goto fail;
9515	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9516	<	{
9517	<	try {
9518	<	result = (arg1)->showCHTools();
9519	<
9520	<	}catch (const std::exception& e) {
9521	<	SWIG_exception(SWIG_RuntimeError, e.what());
9522	<	}
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());
9527		}
9528	<	{
9529	<	std::vector<std::string > * resultptr;
9530	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
9531	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
9528	>	}
9529	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, 0 |  0 );
9530	>	return resultobj;
9531	>	fail:
9532	>	return NULL;
9533	>	}
9534	>
9535	>
9536	>	SWIGINTERN PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
9537	>	int argc;
9538	>	PyObject *argv[3];
9539	>	int ii;
9540	>
9541	>	if (!PyTuple_Check(args)) SWIG_fail;
9542	>	argc = PyObject_Length(args);
9543	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
9544	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
9545	>	}
9546	>	if (argc == 1) {
9547	>	int _v;
9548	>	void *vptr = 0;
9549	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
9550	>	_v = SWIG_CheckState(res);
9551	>	if (_v) {
9552	>	return _wrap_BossSession_makeBossTask__SWIG_1(self, args);
9553		}
9554	<	return resultobj;
9555	<	fail:
9556	<	return NULL;
9554	>	}
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	>	}
9566	>	}
9567	>	}
9568	>
9569	>	fail:
9570	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_makeBossTask'");
9571	>	return NULL;
9572		}
9573
9574
9575	<	static PyObject *_wrap_BossSession_showProgramTypes__SWIG_0(PyObject *self, PyObject *args) {
9576	<	PyObject *resultobj;
9577	<	BossSession *arg1 = (BossSession *) 0 ;
9578	<	SwigValueWrapper< std::vector<std::string > > result;
9579	<	PyObject * obj0 = 0 ;
9580	<
9581	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showProgramTypes",&obj0)) goto fail;
9582	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9583	<	{
9584	<	try {
9585	<	result = (arg1)->showProgramTypes();
9586	<
9587	<	}catch (const std::exception& e) {
9588	<	SWIG_exception(SWIG_RuntimeError, e.what());
9589	<	}
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());
9602		}
9603	<	{
9604	<	std::vector<std::string > * resultptr;
9605	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
9606	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
9603	>	}
9604	>	resultobj = SWIG_Py_Void();
9605	>	return resultobj;
9606	>	fail:
9607	>	return NULL;
9608	>	}
9609	>
9610	>
9611	>	SWIGINTERN PyObject *_wrap_BossSession_defaultCHTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9612	>	PyObject *resultobj = 0;
9613	>	BossSession *arg1 = (BossSession *) 0 ;
9614	>	std::string result;
9615	>	void *argp1 = 0 ;
9616	>	int res1 = 0 ;
9617	>	PyObject * obj0 = 0 ;
9618	>
9619	>	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) SWIG_fail;
9620	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9621	>	if (!SWIG_IsOK(res1)) {
9622	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultCHTool" "', argument " "1"" of type '" "BossSession *""'");
9623	>	}
9624	>	arg1 = reinterpret_cast< BossSession * >(argp1);
9625	>	{
9626	>	try {
9627	>	result = (arg1)->defaultCHTool();
9628	>	} catch (const std::exception& e) {
9629	>	SWIG_exception(SWIG_RuntimeError, e.what());
9630		}
9631	<	return resultobj;
9632	<	fail:
9633	<	return NULL;
9631	>	}
9632	>	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9633	>	return resultobj;
9634	>	fail:
9635	>	return NULL;
9636		}
9637
9638
9639	<	static PyObject *_wrap_BossSession_showRTMon__SWIG_0(PyObject *self, PyObject *args) {
9640	<	PyObject *resultobj;
9641	<	BossSession *arg1 = (BossSession *) 0 ;
9642	<	SwigValueWrapper< std::vector<std::string > > result;
9643	<	PyObject * obj0 = 0 ;
9644	<
9645	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showRTMon",&obj0)) goto fail;
9646	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9647	<	{
9648	<	try {
9649	<	result = (arg1)->showRTMon();
9650	<
9651	<	}catch (const std::exception& e) {
9652	<	SWIG_exception(SWIG_RuntimeError, e.what());
9653	<	}
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());
9658		}
9659	<	{
9660	<	std::vector<std::string > * resultptr;
9661	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
9662	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
9659	>	}
9660	>	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9661	>	return resultobj;
9662	>	fail:
9663	>	return NULL;
9664	>	}
9665	>
9666	>
9667	>	SWIGINTERN PyObject *_wrap_BossSession_defaultRTMon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9668	>	PyObject *resultobj = 0;
9669	>	BossSession *arg1 = (BossSession *) 0 ;
9670	>	std::string result;
9671	>	void *argp1 = 0 ;
9672	>	int res1 = 0 ;
9673	>	PyObject * obj0 = 0 ;
9674	>
9675	>	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) SWIG_fail;
9676	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9677	>	if (!SWIG_IsOK(res1)) {
9678	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultRTMon" "', argument " "1"" of type '" "BossSession *""'");
9679	>	}
9680	>	arg1 = reinterpret_cast< BossSession * >(argp1);
9681	>	{
9682	>	try {
9683	>	result = (arg1)->defaultRTMon();
9684	>	} catch (const std::exception& e) {
9685	>	SWIG_exception(SWIG_RuntimeError, e.what());
9686		}
9687	<	return resultobj;
9688	<	fail:
9689	<	return NULL;
9687	>	}
9688	>	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9689	>	return resultobj;
9690	>	fail:
9691	>	return NULL;
9692		}
9693
9694
9695	<	static PyObject *_wrap_BossSession_showSchedulers__SWIG_0(PyObject *self, PyObject *args) {
9696	<	PyObject *resultobj;
9697	<	BossSession *arg1 = (BossSession *) 0 ;
9698	<	SwigValueWrapper< std::vector<std::string > > result;
9699	<	PyObject * obj0 = 0 ;
9700	<
9701	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_showSchedulers",&obj0)) goto fail;
9702	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9703	<	{
9704	<	try {
9705	<	result = (arg1)->showSchedulers();
9706	<
9707	<	}catch (const std::exception& e) {
9708	<	SWIG_exception(SWIG_RuntimeError, e.what());
9709	<	}
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());
9714		}
9715	<	{
9716	<	std::vector<std::string > * resultptr;
9717	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
9718	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
9715	>	}
9716	>	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9717	>	return resultobj;
9718	>	fail:
9719	>	return NULL;
9720	>	}
9721	>
9722	>
9723	>	SWIGINTERN PyObject *_wrap_BossSession_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9724	>	PyObject *resultobj = 0;
9725	>	BossSession *arg1 = (BossSession *) 0 ;
9726	>	std::string result;
9727	>	void *argp1 = 0 ;
9728	>	int res1 = 0 ;
9729	>	PyObject * obj0 = 0 ;
9730	>
9731	>	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) SWIG_fail;
9732	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9733	>	if (!SWIG_IsOK(res1)) {
9734	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_version" "', argument " "1"" of type '" "BossSession *""'");
9735	>	}
9736	>	arg1 = reinterpret_cast< BossSession * >(argp1);
9737	>	{
9738	>	try {
9739	>	result = (arg1)->version();
9740	>	} catch (const std::exception& e) {
9741	>	SWIG_exception(SWIG_RuntimeError, e.what());
9742		}
9743	<	return resultobj;
9744	<	fail:
9745	<	return NULL;
9743	>	}
9744	>	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9745	>	return resultobj;
9746	>	fail:
9747	>	return NULL;
9748		}
9749
9750
9751	<	static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
9752	<	PyObject *resultobj;
9753	<	BossSession *arg1 = (BossSession *) 0 ;
9754	<	std::string result;
9755	<	PyObject * obj0 = 0 ;
9756	<
9757	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) goto fail;
9758	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9759	<	{
9760	<	try {
9761	<	result = (arg1)->defaultCHTool();
9762	<
9763	<	}catch (const std::exception& e) {
9764	<	SWIG_exception(SWIG_RuntimeError, e.what());
9765	<	}
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());
9770		}
9771	<	{
9772	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
9771	>	}
9772	>	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9773	>	return resultobj;
9774	>	fail:
9775	>	return NULL;
9776	>	}
9777	>
9778	>
9779	>	SWIGINTERN PyObject *_wrap_BossSession_showConfigs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9780	>	PyObject *resultobj = 0;
9781	>	BossSession *arg1 = (BossSession *) 0 ;
9782	>	bool arg2 ;
9783	>	int result;
9784	>	void *argp1 = 0 ;
9785	>	int res1 = 0 ;
9786	>	bool val2 ;
9787	>	int ecode2 = 0 ;
9788	>	PyObject * obj0 = 0 ;
9789	>	PyObject * obj1 = 0 ;
9790	>
9791	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_showConfigs",&obj0,&obj1)) SWIG_fail;
9792	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9793	>	if (!SWIG_IsOK(res1)) {
9794	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_showConfigs" "', argument " "1"" of type '" "BossSession *""'");
9795	>	}
9796	>	arg1 = reinterpret_cast< BossSession * >(argp1);
9797	>	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());
9807		}
9808	<	return resultobj;
9809	<	fail:
9810	<	return NULL;
9808	>	}
9809	>	resultobj = SWIG_From_int(static_cast< int >(result));
9810	>	return resultobj;
9811	>	fail:
9812	>	return NULL;
9813		}
9814
9815
9816	<	static PyObject *_wrap_BossSession_defaultProgramType(PyObject *self, PyObject *args) {
9817	<	PyObject *resultobj;
9818	<	BossSession *arg1 = (BossSession *) 0 ;
9819	<	std::string result;
9820	<	PyObject * obj0 = 0 ;
9821	<
9822	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) goto fail;
9823	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9824	<	{
9825	<	try {
9826	<	result = (arg1)->defaultProgramType();
9827	<
9828	<	}catch (const std::exception& e) {
9829	<	SWIG_exception(SWIG_RuntimeError, e.what());
9830	<	}
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());
9835		}
9836	<	{
9837	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
9836	>	}
9837	>	resultobj = SWIG_From_int(static_cast< int >(result));
9838	>	return resultobj;
9839	>	fail:
9840	>	return NULL;
9841	>	}
9842	>
9843	>
9844	>	SWIGINTERN PyObject *_wrap_BossSession_showConfigs(PyObject *self, PyObject *args) {
9845	>	int argc;
9846	>	PyObject *argv[3];
9847	>	int ii;
9848	>
9849	>	if (!PyTuple_Check(args)) SWIG_fail;
9850	>	argc = PyObject_Length(args);
9851	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
9852	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
9853	>	}
9854	>	if (argc == 1) {
9855	>	int _v;
9856	>	void *vptr = 0;
9857	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
9858	>	_v = SWIG_CheckState(res);
9859	>	if (_v) {
9860	>	return _wrap_BossSession_showConfigs__SWIG_1(self, args);
9861		}
9862	<	return resultobj;
9863	<	fail:
9864	<	return NULL;
9862	>	}
9863	>	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	>	}
9876	>	}
9877	>	}
9878	>
9879	>	fail:
9880	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_showConfigs'");
9881	>	return NULL;
9882		}
9883
9884
9885	<	static PyObject *_wrap_BossSession_defaultRTMon(PyObject *self, PyObject *args) {
9886	<	PyObject *resultobj;
9887	<	BossSession *arg1 = (BossSession *) 0 ;
9888	<	std::string result;
9889	<	PyObject * obj0 = 0 ;
9890	<
9891	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) goto fail;
9892	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9893	<	{
9894	<	try {
9895	<	result = (arg1)->defaultRTMon();
9896	<
9897	<	}catch (const std::exception& e) {
9898	<	SWIG_exception(SWIG_RuntimeError, e.what());
9899	<	}
9885	>	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9886	>	PyObject *resultobj = 0;
9887	>	BossSession *arg1 = (BossSession *) 0 ;
9888	>	std::string arg2 ;
9889	>	std::string arg3 ;
9890	>	std::string arg4 ;
9891	>	int result;
9892	>	void *argp1 = 0 ;
9893	>	int res1 = 0 ;
9894	>	PyObject * obj0 = 0 ;
9895	>	PyObject * obj1 = 0 ;
9896	>	PyObject * obj2 = 0 ;
9897	>	PyObject * obj3 = 0 ;
9898	>
9899	>	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9900	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9901	>	if (!SWIG_IsOK(res1)) {
9902	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTupdate" "', argument " "1"" of type '" "BossSession *""'");
9903	>	}
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	<	{
9912	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
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	<	return resultobj;
9921	<	fail:
9922	<	return NULL;
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""'");
9928	>	}
9929	>	arg4 = *ptr;
9930	>	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());
9937	>	}
9938	>	}
9939	>	resultobj = SWIG_From_int(static_cast< int >(result));
9940	>	return resultobj;
9941	>	fail:
9942	>	return NULL;
9943		}
9944
9945
9946	<	static PyObject *_wrap_BossSession_defaultScheduler(PyObject *self, PyObject *args) {
9947	<	PyObject *resultobj;
9948	<	BossSession *arg1 = (BossSession *) 0 ;
9949	<	std::string result;
9950	<	PyObject * obj0 = 0 ;
9951	<
9952	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) goto fail;
9953	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
9954	<	{
9955	<	try {
9956	<	result = (arg1)->defaultScheduler();
9957	<
9958	<	}catch (const std::exception& e) {
9959	<	SWIG_exception(SWIG_RuntimeError, e.what());
9960	<	}
9946	>	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947	>	PyObject *resultobj = 0;
9948	>	BossSession *arg1 = (BossSession *) 0 ;
9949	>	std::string arg2 ;
9950	>	std::string arg3 ;
9951	>	int result;
9952	>	void *argp1 = 0 ;
9953	>	int res1 = 0 ;
9954	>	PyObject * obj0 = 0 ;
9955	>	PyObject * obj1 = 0 ;
9956	>	PyObject * obj2 = 0 ;
9957	>
9958	>	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_RTupdate",&obj0,&obj1,&obj2)) SWIG_fail;
9959	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9960	>	if (!SWIG_IsOK(res1)) {
9961	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTupdate" "', argument " "1"" of type '" "BossSession *""'");
9962	>	}
9963	>	arg1 = reinterpret_cast< BossSession * >(argp1);
9964	>	{
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	<	{
9971	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
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""'");
9978		}
9979	<	return resultobj;
9980	<	fail:
9981	<	return NULL;
9979	>	arg3 = *ptr;
9980	>	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());
9987	>	}
9988	>	}
9989	>	resultobj = SWIG_From_int(static_cast< int >(result));
9990	>	return resultobj;
9991	>	fail:
9992	>	return NULL;
9993		}
9994
9995
9996	<	static PyObject *_wrap_BossSession_version(PyObject *self, PyObject *args) {
9997	<	PyObject *resultobj;
9998	<	BossSession *arg1 = (BossSession *) 0 ;
9999	<	std::string result;
10000	<	PyObject * obj0 = 0 ;
10001	<
10002	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) goto fail;
10003	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
10004	<	{
10005	<	try {
10006	<	result = (arg1)->version();
10007	<
10008	<	}catch (const std::exception& e) {
10009	<	SWIG_exception(SWIG_RuntimeError, e.what());
10010	<	}
9996	>	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9997	>	PyObject *resultobj = 0;
9998	>	BossSession *arg1 = (BossSession *) 0 ;
9999	>	std::string arg2 ;
10000	>	int result;
10001	>	void *argp1 = 0 ;
10002	>	int res1 = 0 ;
10003	>	PyObject * obj0 = 0 ;
10004	>	PyObject * obj1 = 0 ;
10005	>
10006	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_RTupdate",&obj0,&obj1)) SWIG_fail;
10007	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10008	>	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	<	{
10019	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
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());
10026		}
10027	<	return resultobj;
10028	<	fail:
10029	<	return NULL;
10027	>	}
10028	>	resultobj = SWIG_From_int(static_cast< int >(result));
10029	>	return resultobj;
10030	>	fail:
10031	>	return NULL;
10032		}
10033
10034
10035	<	static PyObject *_wrap_BossSession_clientID(PyObject *self, PyObject *args) {
10036	<	PyObject *resultobj;
10037	<	BossSession *arg1 = (BossSession *) 0 ;
10038	<	std::string result;
10039	<	PyObject * obj0 = 0 ;
10040	<
10041	<	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) goto fail;
10042	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
10043	<	{
10044	<	try {
10045	<	result = (arg1)->clientID();
10046	<
10047	<	}catch (const std::exception& e) {
10048	<	SWIG_exception(SWIG_RuntimeError, e.what());
10035	>	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10036	>	PyObject *resultobj = 0;
10037	>	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());
10054	>	}
10055	>	}
10056	>	resultobj = SWIG_From_int(static_cast< int >(result));
10057	>	return resultobj;
10058	>	fail:
10059	>	return NULL;
10060	>	}
10061	>
10062	>
10063	>	SWIGINTERN PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
10064	>	int argc;
10065	>	PyObject *argv[5];
10066	>	int ii;
10067	>
10068	>	if (!PyTuple_Check(args)) SWIG_fail;
10069	>	argc = PyObject_Length(args);
10070	>	for (ii = 0; (ii < argc) && (ii < 4); ii++) {
10071	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
10072	>	}
10073	>	if (argc == 1) {
10074	>	int _v;
10075	>	void *vptr = 0;
10076	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
10077	>	_v = SWIG_CheckState(res);
10078	>	if (_v) {
10079	>	return _wrap_BossSession_RTupdate__SWIG_3(self, args);
10080	>	}
10081	>	}
10082	>	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);
10108		}
10109	+	}
10110		}
10111	<	{
10112	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
10111	>	}
10112	>	if (argc == 4) {
10113	>	int _v;
10114	>	void *vptr = 0;
10115	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
10116	>	_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	>	}
10129	>	}
10130	>	}
10131		}
10132	<	return resultobj;
10133	<	fail:
10134	<	return NULL;
10132	>	}
10133	>
10134	>	fail:
10135	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_RTupdate'");
10136	>	return NULL;
10137		}
10138
10139
10140	<	static PyObject *_wrap_BossSession_showConfigs(PyObject *self, PyObject *args) {
10141	<	PyObject *resultobj;
10142	<	BossSession *arg1 = (BossSession *) 0 ;
10143	<	bool arg2 = (bool) false ;
10144	<	int result;
10145	<	PyObject * obj0 = 0 ;
10146	<	PyObject * obj1 = 0 ;
10147	<
10148	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_showConfigs",&obj0,&obj1)) goto fail;
10149	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
10150	<	if (obj1) {
10151	<	arg2 = PyInt_AsLong(obj1) ? true : false;
10152	<	if (PyErr_Occurred()) SWIG_fail;
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	<	{
10177	<	try {
2450	<	result = (int)(arg1)->showConfigs(arg2);
2451	<
2452	<	}catch (const std::exception& e) {
2453	<	SWIG_exception(SWIG_RuntimeError, e.what());
2454	<	}
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	<	resultobj = PyInt_FromLong((long)result);
10180	<	return resultobj;
10181	<	fail:
10182	<	return NULL;
10179	>	arg2 = ptr;
10180	>	}
10181	>	{
10182	>	std::string *ptr = (std::string *)0;
10183	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10184	>	if (!SWIG_IsOK(res3)) {
10185	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10186	>	}
10187	>	if (!ptr) {
10188	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10189	>	}
10190	>	arg3 = ptr;
10191	>	}
10192	>	ecode4 = SWIG_AsVal_bool(obj3, &val4);
10193	>	if (!SWIG_IsOK(ecode4)) {
10194	>	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossSession_listMatch" "', argument " "4"" of type '" "bool""'");
10195	>	}
10196	>	arg4 = static_cast< bool >(val4);
10197	>	{
10198	>	std::string *ptr = (std::string *)0;
10199	>	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10200	>	if (!SWIG_IsOK(res5)) {
10201	>	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_listMatch" "', argument " "5"" of type '" "std::string const &""'");
10202	>	}
10203	>	if (!ptr) {
10204	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "5"" of type '" "std::string const &""'");
10205	>	}
10206	>	arg5 = ptr;
10207	>	}
10208	>	{
10209	>	std::string *ptr = (std::string *)0;
10210	>	res6 = SWIG_AsPtr_std_string(obj5, &ptr);
10211	>	if (!SWIG_IsOK(res6)) {
10212	>	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BossSession_listMatch" "', argument " "6"" of type '" "std::string const &""'");
10213	>	}
10214	>	if (!ptr) {
10215	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "6"" of type '" "std::string const &""'");
10216	>	}
10217	>	arg6 = ptr;
10218	>	}
10219	>	{
10220	>	try {
10221	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
10222	>	} catch (const std::exception& e) {
10223	>	SWIG_exception(SWIG_RuntimeError, e.what());
10224	>	}
10225	>	}
10226	>	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
10227	>	if (SWIG_IsNewObj(res2)) delete arg2;
10228	>	if (SWIG_IsNewObj(res3)) delete arg3;
10229	>	if (SWIG_IsNewObj(res5)) delete arg5;
10230	>	if (SWIG_IsNewObj(res6)) delete arg6;
10231	>	return resultobj;
10232	>	fail:
10233	>	if (SWIG_IsNewObj(res2)) delete arg2;
10234	>	if (SWIG_IsNewObj(res3)) delete arg3;
10235	>	if (SWIG_IsNewObj(res5)) delete arg5;
10236	>	if (SWIG_IsNewObj(res6)) delete arg6;
10237	>	return NULL;
10238		}
10239
10240
10241	<	static PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
10242	<	PyObject *resultobj;
10243	<	BossSession *arg1 = (BossSession *) 0 ;
10244	<	std::string arg2 = (std::string) "all" ;
10245	<	std::string arg3 = (std::string) "all" ;
10246	<	std::string arg4 = (std::string) "" ;
10247	<	int result;
10248	<	PyObject * obj0 = 0 ;
10249	<	PyObject * obj1 = 0 ;
10250	<	PyObject * obj2 = 0 ;
10251	<	PyObject * obj3 = 0 ;
10252	<
10253	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
10254	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
10255	<	if (obj1) {
10256	<	{
10257	<	if (PyString_Check(obj1))
10258	<	arg2 = std::string(PyString_AsString(obj1));
10259	<	else
10260	<	SWIG_exception(SWIG_TypeError, "string expected");
10261	<	}
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 (obj2) {
10275	<	{
2487	<	if (PyString_Check(obj2))
2488	<	arg3 = std::string(PyString_AsString(obj2));
2489	<	else
2490	<	SWIG_exception(SWIG_TypeError, "string expected");
2491	<	}
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	<	if (obj3) {
10278	<	{
10279	<	if (PyString_Check(obj3))
10280	<	arg4 = std::string(PyString_AsString(obj3));
10281	<	else
10282	<	SWIG_exception(SWIG_TypeError, "string expected");
10283	<	}
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	<	{
10286	<	try {
2503	<	result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2504	<
2505	<	}catch (const std::exception& e) {
2506	<	SWIG_exception(SWIG_RuntimeError, e.what());
2507	<	}
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	<	resultobj = PyInt_FromLong((long)result);
10289	<	return resultobj;
10290	<	fail:
10291	<	return NULL;
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	<	static PyObject *_wrap_BossSession_listMatch__SWIG_0(PyObject *self, PyObject *args) {
10327	<	PyObject *resultobj;
10328	<	BossSession *arg1 = (BossSession *) 0 ;
10329	<	std::string *arg2 = 0 ;
10330	<	std::string *arg3 = 0 ;
10331	<	bool arg4 = (bool) false ;
10332	<	std::string const &arg5_defvalue = "" ;
10333	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
10334	<	std::string const &arg6_defvalue = "" ;
10335	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
10336	<	SwigValueWrapper< std::vector<std::string > > result;
10337	<	std::string temp2 ;
10338	<	std::string temp3 ;
10339	<	std::string temp5 ;
10340	<	std::string temp6 ;
10341	<	PyObject * obj0 = 0 ;
10342	<	PyObject * obj1 = 0 ;
10343	<	PyObject * obj2 = 0 ;
10344	<	PyObject * obj3 = 0 ;
10345	<	PyObject * obj4 = 0 ;
10346	<	PyObject * obj5 = 0 ;
10347	<
10348	<	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10349	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
10350	<	{
10351	<	if (PyString_Check(obj1)) {
10352	<	temp2 = std::string(PyString_AsString(obj1));
10353	<	arg2 = &temp2;
10354	<	}else {
2545	<	SWIG_exception(SWIG_TypeError, "string expected");
2546	<	}
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	<	{
10357	<	if (PyString_Check(obj2)) {
10358	<	temp3 = std::string(PyString_AsString(obj2));
10359	<	arg3 = &temp3;
10360	<	}else {
10361	<	SWIG_exception(SWIG_TypeError, "string expected");
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 &""'");
10434	>	}
10435	>	arg3 = ptr;
10436	>	}
10437	>	{
10438	>	try {
10439	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3);
10440	>	} catch (const std::exception& e) {
10441	>	SWIG_exception(SWIG_RuntimeError, e.what());
10442	>	}
10443	>	}
10444	>	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
10445	>	if (SWIG_IsNewObj(res2)) delete arg2;
10446	>	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;
10452	>	}
10453	>
10454	>
10455	>	SWIGINTERN PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
10456	>	int argc;
10457	>	PyObject *argv[7];
10458	>	int ii;
10459	>
10460	>	if (!PyTuple_Check(args)) SWIG_fail;
10461	>	argc = PyObject_Length(args);
10462	>	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
10463	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
10464	>	}
10465	>	if (argc == 3) {
10466	>	int _v;
10467	>	void *vptr = 0;
10468	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
10469	>	_v = SWIG_CheckState(res);
10470	>	if (_v) {
10471	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
10472	>	_v = SWIG_CheckState(res);
10473	>	if (_v) {
10474	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
10475	>	_v = SWIG_CheckState(res);
10476	>	if (_v) {
10477	>	return _wrap_BossSession_listMatch__SWIG_3(self, args);
10478		}
10479	+	}
10480		}
10481	<	if (obj3) {
10482	<	arg4 = PyInt_AsLong(obj3) ? true : false;
10483	<	if (PyErr_Occurred()) SWIG_fail;
10481	>	}
10482	>	if (argc == 4) {
10483	>	int _v;
10484	>	void *vptr = 0;
10485	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
10486	>	_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	>	}
10501	>	}
10502	>	}
10503		}
10504	<	if (obj4) {
10505	<	{
10506	<	if (PyString_Check(obj4)) {
10507	<	temp5 = std::string(PyString_AsString(obj4));
10508	<	arg5 = &temp5;
10509	<	}else {
10510	<	SWIG_exception(SWIG_TypeError, "string expected");
10504	>	}
10505	>	if (argc == 5) {
10506	>	int _v;
10507	>	void *vptr = 0;
10508	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
10509	>	_v = SWIG_CheckState(res);
10510	>	if (_v) {
10511	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
10512	>	_v = SWIG_CheckState(res);
10513	>	if (_v) {
10514	>	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);
10526		}
10527	+	}
10528		}
10529	+	}
10530		}
10531	<	if (obj5) {
10532	<	{
10533	<	if (PyString_Check(obj5)) {
10534	<	temp6 = std::string(PyString_AsString(obj5));
10535	<	arg6 = &temp6;
10536	<	}else {
10537	<	SWIG_exception(SWIG_TypeError, "string expected");
10531	>	}
10532	>	if (argc == 6) {
10533	>	int _v;
10534	>	void *vptr = 0;
10535	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
10536	>	_v = SWIG_CheckState(res);
10537	>	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	>	}
10557		}
10558	+	}
10559		}
10560	+	}
10561		}
10562	<	{
10563	<	try {
10564	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
10565	<
10566	<	}catch (const std::exception& e) {
10567	<	SWIG_exception(SWIG_RuntimeError, e.what());
10568	<	}
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	<	{
10616	<	std::vector<std::string > * resultptr;
2590	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2591	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
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	<	return resultobj;
10619	<	fail:
10620	<	return NULL;
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	<	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
10699	<	PyObject *resultobj;
10700	<	BossSession *arg1 = (BossSession *) 0 ;
10701	<	int arg2 = (int) SCHEDULED ;
10702	<	std::string const &arg3_defvalue = "all" ;
10703	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
10704	<	std::string const &arg4_defvalue = "all" ;
10705	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
10706	<	std::string const &arg5_defvalue = "" ;
10707	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
10708	<	std::string arg6 = (std::string) "" ;
10709	<	std::string arg7 = (std::string) "" ;
10710	<	std::string arg8 = (std::string) "" ;
10711	<	std::string arg9 = (std::string) "" ;
10712	<	std::string temp3 ;
10713	<	std::string temp4 ;
10714	<	std::string temp5 ;
10715	<	PyObject * obj0 = 0 ;
10716	<	PyObject * obj2 = 0 ;
10717	<	PyObject * obj3 = 0 ;
10718	<	PyObject * obj4 = 0 ;
10719	<	PyObject * obj5 = 0 ;
10720	<	PyObject * obj6 = 0 ;
10721	<	PyObject * obj7 = 0 ;
10722	<	PyObject * obj8 = 0 ;
10723	<
10724	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
10725	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
10726	<	if (obj2) {
10727	<	{
10728	<	if (PyString_Check(obj2)) {
10729	<	temp3 = std::string(PyString_AsString(obj2));
10730	<	arg3 = &temp3;
10731	<	}else {
10732	<	SWIG_exception(SWIG_TypeError, "string expected");
10733	<	}
10698	>	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10699	>	PyObject *resultobj = 0;
10700	>	BossSession *arg1 = (BossSession *) 0 ;
10701	>	int arg2 ;
10702	>	std::string *arg3 = 0 ;
10703	>	std::string *arg4 = 0 ;
10704	>	std::string *arg5 = 0 ;
10705	>	std::string arg6 ;
10706	>	std::string arg7 ;
10707	>	std::string arg8 ;
10708	>	void *argp1 = 0 ;
10709	>	int res1 = 0 ;
10710	>	int val2 ;
10711	>	int ecode2 = 0 ;
10712	>	int res3 = SWIG_OLDOBJ ;
10713	>	int res4 = SWIG_OLDOBJ ;
10714	>	int res5 = SWIG_OLDOBJ ;
10715	>	PyObject * obj0 = 0 ;
10716	>	PyObject * obj1 = 0 ;
10717	>	PyObject * obj2 = 0 ;
10718	>	PyObject * obj3 = 0 ;
10719	>	PyObject * obj4 = 0 ;
10720	>	PyObject * obj5 = 0 ;
10721	>	PyObject * obj6 = 0 ;
10722	>	PyObject * obj7 = 0 ;
10723	>
10724	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
10725	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10726	>	if (!SWIG_IsOK(res1)) {
10727	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
10728	>	}
10729	>	arg1 = reinterpret_cast< BossSession * >(argp1);
10730	>	ecode2 = SWIG_AsVal_int(obj1, &val2);
10731	>	if (!SWIG_IsOK(ecode2)) {
10732	>	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
10733	>	}
10734	>	arg2 = static_cast< int >(val2);
10735	>	{
10736	>	std::string *ptr = (std::string *)0;
10737	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10738	>	if (!SWIG_IsOK(res3)) {
10739	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10740	>	}
10741	>	if (!ptr) {
10742	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10743	>	}
10744	>	arg3 = ptr;
10745	>	}
10746	>	{
10747	>	std::string *ptr = (std::string *)0;
10748	>	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
10749	>	if (!SWIG_IsOK(res4)) {
10750	>	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10751	>	}
10752	>	if (!ptr) {
10753	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10754	>	}
10755	>	arg4 = ptr;
10756	>	}
10757	>	{
10758	>	std::string *ptr = (std::string *)0;
10759	>	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10760	>	if (!SWIG_IsOK(res5)) {
10761	>	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10762	>	}
10763	>	if (!ptr) {
10764	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10765	>	}
10766	>	arg5 = ptr;
10767	>	}
10768	>	{
10769	>	std::string *ptr = (std::string *)0;
10770	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
10771	>	if (!SWIG_IsOK(res) || !ptr) {
10772	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "6"" of type '" "std::string""'");
10773	>	}
10774	>	arg6 = *ptr;
10775	>	if (SWIG_IsNewObj(res)) delete ptr;
10776	>	}
10777	>	{
10778	>	std::string *ptr = (std::string *)0;
10779	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
10780	>	if (!SWIG_IsOK(res) || !ptr) {
10781	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "7"" of type '" "std::string""'");
10782	>	}
10783	>	arg7 = *ptr;
10784	>	if (SWIG_IsNewObj(res)) delete ptr;
10785	>	}
10786	>	{
10787	>	std::string *ptr = (std::string *)0;
10788	>	int res = SWIG_AsPtr_std_string(obj7, &ptr);
10789	>	if (!SWIG_IsOK(res) || !ptr) {
10790	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "8"" of type '" "std::string""'");
10791	>	}
10792	>	arg8 = *ptr;
10793	>	if (SWIG_IsNewObj(res)) delete ptr;
10794	>	}
10795	>	{
10796	>	try {
10797	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8);
10798	>	} catch (const std::exception& e) {
10799	>	SWIG_exception(SWIG_RuntimeError, e.what());
10800	>	}
10801	>	}
10802	>	resultobj = SWIG_Py_Void();
10803	>	if (SWIG_IsNewObj(res3)) delete arg3;
10804	>	if (SWIG_IsNewObj(res4)) delete arg4;
10805	>	if (SWIG_IsNewObj(res5)) delete arg5;
10806	>	return resultobj;
10807	>	fail:
10808	>	if (SWIG_IsNewObj(res3)) delete arg3;
10809	>	if (SWIG_IsNewObj(res4)) delete arg4;
10810	>	if (SWIG_IsNewObj(res5)) delete arg5;
10811	>	return NULL;
10812	>	}
10813	>
10814	>
10815	>	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10816	>	PyObject *resultobj = 0;
10817	>	BossSession *arg1 = (BossSession *) 0 ;
10818	>	int arg2 ;
10819	>	std::string *arg3 = 0 ;
10820	>	std::string *arg4 = 0 ;
10821	>	std::string *arg5 = 0 ;
10822	>	std::string arg6 ;
10823	>	std::string arg7 ;
10824	>	void *argp1 = 0 ;
10825	>	int res1 = 0 ;
10826	>	int val2 ;
10827	>	int ecode2 = 0 ;
10828	>	int res3 = SWIG_OLDOBJ ;
10829	>	int res4 = SWIG_OLDOBJ ;
10830	>	int res5 = SWIG_OLDOBJ ;
10831	>	PyObject * obj0 = 0 ;
10832	>	PyObject * obj1 = 0 ;
10833	>	PyObject * obj2 = 0 ;
10834	>	PyObject * obj3 = 0 ;
10835	>	PyObject * obj4 = 0 ;
10836	>	PyObject * obj5 = 0 ;
10837	>	PyObject * obj6 = 0 ;
10838	>
10839	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
10840	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10841	>	if (!SWIG_IsOK(res1)) {
10842	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
10843	>	}
10844	>	arg1 = reinterpret_cast< BossSession * >(argp1);
10845	>	ecode2 = SWIG_AsVal_int(obj1, &val2);
10846	>	if (!SWIG_IsOK(ecode2)) {
10847	>	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
10848	>	}
10849	>	arg2 = static_cast< int >(val2);
10850	>	{
10851	>	std::string *ptr = (std::string *)0;
10852	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10853	>	if (!SWIG_IsOK(res3)) {
10854	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10855	>	}
10856	>	if (!ptr) {
10857	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10858	>	}
10859	>	arg3 = ptr;
10860	>	}
10861	>	{
10862	>	std::string *ptr = (std::string *)0;
10863	>	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
10864	>	if (!SWIG_IsOK(res4)) {
10865	>	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10866	>	}
10867	>	if (!ptr) {
10868	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10869	>	}
10870	>	arg4 = ptr;
10871	>	}
10872	>	{
10873	>	std::string *ptr = (std::string *)0;
10874	>	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10875	>	if (!SWIG_IsOK(res5)) {
10876	>	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10877	>	}
10878	>	if (!ptr) {
10879	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10880	>	}
10881	>	arg5 = ptr;
10882	>	}
10883	>	{
10884	>	std::string *ptr = (std::string *)0;
10885	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
10886	>	if (!SWIG_IsOK(res) || !ptr) {
10887	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "6"" of type '" "std::string""'");
10888	>	}
10889	>	arg6 = *ptr;
10890	>	if (SWIG_IsNewObj(res)) delete ptr;
10891	>	}
10892	>	{
10893	>	std::string *ptr = (std::string *)0;
10894	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
10895	>	if (!SWIG_IsOK(res) || !ptr) {
10896	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "7"" of type '" "std::string""'");
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 &""'");
11077	>	}
11078	>	arg5 = ptr;
11079	>	}
11080	>	{
11081	>	try {
11082	>	(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());
11085	>	}
11086	>	}
11087	>	resultobj = SWIG_Py_Void();
11088	>	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;
11097	>	}
11098	>
11099	>
11100	>	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11101	>	PyObject *resultobj = 0;
11102	>	BossSession *arg1 = (BossSession *) 0 ;
11103	>	int arg2 ;
11104	>	std::string *arg3 = 0 ;
11105	>	std::string *arg4 = 0 ;
11106	>	void *argp1 = 0 ;
11107	>	int res1 = 0 ;
11108	>	int val2 ;
11109	>	int ecode2 = 0 ;
11110	>	int res3 = SWIG_OLDOBJ ;
11111	>	int res4 = SWIG_OLDOBJ ;
11112	>	PyObject * obj0 = 0 ;
11113	>	PyObject * obj1 = 0 ;
11114	>	PyObject * obj2 = 0 ;
11115	>	PyObject * obj3 = 0 ;
11116	>
11117	>	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11118	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11119	>	if (!SWIG_IsOK(res1)) {
11120	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
11121	>	}
11122	>	arg1 = reinterpret_cast< BossSession * >(argp1);
11123	>	ecode2 = SWIG_AsVal_int(obj1, &val2);
11124	>	if (!SWIG_IsOK(ecode2)) {
11125	>	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
11126	>	}
11127	>	arg2 = static_cast< int >(val2);
11128	>	{
11129	>	std::string *ptr = (std::string *)0;
11130	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11131	>	if (!SWIG_IsOK(res3)) {
11132	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
11133	>	}
11134	>	if (!ptr) {
11135	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
11136	>	}
11137	>	arg3 = ptr;
11138	>	}
11139	>	{
11140	>	std::string *ptr = (std::string *)0;
11141	>	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
11142	>	if (!SWIG_IsOK(res4)) {
11143	>	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
11144	>	}
11145	>	if (!ptr) {
11146	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
11147	>	}
11148	>	arg4 = ptr;
11149	>	}
11150	>	{
11151	>	try {
11152	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
11153	>	} catch (const std::exception& e) {
11154	>	SWIG_exception(SWIG_RuntimeError, e.what());
11155	>	}
11156	>	}
11157	>	resultobj = SWIG_Py_Void();
11158	>	if (SWIG_IsNewObj(res3)) delete arg3;
11159	>	if (SWIG_IsNewObj(res4)) delete arg4;
11160	>	return resultobj;
11161	>	fail:
11162	>	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 &""'");
11198	>	}
11199	>	if (!ptr) {
11200	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
11201	>	}
11202	>	arg3 = ptr;
11203	>	}
11204	>	{
11205	>	try {
11206	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3);
11207	>	} catch (const std::exception& e) {
11208	>	SWIG_exception(SWIG_RuntimeError, e.what());
11209	>	}
11210	>	}
11211	>	resultobj = SWIG_Py_Void();
11212	>	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());
11247	>	}
11248	>	}
11249	>	resultobj = SWIG_Py_Void();
11250	>	return resultobj;
11251	>	fail:
11252	>	return NULL;
11253	>	}
11254	>
11255	>
11256	>	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257	>	PyObject *resultobj = 0;
11258	>	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());
11274	>	}
11275	>	}
11276	>	resultobj = SWIG_Py_Void();
11277	>	return resultobj;
11278	>	fail:
11279	>	return NULL;
11280	>	}
11281	>
11282	>
11283	>	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
11284	>	int argc;
11285	>	PyObject *argv[10];
11286	>	int ii;
11287	>
11288	>	if (!PyTuple_Check(args)) SWIG_fail;
11289	>	argc = PyObject_Length(args);
11290	>	for (ii = 0; (ii < argc) && (ii < 9); ii++) {
11291	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
11292	>	}
11293	>	if (argc == 1) {
11294	>	int _v;
11295	>	void *vptr = 0;
11296	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11297	>	_v = SWIG_CheckState(res);
11298	>	if (_v) {
11299	>	return _wrap_BossSession_schedulerQuery__SWIG_8(self, args);
11300	>	}
11301	>	}
11302	>	if (argc == 2) {
11303	>	int _v;
11304	>	void *vptr = 0;
11305	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11306	>	_v = SWIG_CheckState(res);
11307	>	if (_v) {
11308	>	{
11309	>	int res = SWIG_AsVal_int(argv[1], NULL);
11310	>	_v = SWIG_CheckState(res);
11311	>	}
11312	>	if (_v) {
11313	>	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	<	if (obj3) {
11336	<	{
11337	<	if (PyString_Check(obj3)) {
11338	<	temp4 = std::string(PyString_AsString(obj3));
11339	<	arg4 = &temp4;
11340	<	}else {
11341	<	SWIG_exception(SWIG_TypeError, "string expected");
11342	<	}
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	<	if (obj4) {
11359	<	{
11360	<	if (PyString_Check(obj4)) {
11361	<	temp5 = std::string(PyString_AsString(obj4));
11362	<	arg5 = &temp5;
11363	<	}else {
11364	<	SWIG_exception(SWIG_TypeError, "string expected");
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);
11380		}
11381	+	}
11382		}
11383	+	}
11384		}
11385	<	if (obj5) {
11386	<	{
11387	<	if (PyString_Check(obj5))
11388	<	arg6 = std::string(PyString_AsString(obj5));
11389	<	else
11390	<	SWIG_exception(SWIG_TypeError, "string expected");
11385	>	}
11386	>	if (argc == 6) {
11387	>	int _v;
11388	>	void *vptr = 0;
11389	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11390	>	_v = SWIG_CheckState(res);
11391	>	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	>	}
11411	>	}
11412	>	}
11413		}
11414	+	}
11415		}
11416	<	if (obj6) {
11417	<	{
11418	<	if (PyString_Check(obj6))
11419	<	arg7 = std::string(PyString_AsString(obj6));
11420	<	else
11421	<	SWIG_exception(SWIG_TypeError, "string expected");
11416	>	}
11417	>	if (argc == 7) {
11418	>	int _v;
11419	>	void *vptr = 0;
11420	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11421	>	_v = SWIG_CheckState(res);
11422	>	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	>	}
11446	>	}
11447	>	}
11448		}
11449	+	}
11450		}
11451	<	if (obj7) {
11452	<	{
11453	<	if (PyString_Check(obj7))
11454	<	arg8 = std::string(PyString_AsString(obj7));
11455	<	else
11456	<	SWIG_exception(SWIG_TypeError, "string expected");
11451	>	}
11452	>	if (argc == 8) {
11453	>	int _v;
11454	>	void *vptr = 0;
11455	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11456	>	_v = SWIG_CheckState(res);
11457	>	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	>	}
11485	>	}
11486	>	}
11487		}
11488	+	}
11489		}
11490	<	if (obj8) {
11491	<	{
11492	<	if (PyString_Check(obj8))
11493	<	arg9 = std::string(PyString_AsString(obj8));
11494	<	else
11495	<	SWIG_exception(SWIG_TypeError, "string expected");
11490	>	}
11491	>	if (argc == 9) {
11492	>	int _v;
11493	>	void *vptr = 0;
11494	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11495	>	_v = SWIG_CheckState(res);
11496	>	if (_v) {
11497	>	{
11498	>	int res = SWIG_AsVal_int(argv[1], NULL);
11499	>	_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	>	}
11530		}
11531	+	}
11532		}
11533	<	{
11534	<	try {
11535	<	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
11536	<
11537	<	}catch (const std::exception& e) {
11538	<	SWIG_exception(SWIG_RuntimeError, e.what());
11539	<	}
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	<	Py_INCREF(Py_None); resultobj = Py_None;
11574	<	return resultobj;
11575	<	fail:
11576	<	return NULL;
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	<	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
11634	<	PyObject *resultobj;
11635	<	BossSession *arg1 = (BossSession *) 0 ;
11636	<	std::string const &arg2_defvalue = "all" ;
11637	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
11638	<	std::string const &arg3_defvalue = "" ;
11639	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
11640	<	std::string const &arg4_defvalue = "" ;
11641	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
11642	<	std::string const &arg5_defvalue = "" ;
11643	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
11644	<	SwigValueWrapper< std::vector<std::string > > result;
11645	<	std::string temp2 ;
11646	<	std::string temp3 ;
11647	<	std::string temp4 ;
11648	<	std::string temp5 ;
11649	<	PyObject * obj0 = 0 ;
11650	<	PyObject * obj1 = 0 ;
11651	<	PyObject * obj2 = 0 ;
11652	<	PyObject * obj3 = 0 ;
11653	<	PyObject * obj4 = 0 ;
11654	<
11655	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11656	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
11657	<	if (obj1) {
11658	<	{
11659	<	if (PyString_Check(obj1)) {
11660	<	temp2 = std::string(PyString_AsString(obj1));
2732	<	arg2 = &temp2;
2733	<	}else {
2734	<	SWIG_exception(SWIG_TypeError, "string expected");
2735	<	}
2736	<	}
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 (obj2) {
11663	<	{
11664	<	if (PyString_Check(obj2)) {
11665	<	temp3 = std::string(PyString_AsString(obj2));
11666	<	arg3 = &temp3;
11667	<	}else {
11668	<	SWIG_exception(SWIG_TypeError, "string expected");
11669	<	}
11662	>	if (!ptr) {
11663	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11664	>	}
11665	>	arg2 = ptr;
11666	>	}
11667	>	{
11668	>	std::string *ptr = (std::string *)0;
11669	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11670	>	if (!SWIG_IsOK(res3)) {
11671	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11672	>	}
11673	>	if (!ptr) {
11674	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11675	>	}
11676	>	arg3 = ptr;
11677	>	}
11678	>	{
11679	>	std::string *ptr = (std::string *)0;
11680	>	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
11681	>	if (!SWIG_IsOK(res4)) {
11682	>	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_selectTasks" "', argument " "4"" of type '" "std::string const &""'");
11683	>	}
11684	>	if (!ptr) {
11685	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "4"" of type '" "std::string const &""'");
11686	>	}
11687	>	arg4 = ptr;
11688	>	}
11689	>	{
11690	>	try {
11691	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
11692	>	} catch (const std::exception& e) {
11693	>	SWIG_exception(SWIG_RuntimeError, e.what());
11694	>	}
11695	>	}
11696	>	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
11697	>	if (SWIG_IsNewObj(res2)) delete arg2;
11698	>	if (SWIG_IsNewObj(res3)) delete arg3;
11699	>	if (SWIG_IsNewObj(res4)) delete arg4;
11700	>	return resultobj;
11701	>	fail:
11702	>	if (SWIG_IsNewObj(res2)) delete arg2;
11703	>	if (SWIG_IsNewObj(res3)) delete arg3;
11704	>	if (SWIG_IsNewObj(res4)) delete arg4;
11705	>	return NULL;
11706	>	}
11707	>
11708	>
11709	>	SWIGINTERN PyObject *_wrap_BossSession_selectTasks__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11710	>	PyObject *resultobj = 0;
11711	>	BossSession *arg1 = (BossSession *) 0 ;
11712	>	std::string *arg2 = 0 ;
11713	>	std::string *arg3 = 0 ;
11714	>	std::vector<std::string,std::allocator<std::string > > result;
11715	>	void *argp1 = 0 ;
11716	>	int res1 = 0 ;
11717	>	int res2 = SWIG_OLDOBJ ;
11718	>	int res3 = SWIG_OLDOBJ ;
11719	>	PyObject * obj0 = 0 ;
11720	>	PyObject * obj1 = 0 ;
11721	>	PyObject * obj2 = 0 ;
11722	>
11723	>	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_selectTasks",&obj0,&obj1,&obj2)) SWIG_fail;
11724	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11725	>	if (!SWIG_IsOK(res1)) {
11726	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_selectTasks" "', argument " "1"" of type '" "BossSession *""'");
11727	>	}
11728	>	arg1 = reinterpret_cast< BossSession * >(argp1);
11729	>	{
11730	>	std::string *ptr = (std::string *)0;
11731	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11732	>	if (!SWIG_IsOK(res2)) {
11733	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11734	>	}
11735	>	if (!ptr) {
11736	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11737	>	}
11738	>	arg2 = ptr;
11739	>	}
11740	>	{
11741	>	std::string *ptr = (std::string *)0;
11742	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11743	>	if (!SWIG_IsOK(res3)) {
11744	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11745	>	}
11746	>	if (!ptr) {
11747	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11748	>	}
11749	>	arg3 = ptr;
11750	>	}
11751	>	{
11752	>	try {
11753	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3);
11754	>	} catch (const std::exception& e) {
11755	>	SWIG_exception(SWIG_RuntimeError, e.what());
11756	>	}
11757	>	}
11758	>	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
11759	>	if (SWIG_IsNewObj(res2)) delete arg2;
11760	>	if (SWIG_IsNewObj(res3)) delete arg3;
11761	>	return resultobj;
11762	>	fail:
11763	>	if (SWIG_IsNewObj(res2)) delete arg2;
11764	>	if (SWIG_IsNewObj(res3)) delete arg3;
11765	>	return NULL;
11766	>	}
11767	>
11768	>
11769	>	SWIGINTERN PyObject *_wrap_BossSession_selectTasks__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11770	>	PyObject *resultobj = 0;
11771	>	BossSession *arg1 = (BossSession *) 0 ;
11772	>	std::string *arg2 = 0 ;
11773	>	std::vector<std::string,std::allocator<std::string > > result;
11774	>	void *argp1 = 0 ;
11775	>	int res1 = 0 ;
11776	>	int res2 = SWIG_OLDOBJ ;
11777	>	PyObject * obj0 = 0 ;
11778	>	PyObject * obj1 = 0 ;
11779	>
11780	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_selectTasks",&obj0,&obj1)) SWIG_fail;
11781	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11782	>	if (!SWIG_IsOK(res1)) {
11783	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_selectTasks" "', argument " "1"" of type '" "BossSession *""'");
11784	>	}
11785	>	arg1 = reinterpret_cast< BossSession * >(argp1);
11786	>	{
11787	>	std::string *ptr = (std::string *)0;
11788	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11789	>	if (!SWIG_IsOK(res2)) {
11790	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11791	>	}
11792	>	if (!ptr) {
11793	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11794	>	}
11795	>	arg2 = ptr;
11796	>	}
11797	>	{
11798	>	try {
11799	>	result = (arg1)->selectTasks((std::string const &)*arg2);
11800	>	} catch (const std::exception& e) {
11801	>	SWIG_exception(SWIG_RuntimeError, e.what());
11802	>	}
11803	>	}
11804	>	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
11805	>	if (SWIG_IsNewObj(res2)) delete arg2;
11806	>	return resultobj;
11807	>	fail:
11808	>	if (SWIG_IsNewObj(res2)) delete arg2;
11809	>	return NULL;
11810	>	}
11811	>
11812	>
11813	>	SWIGINTERN PyObject *_wrap_BossSession_selectTasks__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11814	>	PyObject *resultobj = 0;
11815	>	BossSession *arg1 = (BossSession *) 0 ;
11816	>	std::vector<std::string,std::allocator<std::string > > result;
11817	>	void *argp1 = 0 ;
11818	>	int res1 = 0 ;
11819	>	PyObject * obj0 = 0 ;
11820	>
11821	>	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_selectTasks",&obj0)) SWIG_fail;
11822	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11823	>	if (!SWIG_IsOK(res1)) {
11824	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_selectTasks" "', argument " "1"" of type '" "BossSession *""'");
11825	>	}
11826	>	arg1 = reinterpret_cast< BossSession * >(argp1);
11827	>	{
11828	>	try {
11829	>	result = (arg1)->selectTasks();
11830	>	} catch (const std::exception& e) {
11831	>	SWIG_exception(SWIG_RuntimeError, e.what());
11832	>	}
11833	>	}
11834	>	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
11835	>	return resultobj;
11836	>	fail:
11837	>	return NULL;
11838	>	}
11839	>
11840	>
11841	>	SWIGINTERN PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
11842	>	int argc;
11843	>	PyObject *argv[6];
11844	>	int ii;
11845	>
11846	>	if (!PyTuple_Check(args)) SWIG_fail;
11847	>	argc = PyObject_Length(args);
11848	>	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
11849	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
11850	>	}
11851	>	if (argc == 1) {
11852	>	int _v;
11853	>	void *vptr = 0;
11854	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11855	>	_v = SWIG_CheckState(res);
11856	>	if (_v) {
11857	>	return _wrap_BossSession_selectTasks__SWIG_4(self, args);
11858	>	}
11859	>	}
11860	>	if (argc == 2) {
11861	>	int _v;
11862	>	void *vptr = 0;
11863	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11864	>	_v = SWIG_CheckState(res);
11865	>	if (_v) {
11866	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
11867	>	_v = SWIG_CheckState(res);
11868	>	if (_v) {
11869	>	return _wrap_BossSession_selectTasks__SWIG_3(self, args);
11870	>	}
11871	>	}
11872	>	}
11873	>	if (argc == 3) {
11874	>	int _v;
11875	>	void *vptr = 0;
11876	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11877	>	_v = SWIG_CheckState(res);
11878	>	if (_v) {
11879	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
11880	>	_v = SWIG_CheckState(res);
11881	>	if (_v) {
11882	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11883	>	_v = SWIG_CheckState(res);
11884	>	if (_v) {
11885	>	return _wrap_BossSession_selectTasks__SWIG_2(self, args);
11886		}
11887	+	}
11888		}
11889	<	if (obj3) {
11890	<	{
11891	<	if (PyString_Check(obj3)) {
11892	<	temp4 = std::string(PyString_AsString(obj3));
11893	<	arg4 = &temp4;
11894	<	}else {
11895	<	SWIG_exception(SWIG_TypeError, "string expected");
11896	<	}
11889	>	}
11890	>	if (argc == 4) {
11891	>	int _v;
11892	>	void *vptr = 0;
11893	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11894	>	_v = SWIG_CheckState(res);
11895	>	if (_v) {
11896	>	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	>	}
11907		}
11908	+	}
11909		}
11910	<	if (obj4) {
11911	<	{
11912	<	if (PyString_Check(obj4)) {
11913	<	temp5 = std::string(PyString_AsString(obj4));
11914	<	arg5 = &temp5;
11915	<	}else {
11916	<	SWIG_exception(SWIG_TypeError, "string expected");
11910	>	}
11911	>	if (argc == 5) {
11912	>	int _v;
11913	>	void *vptr = 0;
11914	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11915	>	_v = SWIG_CheckState(res);
11916	>	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);
11930		}
11931	+	}
11932		}
11933	+	}
11934		}
11935	<	{
11936	<	try {
11937	<	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
11938	<
11939	<	}catch (const std::exception& e) {
11940	<	SWIG_exception(SWIG_RuntimeError, e.what());
11941	<	}
11935	>	}
11936	>
11937	>	fail:
11938	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_selectTasks'");
11939	>	return NULL;
11940	>	}
11941	>
11942	>
11943	>	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11944	>	PyObject *resultobj = 0;
11945	>	BossSession *arg1 = (BossSession *) 0 ;
11946	>	int arg2 ;
11947	>	std::string *arg3 = 0 ;
11948	>	std::string *arg4 = 0 ;
11949	>	std::string *arg5 = 0 ;
11950	>	std::string arg6 ;
11951	>	std::string arg7 ;
11952	>	std::string arg8 ;
11953	>	std::string arg9 ;
11954	>	bool arg10 ;
11955	>	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
11956	>	void *argp1 = 0 ;
11957	>	int res1 = 0 ;
11958	>	int val2 ;
11959	>	int ecode2 = 0 ;
11960	>	int res3 = SWIG_OLDOBJ ;
11961	>	int res4 = SWIG_OLDOBJ ;
11962	>	int res5 = SWIG_OLDOBJ ;
11963	>	bool val10 ;
11964	>	int ecode10 = 0 ;
11965	>	PyObject * obj0 = 0 ;
11966	>	PyObject * obj1 = 0 ;
11967	>	PyObject * obj2 = 0 ;
11968	>	PyObject * obj3 = 0 ;
11969	>	PyObject * obj4 = 0 ;
11970	>	PyObject * obj5 = 0 ;
11971	>	PyObject * obj6 = 0 ;
11972	>	PyObject * obj7 = 0 ;
11973	>	PyObject * obj8 = 0 ;
11974	>	PyObject * obj9 = 0 ;
11975	>
11976	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
11977	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11978	>	if (!SWIG_IsOK(res1)) {
11979	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
11980	>	}
11981	>	arg1 = reinterpret_cast< BossSession * >(argp1);
11982	>	ecode2 = SWIG_AsVal_int(obj1, &val2);
11983	>	if (!SWIG_IsOK(ecode2)) {
11984	>	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
11985	>	}
11986	>	arg2 = static_cast< int >(val2);
11987	>	{
11988	>	std::string *ptr = (std::string *)0;
11989	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11990	>	if (!SWIG_IsOK(res3)) {
11991	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
11992		}
11993	<	{
11994	<	std::vector<std::string > * resultptr;
2778	<	resultptr = new std::vector<std::string >((std::vector<std::string > &) result);
2779	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__string_t, 1);
11993	>	if (!ptr) {
11994	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
11995		}
11996	<	return resultobj;
11997	<	fail:
11998	<	return NULL;
11996	>	arg3 = ptr;
11997	>	}
11998	>	{
11999	>	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 &""'");
12006	>	}
12007	>	arg4 = ptr;
12008	>	}
12009	>	{
12010	>	std::string *ptr = (std::string *)0;
12011	>	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
12012	>	if (!SWIG_IsOK(res5)) {
12013	>	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12014	>	}
12015	>	if (!ptr) {
12016	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
12017	>	}
12018	>	arg5 = ptr;
12019	>	}
12020	>	{
12021	>	std::string *ptr = (std::string *)0;
12022	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
12023	>	if (!SWIG_IsOK(res) || !ptr) {
12024	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "6"" of type '" "std::string""'");
12025	>	}
12026	>	arg6 = *ptr;
12027	>	if (SWIG_IsNewObj(res)) delete ptr;
12028	>	}
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""'");
12034	>	}
12035	>	arg7 = *ptr;
12036	>	if (SWIG_IsNewObj(res)) delete ptr;
12037	>	}
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""'");
12043	>	}
12044	>	arg8 = *ptr;
12045	>	if (SWIG_IsNewObj(res)) delete ptr;
12046	>	}
12047	>	{
12048	>	std::string *ptr = (std::string *)0;
12049	>	int res = SWIG_AsPtr_std_string(obj8, &ptr);
12050	>	if (!SWIG_IsOK(res) || !ptr) {
12051	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_query" "', argument " "9"" of type '" "std::string""'");
12052	>	}
12053	>	arg9 = *ptr;
12054	>	if (SWIG_IsNewObj(res)) delete ptr;
12055	>	}
12056	>	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());
12066	>	}
12067	>	}
12068	>	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 );
12069	>	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;
12078		}
12079
12080
12081	<	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
12082	<	PyObject *obj;
12083	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12084	<	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
12085	<	Py_INCREF(obj);
12086	<	return Py_BuildValue((char *)"");
12087	<	}
12088	<	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
12089	<	PyObject *resultobj;
12090	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
12091	<	char *arg2 ;
12092	<	PyObject * obj0 = 0 ;
12093	<
12094	<	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
12095	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
12096	<	{
12097	<	if (arg2) {
12098	<	arg1->key = (char const *) (new char[strlen(arg2)+1]);
12099	<	strcpy((char *) arg1->key,arg2);
12100	<	}else {
12101	<	arg1->key = 0;
12102	<	}
12081	>	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12082	>	PyObject *resultobj = 0;
12083	>	BossSession *arg1 = (BossSession *) 0 ;
12084	>	int arg2 ;
12085	>	std::string *arg3 = 0 ;
12086	>	std::string *arg4 = 0 ;
12087	>	std::string *arg5 = 0 ;
12088	>	std::string arg6 ;
12089	>	std::string arg7 ;
12090	>	std::string arg8 ;
12091	>	std::string arg9 ;
12092	>	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
12093	>	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	<	Py_INCREF(Py_None); resultobj = Py_None;
12128	<	return resultobj;
12129	<	fail:
12130	<	return NULL;
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""'");
12186	>	}
12187	>	arg9 = *ptr;
12188	>	if (SWIG_IsNewObj(res)) delete ptr;
12189	>	}
12190	>	{
12191	>	try {
12192	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
12193	>	} catch (const std::exception& e) {
12194	>	SWIG_exception(SWIG_RuntimeError, e.what());
12195	>	}
12196	>	}
12197	>	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 );
12198	>	if (SWIG_IsNewObj(res3)) delete arg3;
12199	>	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;
12207		}
12208
12209
12210	<	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
12211	<	PyObject *resultobj;
12212	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
12213	<	char *result;
12214	<	PyObject * obj0 = 0 ;
12215	<
12216	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
12217	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
12218	<	result = (char *) ((arg1)->key);
12219	<
12220	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
12221	<	return resultobj;
12222	<	fail:
12223	<	return NULL;
12210	>	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12211	>	PyObject *resultobj = 0;
12212	>	BossSession *arg1 = (BossSession *) 0 ;
12213	>	int arg2 ;
12214	>	std::string *arg3 = 0 ;
12215	>	std::string *arg4 = 0 ;
12216	>	std::string *arg5 = 0 ;
12217	>	std::string arg6 ;
12218	>	std::string arg7 ;
12219	>	std::string arg8 ;
12220	>	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
12221	>	void *argp1 = 0 ;
12222	>	int res1 = 0 ;
12223	>	int val2 ;
12224	>	int ecode2 = 0 ;
12225	>	int res3 = SWIG_OLDOBJ ;
12226	>	int res4 = SWIG_OLDOBJ ;
12227	>	int res5 = SWIG_OLDOBJ ;
12228	>	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());
12313	>	}
12314	>	}
12315	>	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 );
12316	>	if (SWIG_IsNewObj(res3)) delete arg3;
12317	>	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;
12325		}
12326
12327
12328	<	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
12329	<	PyObject *resultobj;
12330	<	char *arg1 ;
12331	<	BossTaskException *result;
12332	<
12333	<	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
12334	<	{
12335	<	try {
12336	<	result = (BossTaskException *)new BossTaskException((char const *)arg1);
12337	<
12338	<	}catch (const std::exception& e) {
12339	<	SWIG_exception(SWIG_RuntimeError, e.what());
12340	<	}
12328	>	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12329	>	PyObject *resultobj = 0;
12330	>	BossSession *arg1 = (BossSession *) 0 ;
12331	>	int arg2 ;
12332	>	std::string *arg3 = 0 ;
12333	>	std::string *arg4 = 0 ;
12334	>	std::string *arg5 = 0 ;
12335	>	std::string arg6 ;
12336	>	std::string arg7 ;
12337	>	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
12338	>	void *argp1 = 0 ;
12339	>	int res1 = 0 ;
12340	>	int val2 ;
12341	>	int ecode2 = 0 ;
12342	>	int res3 = SWIG_OLDOBJ ;
12343	>	int res4 = SWIG_OLDOBJ ;
12344	>	int res5 = SWIG_OLDOBJ ;
12345	>	PyObject * obj0 = 0 ;
12346	>	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	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
12371	<	return resultobj;
12372	<	fail:
12373	<	return NULL;
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());
12420	>	}
12421	>	}
12422	>	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 );
12423	>	if (SWIG_IsNewObj(res3)) delete arg3;
12424	>	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;
12432		}
12433
12434
12435	<	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
12436	<	PyObject *resultobj;
12437	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
12438	<	char *result;
12439	<	PyObject * obj0 = 0 ;
12440	<
12441	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
12442	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
12443	<	{
12444	<	try {
12445	<	result = (char *)((BossTaskException const *)arg1)->what();
12446	<
12447	<	}catch (const std::exception& e) {
12448	<	SWIG_exception(SWIG_RuntimeError, e.what());
12449	<	}
12435	>	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12436	>	PyObject *resultobj = 0;
12437	>	BossSession *arg1 = (BossSession *) 0 ;
12438	>	int arg2 ;
12439	>	std::string *arg3 = 0 ;
12440	>	std::string *arg4 = 0 ;
12441	>	std::string *arg5 = 0 ;
12442	>	std::string arg6 ;
12443	>	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
12444	>	void *argp1 = 0 ;
12445	>	int res1 = 0 ;
12446	>	int val2 ;
12447	>	int ecode2 = 0 ;
12448	>	int res3 = SWIG_OLDOBJ ;
12449	>	int res4 = SWIG_OLDOBJ ;
12450	>	int res5 = SWIG_OLDOBJ ;
12451	>	PyObject * obj0 = 0 ;
12452	>	PyObject * obj1 = 0 ;
12453	>	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	<	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
12476	<	return resultobj;
12477	<	fail:
12478	<	return NULL;
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());
12516	>	}
12517	>	}
12518	>	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 );
12519	>	if (SWIG_IsNewObj(res3)) delete arg3;
12520	>	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;
12528		}
12529
12530
12531	<	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
12532	<	PyObject *resultobj;
12533	<	BossTaskException *arg1 = (BossTaskException *) 0 ;
12534	<	PyObject * obj0 = 0 ;
12535	<
12536	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
12537	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
12538	<	{
12539	<	try {
12540	<	delete arg1;
12541	<
12542	<	}catch (const std::exception& e) {
12543	<	SWIG_exception(SWIG_RuntimeError, e.what());
12544	<	}
12531	>	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12532	>	PyObject *resultobj = 0;
12533	>	BossSession *arg1 = (BossSession *) 0 ;
12534	>	int arg2 ;
12535	>	std::string *arg3 = 0 ;
12536	>	std::string *arg4 = 0 ;
12537	>	std::string *arg5 = 0 ;
12538	>	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
12539	>	void *argp1 = 0 ;
12540	>	int res1 = 0 ;
12541	>	int val2 ;
12542	>	int ecode2 = 0 ;
12543	>	int res3 = SWIG_OLDOBJ ;
12544	>	int res4 = SWIG_OLDOBJ ;
12545	>	int res5 = SWIG_OLDOBJ ;
12546	>	PyObject * obj0 = 0 ;
12547	>	PyObject * obj1 = 0 ;
12548	>	PyObject * obj2 = 0 ;
12549	>	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	<	Py_INCREF(Py_None); resultobj = Py_None;
12570	<	return resultobj;
12571	<	fail:
12572	<	return NULL;
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());
12601	>	}
12602	>	}
12603	>	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 );
12604	>	if (SWIG_IsNewObj(res3)) delete arg3;
12605	>	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;
12613		}
12614
12615
12616	<	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
12617	<	PyObject *obj;
12618	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12619	<	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
12620	<	Py_INCREF(obj);
12621	<	return Py_BuildValue((char *)"");
12622	<	}
12623	<	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
12624	<	PyObject *resultobj;
12625	<	BossTask *arg1 = (BossTask *) 0 ;
12626	<	PyObject *arg2 = (PyObject *) 0 ;
12627	<	BossAttributeContainer *arg3 = 0 ;
12628	<	PyObject *result;
12629	<	PyObject * obj0 = 0 ;
12630	<	PyObject * obj1 = 0 ;
12631	<	PyObject * obj2 = 0 ;
12632	<
12633	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
12634	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
12635	<	arg2 = obj1;
12636	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
12637	<	if (arg3 == NULL) {
12638	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
12616	>	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12617	>	PyObject *resultobj = 0;
12618	>	BossSession *arg1 = (BossSession *) 0 ;
12619	>	int arg2 ;
12620	>	std::string *arg3 = 0 ;
12621	>	std::string *arg4 = 0 ;
12622	>	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
12623	>	void *argp1 = 0 ;
12624	>	int res1 = 0 ;
12625	>	int val2 ;
12626	>	int ecode2 = 0 ;
12627	>	int res3 = SWIG_OLDOBJ ;
12628	>	int res4 = SWIG_OLDOBJ ;
12629	>	PyObject * obj0 = 0 ;
12630	>	PyObject * obj1 = 0 ;
12631	>	PyObject * obj2 = 0 ;
12632	>	PyObject * obj3 = 0 ;
12633	>
12634	>	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12635	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
12636	>	if (!SWIG_IsOK(res1)) {
12637	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
12638	>	}
12639	>	arg1 = reinterpret_cast< BossSession * >(argp1);
12640	>	ecode2 = SWIG_AsVal_int(obj1, &val2);
12641	>	if (!SWIG_IsOK(ecode2)) {
12642	>	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
12643	>	}
12644	>	arg2 = static_cast< int >(val2);
12645	>	{
12646	>	std::string *ptr = (std::string *)0;
12647	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
12648	>	if (!SWIG_IsOK(res3)) {
12649	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12650		}
12651	<	{
12652	<	try {
2926	<	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
2927	<
2928	<	}catch (const std::exception& e) {
2929	<	SWIG_exception(SWIG_RuntimeError, e.what());
2930	<	}
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	<	resultobj = result;
12655	<	return resultobj;
12656	<	fail:
12657	<	return NULL;
12654	>	arg3 = ptr;
12655	>	}
12656	>	{
12657	>	std::string *ptr = (std::string *)0;
12658	>	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
12659	>	if (!SWIG_IsOK(res4)) {
12660	>	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12661	>	}
12662	>	if (!ptr) {
12663	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12664	>	}
12665	>	arg4 = ptr;
12666	>	}
12667	>	{
12668	>	try {
12669	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
12670	>	} catch (const std::exception& e) {
12671	>	SWIG_exception(SWIG_RuntimeError, e.what());
12672	>	}
12673	>	}
12674	>	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 );
12675	>	if (SWIG_IsNewObj(res3)) delete arg3;
12676	>	if (SWIG_IsNewObj(res4)) delete arg4;
12677	>	return resultobj;
12678	>	fail:
12679	>	if (SWIG_IsNewObj(res3)) delete arg3;
12680	>	if (SWIG_IsNewObj(res4)) delete arg4;
12681	>	return NULL;
12682		}
12683
12684
12685	<	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
12686	<	PyObject *resultobj;
12687	<	BossTask *arg1 = (BossTask *) 0 ;
12688	<	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
12689	<	PyObject *result;
12690	<	PyObject * obj0 = 0 ;
12691	<	PyObject * obj1 = 0 ;
12692	<
12693	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
12694	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
12695	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
12696	<	if (arg2 == NULL) {
12697	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
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 &""'");
12716		}
12717	<	{
12718	<	try {
2955	<	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
2956	<
2957	<	}catch (const std::exception& e) {
2958	<	SWIG_exception(SWIG_RuntimeError, e.what());
2959	<	}
12717	>	if (!ptr) {
12718	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12719		}
12720	<	resultobj = result;
12721	<	return resultobj;
12722	<	fail:
12723	<	return NULL;
12720	>	arg3 = ptr;
12721	>	}
12722	>	{
12723	>	try {
12724	>	result = (arg1)->query(arg2,(std::string const &)*arg3);
12725	>	} catch (const std::exception& e) {
12726	>	SWIG_exception(SWIG_RuntimeError, e.what());
12727	>	}
12728	>	}
12729	>	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 );
12730	>	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	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_1(PyObject *self, PyObject *args) {
12739	<	PyObject *resultobj;
12740	<	BossTask *arg1 = (BossTask *) 0 ;
12741	<	PyObject *result;
12742	<	PyObject * obj0 = 0 ;
12743	<
12744	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
12745	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
12746	<	{
12747	<	try {
12748	<	result = (PyObject *)BossTask_jobsMap__SWIG_1((BossTask const *)arg1);
12749	<
12750	<	}catch (const std::exception& e) {
12751	<	SWIG_exception(SWIG_RuntimeError, e.what());
12752	<	}
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());
12766		}
12767	<	resultobj = result;
12768	<	return resultobj;
12769	<	fail:
12770	<	return NULL;
12767	>	}
12768	>	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 );
12769	>	return resultobj;
12770	>	fail:
12771	>	return NULL;
12772		}
12773
12774
12775	<	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
12776	<	int argc;
12777	<	PyObject *argv[2];
12778	<	int ii;
12779	<
12780	<	argc = PyObject_Length(args);
12781	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
12782	<	argv[ii] = PyTuple_GetItem(args,ii);
12775	>	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12776	>	PyObject *resultobj = 0;
12777	>	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());
12794		}
12795	<	if (argc == 1) {
12796	<	int _v;
12797	<	{
12798	<	void *ptr;
12799	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
12800	<	_v = 0;
12801	<	PyErr_Clear();
12802	<	}else {
12803	<	_v = 1;
12795	>	}
12796	>	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 );
12797	>	return resultobj;
12798	>	fail:
12799	>	return NULL;
12800	>	}
12801	>
12802	>
12803	>	SWIGINTERN PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
12804	>	int argc;
12805	>	PyObject *argv[11];
12806	>	int ii;
12807	>
12808	>	if (!PyTuple_Check(args)) SWIG_fail;
12809	>	argc = PyObject_Length(args);
12810	>	for (ii = 0; (ii < argc) && (ii < 10); ii++) {
12811	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
12812	>	}
12813	>	if (argc == 1) {
12814	>	int _v;
12815	>	void *vptr = 0;
12816	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
12817	>	_v = SWIG_CheckState(res);
12818	>	if (_v) {
12819	>	return _wrap_BossSession_query__SWIG_9(self, args);
12820	>	}
12821	>	}
12822	>	if (argc == 2) {
12823	>	int _v;
12824	>	void *vptr = 0;
12825	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
12826	>	_v = SWIG_CheckState(res);
12827	>	if (_v) {
12828	>	{
12829	>	int res = SWIG_AsVal_int(argv[1], NULL);
12830	>	_v = SWIG_CheckState(res);
12831	>	}
12832	>	if (_v) {
12833	>	return _wrap_BossSession_query__SWIG_8(self, args);
12834	>	}
12835	>	}
12836	>	}
12837	>	if (argc == 3) {
12838	>	int _v;
12839	>	void *vptr = 0;
12840	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
12841	>	_v = SWIG_CheckState(res);
12842	>	if (_v) {
12843	>	{
12844	>	int res = SWIG_AsVal_int(argv[1], NULL);
12845	>	_v = SWIG_CheckState(res);
12846	>	}
12847	>	if (_v) {
12848	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
12849	>	_v = SWIG_CheckState(res);
12850	>	if (_v) {
12851	>	return _wrap_BossSession_query__SWIG_7(self, args);
12852	>	}
12853	>	}
12854	>	}
12855	>	}
12856	>	if (argc == 4) {
12857	>	int _v;
12858	>	void *vptr = 0;
12859	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
12860	>	_v = SWIG_CheckState(res);
12861	>	if (_v) {
12862	>	{
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	>	}
12875	>	}
12876	>	}
12877	>	}
12878	>	}
12879	>	if (argc == 5) {
12880	>	int _v;
12881	>	void *vptr = 0;
12882	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
12883	>	_v = SWIG_CheckState(res);
12884	>	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);
12900		}
12901	+	}
12902		}
12903	+	}
12904	+	}
12905	+	}
12906	+	if (argc == 6) {
12907	+	int _v;
12908	+	void *vptr = 0;
12909	+	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
12910	+	_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	<	return _wrap_BossTask_jobsMap__SWIG_1(self,args);
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	>	}
12933		}
12934	+	}
12935		}
12936	<
12937	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobsMap'");
12938	<	return NULL;
12936	>	}
12937	>	if (argc == 7) {
12938	>	int _v;
12939	>	void *vptr = 0;
12940	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
12941	>	_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	>	}
12968	>	}
12969	>	}
12970	>	}
12971	>	}
12972	>	if (argc == 8) {
12973	>	int _v;
12974	>	void *vptr = 0;
12975	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
12976	>	_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	>	}
13007	>	}
13008	>	}
13009	>	}
13010	>	}
13011	>	if (argc == 9) {
13012	>	int _v;
13013	>	void *vptr = 0;
13014	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
13015	>	_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	>	}
13050	>	}
13051	>	}
13052	>	}
13053	>	}
13054	>	if (argc == 10) {
13055	>	int _v;
13056	>	void *vptr = 0;
13057	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
13058	>	_v = SWIG_CheckState(res);
13059	>	if (_v) {
13060	>	{
13061	>	int res = SWIG_AsVal_int(argv[1], NULL);
13062	>	_v = SWIG_CheckState(res);
13063	>	}
13064	>	if (_v) {
13065	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
13066	>	_v = SWIG_CheckState(res);
13067	>	if (_v) {
13068	>	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
13069	>	_v = SWIG_CheckState(res);
13070	>	if (_v) {
13071	>	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
13072	>	_v = SWIG_CheckState(res);
13073	>	if (_v) {
13074	>	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
13075	>	_v = SWIG_CheckState(res);
13076	>	if (_v) {
13077	>	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
13078	>	_v = SWIG_CheckState(res);
13079	>	if (_v) {
13080	>	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
13081	>	_v = SWIG_CheckState(res);
13082	>	if (_v) {
13083	>	int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
13084	>	_v = SWIG_CheckState(res);
13085	>	if (_v) {
13086	>	{
13087	>	int res = SWIG_AsVal_bool(argv[9], NULL);
13088	>	_v = SWIG_CheckState(res);
13089	>	}
13090	>	if (_v) {
13091	>	return _wrap_BossSession_query__SWIG_0(self, args);
13092	>	}
13093	>	}
13094	>	}
13095	>	}
13096	>	}
13097	>	}
13098	>	}
13099	>	}
13100	>	}
13101	>	}
13102	>	}
13103	>
13104	>	fail:
13105	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_query'");
13106	>	return NULL;
13107		}
13108
13109
13110	<	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
13111	<	PyObject *resultobj;
13112	<	BossTask *arg1 = (BossTask *) 0 ;
13113	<	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
13114	<	PyObject *result;
13115	<	PyObject * obj0 = 0 ;
13116	<	PyObject * obj1 = 0 ;
13117	<
13118	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
13119	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
13120	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
13121	<	if (arg2 == NULL) {
13122	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
13110	>	SWIGINTERN PyObject *_wrap_BossSession_show(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13111	>	PyObject *resultobj = 0;
13112	>	BossSession *arg1 = (BossSession *) 0 ;
13113	>	std::vector<std::string,std::allocator<std::string > > *arg2 = 0 ;
13114	>	PyObject *result = 0 ;
13115	>	void *argp1 = 0 ;
13116	>	int res1 = 0 ;
13117	>	void *argp2 = 0 ;
13118	>	int res2 = 0 ;
13119	>	PyObject * obj0 = 0 ;
13120	>	PyObject * obj1 = 0 ;
13121	>
13122	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) SWIG_fail;
13123	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13124	>	if (!SWIG_IsOK(res1)) {
13125	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_show" "', argument " "1"" of type '" "BossSession *""'");
13126	>	}
13127	>	arg1 = reinterpret_cast< BossSession * >(argp1);
13128	>	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t,  0 );
13129	>	if (!SWIG_IsOK(res2)) {
13130	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_show" "', argument " "2"" of type '" "std::vector<std::string,std::allocator<std::string > > &""'");
13131	>	}
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());
13141		}
13142	<	{
13143	<	try {
13144	<	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
13145	<
13146	<	}catch (const std::exception& e) {
13147	<	SWIG_exception(SWIG_RuntimeError, e.what());
13148	<	}
13142	>	}
13143	>	resultobj = result;
13144	>	return resultobj;
13145	>	fail:
13146	>	return NULL;
13147	>	}
13148	>
13149	>
13150	>	SWIGINTERN PyObject *_wrap_BossSession_CHTools(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13151	>	PyObject *resultobj = 0;
13152	>	BossSession *arg1 = (BossSession *) 0 ;
13153	>	PyObject *result = 0 ;
13154	>	void *argp1 = 0 ;
13155	>	int res1 = 0 ;
13156	>	PyObject * obj0 = 0 ;
13157	>
13158	>	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) SWIG_fail;
13159	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13160	>	if (!SWIG_IsOK(res1)) {
13161	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_CHTools" "', argument " "1"" of type '" "BossSession *""'");
13162	>	}
13163	>	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	<	resultobj = result;
13171	<	return resultobj;
13172	<	fail:
13173	<	return NULL;
13170	>	}
13171	>	resultobj = result;
13172	>	return resultobj;
13173	>	fail:
13174	>	return NULL;
13175		}
13176
13177
13178	<	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
13179	<	PyObject *resultobj;
13180	<	BossTask *arg1 = (BossTask *) 0 ;
13181	<	std::string *arg2 = 0 ;
13182	<	PyObject *result;
13183	<	std::string temp2 ;
13184	<	PyObject * obj0 = 0 ;
13185	<	PyObject * obj1 = 0 ;
13186	<
13187	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
13188	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
13189	<	{
13190	<	if (PyString_Check(obj1)) {
13191	<	temp2 = std::string(PyString_AsString(obj1));
13192	<	arg2 = &temp2;
13193	<	}else {
13194	<	SWIG_exception(SWIG_TypeError, "string expected");
13195	<	}
13178	>	SWIGINTERN PyObject *_wrap_BossSession_ProgramTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13179	>	PyObject *resultobj = 0;
13180	>	BossSession *arg1 = (BossSession *) 0 ;
13181	>	PyObject *result = 0 ;
13182	>	void *argp1 = 0 ;
13183	>	int res1 = 0 ;
13184	>	PyObject * obj0 = 0 ;
13185	>
13186	>	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) SWIG_fail;
13187	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13188	>	if (!SWIG_IsOK(res1)) {
13189	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_ProgramTypes" "', argument " "1"" of type '" "BossSession *""'");
13190	>	}
13191	>	arg1 = reinterpret_cast< BossSession * >(argp1);
13192	>	{
13193	>	try {
13194	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
13195	>	} catch (const std::exception& e) {
13196	>	SWIG_exception(SWIG_RuntimeError, e.what());
13197		}
13198	<	{
13199	<	try {
13200	<	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
13201	<
13202	<	}catch (const std::exception& e) {
13203	<	SWIG_exception(SWIG_RuntimeError, e.what());
13204	<	}
13198	>	}
13199	>	resultobj = result;
13200	>	return resultobj;
13201	>	fail:
13202	>	return NULL;
13203	>	}
13204	>
13205	>
13206	>	SWIGINTERN PyObject *_wrap_BossSession_RTMons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13207	>	PyObject *resultobj = 0;
13208	>	BossSession *arg1 = (BossSession *) 0 ;
13209	>	PyObject *result = 0 ;
13210	>	void *argp1 = 0 ;
13211	>	int res1 = 0 ;
13212	>	PyObject * obj0 = 0 ;
13213	>
13214	>	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) SWIG_fail;
13215	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13216	>	if (!SWIG_IsOK(res1)) {
13217	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTMons" "', argument " "1"" of type '" "BossSession *""'");
13218	>	}
13219	>	arg1 = reinterpret_cast< BossSession * >(argp1);
13220	>	{
13221	>	try {
13222	>	result = (PyObject *)BossSession_RTMons(arg1);
13223	>	} catch (const std::exception& e) {
13224	>	SWIG_exception(SWIG_RuntimeError, e.what());
13225		}
13226	<	resultobj = result;
13227	<	return resultobj;
13228	<	fail:
13229	<	return NULL;
13226	>	}
13227	>	resultobj = result;
13228	>	return resultobj;
13229	>	fail:
13230	>	return NULL;
13231		}
13232
13233
13234	<	static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
13235	<	PyObject *resultobj;
13236	<	BossDatabase *arg1 = (BossDatabase *) 0 ;
13237	<	BossTask *result;
13238	<	PyObject * obj0 = 0 ;
13239	<
13240	<	if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
13241	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
13242	<	{
13243	<	try {
13244	<	result = (BossTask *)new BossTask(arg1);
13245	<
13246	<	}catch (const std::exception& e) {
13247	<	SWIG_exception(SWIG_RuntimeError, e.what());
13248	<	}
13234	>	SWIGINTERN PyObject *_wrap_BossSession_schedulers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13235	>	PyObject *resultobj = 0;
13236	>	BossSession *arg1 = (BossSession *) 0 ;
13237	>	PyObject *result = 0 ;
13238	>	void *argp1 = 0 ;
13239	>	int res1 = 0 ;
13240	>	PyObject * obj0 = 0 ;
13241	>
13242	>	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) SWIG_fail;
13243	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13244	>	if (!SWIG_IsOK(res1)) {
13245	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulers" "', argument " "1"" of type '" "BossSession *""'");
13246	>	}
13247	>	arg1 = reinterpret_cast< BossSession * >(argp1);
13248	>	{
13249	>	try {
13250	>	result = (PyObject *)BossSession_schedulers(arg1);
13251	>	} catch (const std::exception& e) {
13252	>	SWIG_exception(SWIG_RuntimeError, e.what());
13253		}
13254	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
13255	<	return resultobj;
13256	<	fail:
13257	<	return NULL;
13254	>	}
13255	>	resultobj = result;
13256	>	return resultobj;
13257	>	fail:
13258	>	return NULL;
13259		}
13260
13261
13262	<	static PyObject *_wrap_new_BossTask__SWIG_1(PyObject *self, PyObject *args) {
13263	<	PyObject *resultobj;
13264	<	BossDatabase *arg1 = (BossDatabase *) 0 ;
13265	<	std::string *arg2 = 0 ;
13266	<	BossTask *result;
13267	<	std::string temp2 ;
13268	<	PyObject * obj0 = 0 ;
13269	<	PyObject * obj1 = 0 ;
13270	<
13271	<	if(!PyArg_ParseTuple(args,(char *)"OO:new_BossTask",&obj0,&obj1)) goto fail;
13272	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
13273	<	{
13274	<	if (PyString_Check(obj1)) {
13275	<	temp2 = std::string(PyString_AsString(obj1));
13276	<	arg2 = &temp2;
13277	<	}else {
13278	<	SWIG_exception(SWIG_TypeError, "string expected");
13279	<	}
13262	>	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13263	>	PyObject *resultobj = 0;
13264	>	BossSession *arg1 = (BossSession *) 0 ;
13265	>	std::string *arg2 = 0 ;
13266	>	std::string *arg3 = 0 ;
13267	>	std::string *arg4 = 0 ;
13268	>	std::string *arg5 = 0 ;
13269	>	bool arg6 ;
13270	>	PyObject *result = 0 ;
13271	>	void *argp1 = 0 ;
13272	>	int res1 = 0 ;
13273	>	int res2 = SWIG_OLDOBJ ;
13274	>	int res3 = SWIG_OLDOBJ ;
13275	>	int res4 = SWIG_OLDOBJ ;
13276	>	int res5 = SWIG_OLDOBJ ;
13277	>	bool val6 ;
13278	>	int ecode6 = 0 ;
13279	>	PyObject * obj0 = 0 ;
13280	>	PyObject * obj1 = 0 ;
13281	>	PyObject * obj2 = 0 ;
13282	>	PyObject * obj3 = 0 ;
13283	>	PyObject * obj4 = 0 ;
13284	>	PyObject * obj5 = 0 ;
13285	>
13286	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13287	>	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	<	{
13299	<	try {
3128	<	result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3129	<
3130	<	}catch (const std::exception& e) {
3131	<	SWIG_exception(SWIG_RuntimeError, e.what());
3132	<	}
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	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
13302	<	return resultobj;
13303	<	fail:
13304	<	return NULL;
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());
13346	>	}
13347	>	}
13348	>	resultobj = result;
13349	>	if (SWIG_IsNewObj(res2)) delete arg2;
13350	>	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;
13360		}
13361
13362
13363	<	static PyObject *_wrap_delete_BossTask(PyObject *self, PyObject *args) {
13364	<	PyObject *resultobj;
13365	<	BossTask *arg1 = (BossTask *) 0 ;
13366	<	PyObject * obj0 = 0 ;
13367	<
13368	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTask",&obj0)) goto fail;
13369	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
13370	<	{
13371	<	try {
13372	<	delete arg1;
13373	<
13374	<	}catch (const std::exception& e) {
13375	<	SWIG_exception(SWIG_RuntimeError, e.what());
13376	<	}
13363	>	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13364	>	PyObject *resultobj = 0;
13365	>	BossSession *arg1 = (BossSession *) 0 ;
13366	>	std::string *arg2 = 0 ;
13367	>	std::string *arg3 = 0 ;
13368	>	std::string *arg4 = 0 ;
13369	>	std::string *arg5 = 0 ;
13370	>	PyObject *result = 0 ;
13371	>	void *argp1 = 0 ;
13372	>	int res1 = 0 ;
13373	>	int res2 = SWIG_OLDOBJ ;
13374	>	int res3 = SWIG_OLDOBJ ;
13375	>	int res4 = SWIG_OLDOBJ ;
13376	>	int res5 = SWIG_OLDOBJ ;
13377	>	PyObject * obj0 = 0 ;
13378	>	PyObject * obj1 = 0 ;
13379	>	PyObject * obj2 = 0 ;
13380	>	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	<	Py_INCREF(Py_None); resultobj = Py_None;
13396	<	return resultobj;
13397	<	fail:
13398	<	return NULL;
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 &""'");
13430	>	}
13431	>	arg5 = ptr;
13432	>	}
13433	>	{
13434	>	try {
13435	>	result = (PyObject *)BossSession_schedListMatch__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
13436	>	} catch (const std::exception& e) {
13437	>	SWIG_exception(SWIG_RuntimeError, e.what());
13438	>	}
13439	>	}
13440	>	resultobj = result;
13441	>	if (SWIG_IsNewObj(res2)) delete arg2;
13442	>	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;
13452		}
13453
13454
13455	<	static PyObject *_wrap_new_BossTask__SWIG_2(PyObject *self, PyObject *args) {
13456	<	PyObject *resultobj;
13457	<	BossTask *arg1 = 0 ;
13458	<	BossTask *result;
13459	<	PyObject * obj0 = 0 ;
13460	<
13461	<	if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
13462	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
13463	<	if (arg1 == NULL) {
13464	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
13455	>	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13456	>	PyObject *resultobj = 0;
13457	>	BossSession *arg1 = (BossSession *) 0 ;
13458	>	std::string *arg2 = 0 ;
13459	>	std::string *arg3 = 0 ;
13460	>	std::string *arg4 = 0 ;
13461	>	PyObject *result = 0 ;
13462	>	void *argp1 = 0 ;
13463	>	int res1 = 0 ;
13464	>	int res2 = SWIG_OLDOBJ ;
13465	>	int res3 = SWIG_OLDOBJ ;
13466	>	int res4 = SWIG_OLDOBJ ;
13467	>	PyObject * obj0 = 0 ;
13468	>	PyObject * obj1 = 0 ;
13469	>	PyObject * obj2 = 0 ;
13470	>	PyObject * obj3 = 0 ;
13471	>
13472	>	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	<	{
13485	<	try {
3176	<	result = (BossTask *)new BossTask((BossTask const &)*arg1);
3177	<
3178	<	}catch (const std::exception& e) {
3179	<	SWIG_exception(SWIG_RuntimeError, e.what());
3180	<	}
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	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
13488	<	return resultobj;
13489	<	fail:
13490	<	return NULL;
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());
13516	>	}
13517	>	}
13518	>	resultobj = result;
13519	>	if (SWIG_IsNewObj(res2)) delete arg2;
13520	>	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;
13528		}
13529
13530
13531	<	static PyObject *_wrap_new_BossTask(PyObject *self, PyObject *args) {
13532	<	int argc;
13533	<	PyObject *argv[3];
13534	<	int ii;
13535	<
13536	<	argc = PyObject_Length(args);
13537	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
13538	<	argv[ii] = PyTuple_GetItem(args,ii);
13531	>	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13532	>	PyObject *resultobj = 0;
13533	>	BossSession *arg1 = (BossSession *) 0 ;
13534	>	std::string *arg2 = 0 ;
13535	>	std::string *arg3 = 0 ;
13536	>	PyObject *result = 0 ;
13537	>	void *argp1 = 0 ;
13538	>	int res1 = 0 ;
13539	>	int res2 = SWIG_OLDOBJ ;
13540	>	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 (argc == 1) {
13558	<	int _v;
13559	<	{
13560	<	void *ptr;
13561	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
13562	<	_v = 0;
13563	<	PyErr_Clear();
13564	<	}else {
13565	<	_v = 1;
13566	<	}
13567	<	}
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 &""'");
13570	>	}
13571	>	arg3 = ptr;
13572	>	}
13573	>	{
13574	>	try {
13575	>	result = (PyObject *)BossSession_schedListMatch__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
13576	>	} catch (const std::exception& e) {
13577	>	SWIG_exception(SWIG_RuntimeError, e.what());
13578	>	}
13579	>	}
13580	>	resultobj = result;
13581	>	if (SWIG_IsNewObj(res2)) delete arg2;
13582	>	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;
13588	>	}
13589	>
13590	>
13591	>	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
13592	>	int argc;
13593	>	PyObject *argv[7];
13594	>	int ii;
13595	>
13596	>	if (!PyTuple_Check(args)) SWIG_fail;
13597	>	argc = PyObject_Length(args);
13598	>	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
13599	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
13600	>	}
13601	>	if (argc == 3) {
13602	>	int _v;
13603	>	void *vptr = 0;
13604	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
13605	>	_v = SWIG_CheckState(res);
13606	>	if (_v) {
13607	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
13608	>	_v = SWIG_CheckState(res);
13609	>	if (_v) {
13610	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
13611	>	_v = SWIG_CheckState(res);
13612		if (_v) {
13613	<	return _wrap_new_BossTask__SWIG_0(self,args);
13613	>	return _wrap_BossSession_schedListMatch__SWIG_3(self, args);
13614		}
13615	+	}
13616		}
13617	<	if (argc == 1) {
13618	<	int _v;
13619	<	{
13620	<	void *ptr;
13621	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
13622	<	_v = 0;
13623	<	PyErr_Clear();
13624	<	}else {
13625	<	_v = 1;
13626	<	}
13627	<	}
13617	>	}
13618	>	if (argc == 4) {
13619	>	int _v;
13620	>	void *vptr = 0;
13621	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
13622	>	_v = SWIG_CheckState(res);
13623	>	if (_v) {
13624	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
13625	>	_v = SWIG_CheckState(res);
13626	>	if (_v) {
13627	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
13628	>	_v = SWIG_CheckState(res);
13629		if (_v) {
13630	<	return _wrap_new_BossTask__SWIG_2(self,args);
13630	>	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	>	}
13635		}
13636	+	}
13637		}
13638	<	if (argc == 2) {
13639	<	int _v;
13640	<	{
13641	<	void *ptr;
13642	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
13643	<	_v = 0;
13644	<	PyErr_Clear();
13645	<	}else {
13646	<	_v = 1;
13638	>	}
13639	>	if (argc == 5) {
13640	>	int _v;
13641	>	void *vptr = 0;
13642	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
13643	>	_v = SWIG_CheckState(res);
13644	>	if (_v) {
13645	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
13646	>	_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);
13658		}
13659	+	}
13660		}
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);
13675		if (_v) {
13676	<	{
13677	<	_v = PyString_Check(argv[1]) ? 1 : 0;
13678	<	}
13676	>	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
13677	>	_v = SWIG_CheckState(res);
13678	>	if (_v) {
13679	>	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
13680	>	_v = SWIG_CheckState(res);
13681		if (_v) {
13682	<	return _wrap_new_BossTask__SWIG_1(self,args);
13682	>	{
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	>	}
13689		}
13690	+	}
13691		}
13692	+	}
13693		}
13694	<
13695	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_BossTask'");
13696	<	return NULL;
13694	>	}
13695	>
13696	>	fail:
13697	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_schedListMatch'");
13698	>	return NULL;
13699		}
13700
13701
13702	<	static PyObject *_wrap_BossTask_id(PyObject *self, PyObject *args) {
13703	<	PyObject *resultobj;
13704	<	BossTask *arg1 = (BossTask *) 0 ;
13705	<	std::string *result;
13706	<	PyObject * obj0 = 0 ;
13707	<
13708	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_id",&obj0)) goto fail;
13709	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
13710	<	{
13711	<	try {
13712	<	{
13713	<	std::string const &_result_ref = ((BossTask const *)arg1)->id();
13714	<	result = (std::string *) &_result_ref;
13715	<	}
13716	<
13717	<	}catch (const std::exception& e) {
13718	<	SWIG_exception(SWIG_RuntimeError, e.what());
13719	<	}
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	<	{
13753	<	resultobj = PyString_FromStringAndSize(result->data(),result->size());
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	<	return resultobj;
13756	<	fail:
13757	<	return NULL;
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""'");
13784	>	}
13785	>	arg6 = *ptr;
13786	>	if (SWIG_IsNewObj(res)) delete ptr;
13787	>	}
13788	>	{
13789	>	std::string *ptr = (std::string *)0;
13790	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
13791	>	if (!SWIG_IsOK(res) || !ptr) {
13792	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "7"" of type '" "std::string""'");
13793	>	}
13794	>	arg7 = *ptr;
13795	>	if (SWIG_IsNewObj(res)) delete ptr;
13796	>	}
13797	>	{
13798	>	std::string *ptr = (std::string *)0;
13799	>	int res = SWIG_AsPtr_std_string(obj7, &ptr);
13800	>	if (!SWIG_IsOK(res) || !ptr) {
13801	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "8"" of type '" "std::string""'");
13802	>	}
13803	>	arg8 = *ptr;
13804	>	if (SWIG_IsNewObj(res)) delete ptr;
13805	>	}
13806	>	{
13807	>	std::string *ptr = (std::string *)0;
13808	>	int res = SWIG_AsPtr_std_string(obj8, &ptr);
13809	>	if (!SWIG_IsOK(res) || !ptr) {
13810	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "9"" of type '" "std::string""'");
13811	>	}
13812	>	arg9 = *ptr;
13813	>	if (SWIG_IsNewObj(res)) delete ptr;
13814	>	}
13815	>	ecode10 = SWIG_AsVal_bool(obj9, &val10);
13816	>	if (!SWIG_IsOK(ecode10)) {
13817	>	SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "BossSession_queryTasks" "', argument " "10"" of type '" "bool""'");
13818	>	}
13819	>	arg10 = static_cast< bool >(val10);
13820	>	{
13821	>	try {
13822	>	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
13823	>	} catch (const std::exception& e) {
13824	>	SWIG_exception(SWIG_RuntimeError, e.what());
13825	>	}
13826	>	}
13827	>	resultobj = result;
13828	>	if (SWIG_IsNewObj(res3)) delete arg3;
13829	>	if (SWIG_IsNewObj(res4)) delete arg4;
13830	>	if (SWIG_IsNewObj(res5)) delete arg5;
13831	>	return resultobj;
13832	>	fail:
13833	>	if (SWIG_IsNewObj(res3)) delete arg3;
13834	>	if (SWIG_IsNewObj(res4)) delete arg4;
13835	>	if (SWIG_IsNewObj(res5)) delete arg5;
13836	>	return NULL;
13837		}
13838
13839
13840	<	static PyObject *_wrap_BossTask_name(PyObject *self, PyObject *args) {
13841	<	PyObject *resultobj;
13842	<	BossTask *arg1 = (BossTask *) 0 ;
13843	<	std::string *result;
13844	<	PyObject * obj0 = 0 ;
13845	<
13846	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_name",&obj0)) goto fail;
13847	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
13848	<	{
13849	<	try {
13850	<	{
13851	<	std::string const &_result_ref = ((BossTask const *)arg1)->name();
13852	<	result = (std::string *) &_result_ref;
13853	<	}
13854	<
13855	<	}catch (const std::exception& e) {
13856	<	SWIG_exception(SWIG_RuntimeError, e.what());
13857	<	}
13840	>	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13841	>	PyObject *resultobj = 0;
13842	>	BossSession *arg1 = (BossSession *) 0 ;
13843	>	int arg2 ;
13844	>	std::string *arg3 = 0 ;
13845	>	std::string *arg4 = 0 ;
13846	>	std::string *arg5 = 0 ;
13847	>	std::string arg6 ;
13848	>	std::string arg7 ;
13849	>	std::string arg8 ;
13850	>	std::string arg9 ;
13851	>	PyObject *result = 0 ;
13852	>	void *argp1 = 0 ;
13853	>	int res1 = 0 ;
13854	>	int val2 ;
13855	>	int ecode2 = 0 ;
13856	>	int res3 = SWIG_OLDOBJ ;
13857	>	int res4 = SWIG_OLDOBJ ;
13858	>	int res5 = SWIG_OLDOBJ ;
13859	>	PyObject * obj0 = 0 ;
13860	>	PyObject * obj1 = 0 ;
13861	>	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	<	{
13887	<	resultobj = PyString_FromStringAndSize(result->data(),result->size());
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	<	return resultobj;
13890	<	fail:
13891	<	return NULL;
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""'");
13945	>	}
13946	>	arg9 = *ptr;
13947	>	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());
13954	>	}
13955	>	}
13956	>	resultobj = result;
13957	>	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;
13966		}
13967
13968
13969	<	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
13970	<	PyObject *resultobj;
13971	<	BossTask *arg1 = (BossTask *) 0 ;
13972	<	std::map<std::string,std::string > result;
13973	<	PyObject * obj0 = 0 ;
13974	<
13975	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
13976	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
13977	<	{
13978	<	try {
13979	<	result = ((BossTask const *)arg1)->taskMap();
13980	<
13981	<	}catch (const std::exception& e) {
13982	<	SWIG_exception(SWIG_RuntimeError, e.what());
13983	<	}
13969	>	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13970	>	PyObject *resultobj = 0;
13971	>	BossSession *arg1 = (BossSession *) 0 ;
13972	>	int arg2 ;
13973	>	std::string *arg3 = 0 ;
13974	>	std::string *arg4 = 0 ;
13975	>	std::string *arg5 = 0 ;
13976	>	std::string arg6 ;
13977	>	std::string arg7 ;
13978	>	std::string arg8 ;
13979	>	PyObject *result = 0 ;
13980	>	void *argp1 = 0 ;
13981	>	int res1 = 0 ;
13982	>	int val2 ;
13983	>	int ecode2 = 0 ;
13984	>	int res3 = SWIG_OLDOBJ ;
13985	>	int res4 = SWIG_OLDOBJ ;
13986	>	int res5 = SWIG_OLDOBJ ;
13987	>	PyObject * obj0 = 0 ;
13988	>	PyObject * obj1 = 0 ;
13989	>	PyObject * obj2 = 0 ;
13990	>	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	<	{
14014	<	resultobj = PyDict_New();
3328	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3329	<	PyDict_SetItem(resultobj,
3330	<	SwigString_FromString(i->first),
3331	<	SwigString_FromString(i->second));
3332	<	}
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	<	return resultobj;
14017	<	fail:
14018	<	return NULL;
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""'");
14063	>	}
14064	>	arg8 = *ptr;
14065	>	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());
14072	>	}
14073	>	}
14074	>	resultobj = result;
14075	>	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;
14084		}
14085
14086
14087	<	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
14088	<	PyObject *resultobj;
14089	<	BossTask *arg1 = (BossTask *) 0 ;
14090	<	BossTask::job_iterator result;
14091	<	PyObject * obj0 = 0 ;
14092	<
14093	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
14094	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
14095	<	{
14096	<	try {
14097	<	result = ((BossTask const *)arg1)->job_begin();
14098	<
14099	<	}catch (const std::exception& e) {
14100	<	SWIG_exception(SWIG_RuntimeError, e.what());
14101	<	}
14087	>	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14088	>	PyObject *resultobj = 0;
14089	>	BossSession *arg1 = (BossSession *) 0 ;
14090	>	int arg2 ;
14091	>	std::string *arg3 = 0 ;
14092	>	std::string *arg4 = 0 ;
14093	>	std::string *arg5 = 0 ;
14094	>	std::string arg6 ;
14095	>	std::string arg7 ;
14096	>	PyObject *result = 0 ;
14097	>	void *argp1 = 0 ;
14098	>	int res1 = 0 ;
14099	>	int val2 ;
14100	>	int ecode2 = 0 ;
14101	>	int res3 = SWIG_OLDOBJ ;
14102	>	int res4 = SWIG_OLDOBJ ;
14103	>	int res5 = SWIG_OLDOBJ ;
14104	>	PyObject * obj0 = 0 ;
14105	>	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	<	{
14130	<	BossTask::job_iterator * resultptr;
3358	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3359	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
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	<	return resultobj;
14133	<	fail:
14134	<	return NULL;
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""'");
14170	>	}
14171	>	arg7 = *ptr;
14172	>	if (SWIG_IsNewObj(res)) delete ptr;
14173	>	}
14174	>	{
14175	>	try {
14176	>	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
14177	>	} catch (const std::exception& e) {
14178	>	SWIG_exception(SWIG_RuntimeError, e.what());
14179	>	}
14180	>	}
14181	>	resultobj = result;
14182	>	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;
14191		}
14192
14193
14194	<	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
14195	<	PyObject *resultobj;
14196	<	BossTask *arg1 = (BossTask *) 0 ;
14197	<	BossTask::job_iterator result;
14198	<	PyObject * obj0 = 0 ;
14199	<
14200	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
14201	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
14202	<	{
14203	<	try {
14204	<	result = ((BossTask const *)arg1)->job_end();
14205	<
14206	<	}catch (const std::exception& e) {
14207	<	SWIG_exception(SWIG_RuntimeError, e.what());
14208	<	}
14194	>	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14195	>	PyObject *resultobj = 0;
14196	>	BossSession *arg1 = (BossSession *) 0 ;
14197	>	int arg2 ;
14198	>	std::string *arg3 = 0 ;
14199	>	std::string *arg4 = 0 ;
14200	>	std::string *arg5 = 0 ;
14201	>	std::string arg6 ;
14202	>	PyObject *result = 0 ;
14203	>	void *argp1 = 0 ;
14204	>	int res1 = 0 ;
14205	>	int val2 ;
14206	>	int ecode2 = 0 ;
14207	>	int res3 = SWIG_OLDOBJ ;
14208	>	int res4 = SWIG_OLDOBJ ;
14209	>	int res5 = SWIG_OLDOBJ ;
14210	>	PyObject * obj0 = 0 ;
14211	>	PyObject * obj1 = 0 ;
14212	>	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	<	{
14235	<	BossTask::job_iterator * resultptr;
3385	<	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3386	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
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	<	return resultobj;
14238	<	fail:
14239	<	return NULL;
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""'");
14266	>	}
14267	>	arg6 = *ptr;
14268	>	if (SWIG_IsNewObj(res)) delete ptr;
14269	>	}
14270	>	{
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());
14275	>	}
14276	>	}
14277	>	resultobj = result;
14278	>	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;
14287		}
14288
14289
14290	<	static PyObject *_wrap_BossTask_jobsMap__SWIG_0(PyObject *self, PyObject *args) {
14291	<	PyObject *resultobj;
14292	<	BossTask *arg1 = (BossTask *) 0 ;
14293	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
14294	<	PyObject * obj0 = 0 ;
14295	<
14296	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
14297	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
14298	<	{
14299	<	try {
14300	<	result = ((BossTask const *)arg1)->jobsMap();
14301	<
14302	<	}catch (const std::exception& e) {
14303	<	SWIG_exception(SWIG_RuntimeError, e.what());
14304	<	}
14290	>	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14291	>	PyObject *resultobj = 0;
14292	>	BossSession *arg1 = (BossSession *) 0 ;
14293	>	int arg2 ;
14294	>	std::string *arg3 = 0 ;
14295	>	std::string *arg4 = 0 ;
14296	>	std::string *arg5 = 0 ;
14297	>	PyObject *result = 0 ;
14298	>	void *argp1 = 0 ;
14299	>	int res1 = 0 ;
14300	>	int val2 ;
14301	>	int ecode2 = 0 ;
14302	>	int res3 = SWIG_OLDOBJ ;
14303	>	int res4 = SWIG_OLDOBJ ;
14304	>	int res5 = SWIG_OLDOBJ ;
14305	>	PyObject * obj0 = 0 ;
14306	>	PyObject * obj1 = 0 ;
14307	>	PyObject * obj2 = 0 ;
14308	>	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	<	{
14329	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3412	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3413	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
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	<	return resultobj;
14332	<	fail:
14333	<	return NULL;
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 &""'");
14352	>	}
14353	>	arg5 = ptr;
14354	>	}
14355	>	{
14356	>	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());
14360	>	}
14361	>	}
14362	>	resultobj = result;
14363	>	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;
14372		}
14373
14374
14375	<	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
14376	<	PyObject *resultobj;
14377	<	BossTask *arg1 = (BossTask *) 0 ;
14378	<	SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
14379	<	std::map<std::string,std::string > *arg3 = 0 ;
14380	<	std::string result;
14381	<	std::vector<BossJob * >::const_iterator *argp2 ;
14382	<	PyObject * obj0 = 0 ;
14383	<	PyObject * obj1 = 0 ;
14384	<	PyObject * obj2 = 0 ;
14385	<
14386	<	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobMap",&obj0,&obj1,&obj2)) goto fail;
14387	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
14388	<	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
14389	<	arg2 = *argp2;
14390	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
14391	<	if (arg3 == NULL) {
14392	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
14375	>	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14376	>	PyObject *resultobj = 0;
14377	>	BossSession *arg1 = (BossSession *) 0 ;
14378	>	int arg2 ;
14379	>	std::string *arg3 = 0 ;
14380	>	std::string *arg4 = 0 ;
14381	>	PyObject *result = 0 ;
14382	>	void *argp1 = 0 ;
14383	>	int res1 = 0 ;
14384	>	int val2 ;
14385	>	int ecode2 = 0 ;
14386	>	int res3 = SWIG_OLDOBJ ;
14387	>	int res4 = SWIG_OLDOBJ ;
14388	>	PyObject * obj0 = 0 ;
14389	>	PyObject * obj1 = 0 ;
14390	>	PyObject * obj2 = 0 ;
14391	>	PyObject * obj3 = 0 ;
14392	>
14393	>	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	<	{
14411	<	try {
3442	<	result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
3443	<
3444	<	}catch (const std::exception& e) {
3445	<	SWIG_exception(SWIG_RuntimeError, e.what());
3446	<	}
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	<	{
14414	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
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	<	return resultobj;
14422	<	fail:
14423	<	return NULL;
14421	>	if (!ptr) {
14422	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14423	>	}
14424	>	arg4 = ptr;
14425	>	}
14426	>	{
14427	>	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());
14431	>	}
14432	>	}
14433	>	resultobj = result;
14434	>	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;
14441		}
14442
14443
14444	<	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
14445	<	PyObject *resultobj;
14446	<	BossTask *arg1 = (BossTask *) 0 ;
14447	<	unsigned int arg2 ;
14448	<	std::map<std::string,std::string > result;
14449	<	PyObject * obj0 = 0 ;
14450	<	PyObject * obj1 = 0 ;
14451	<
14452	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
14453	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
14454	<	arg2 = (unsigned int) PyInt_AsLong(obj1);
14455	<	if (PyErr_Occurred()) SWIG_fail;
14456	<	{
14457	<	try {
14458	<	result = ((BossTask const *)arg1)->jobMap(arg2);
14459	<
14460	<	}catch (const std::exception& e) {
14461	<	SWIG_exception(SWIG_RuntimeError, e.what());
14462	<	}
14444	>	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14445	>	PyObject *resultobj = 0;
14446	>	BossSession *arg1 = (BossSession *) 0 ;
14447	>	int arg2 ;
14448	>	std::string *arg3 = 0 ;
14449	>	PyObject *result = 0 ;
14450	>	void *argp1 = 0 ;
14451	>	int res1 = 0 ;
14452	>	int val2 ;
14453	>	int ecode2 = 0 ;
14454	>	int res3 = SWIG_OLDOBJ ;
14455	>	PyObject * obj0 = 0 ;
14456	>	PyObject * obj1 = 0 ;
14457	>	PyObject * obj2 = 0 ;
14458	>
14459	>	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_queryTasks",&obj0,&obj1,&obj2)) SWIG_fail;
14460	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
14461	>	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 &""'");
14475		}
14476	<	{
14477	<	resultobj = PyDict_New();
3479	<	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3480	<	PyDict_SetItem(resultobj,
3481	<	SwigString_FromString(i->first),
3482	<	SwigString_FromString(i->second));
3483	<	}
14476	>	if (!ptr) {
14477	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14478		}
14479	<	return resultobj;
14480	<	fail:
14481	<	return NULL;
14479	>	arg3 = ptr;
14480	>	}
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());
14486	>	}
14487	>	}
14488	>	resultobj = result;
14489	>	if (SWIG_IsNewObj(res3)) delete arg3;
14490	>	return resultobj;
14491	>	fail:
14492	>	if (SWIG_IsNewObj(res3)) delete arg3;
14493	>	return NULL;
14494		}
14495
14496
14497	<	static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
14498	<	int argc;
14499	<	PyObject *argv[4];
14500	<	int ii;
14501	<
14502	<	argc = PyObject_Length(args);
14503	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
14504	<	argv[ii] = PyTuple_GetItem(args,ii);
14497	>	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14498	>	PyObject *resultobj = 0;
14499	>	BossSession *arg1 = (BossSession *) 0 ;
14500	>	int arg2 ;
14501	>	PyObject *result = 0 ;
14502	>	void *argp1 = 0 ;
14503	>	int res1 = 0 ;
14504	>	int val2 ;
14505	>	int ecode2 = 0 ;
14506	>	PyObject * obj0 = 0 ;
14507	>	PyObject * obj1 = 0 ;
14508	>
14509	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_queryTasks",&obj0,&obj1)) SWIG_fail;
14510	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
14511	>	if (!SWIG_IsOK(res1)) {
14512	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
14513	>	}
14514	>	arg1 = reinterpret_cast< BossSession * >(argp1);
14515	>	ecode2 = SWIG_AsVal_int(obj1, &val2);
14516	>	if (!SWIG_IsOK(ecode2)) {
14517	>	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
14518	>	}
14519	>	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());
14525		}
14526	<	if (argc == 2) {
14527	<	int _v;
14528	<	{
14529	<	void *ptr;
14530	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
14531	<	_v = 0;
14532	<	PyErr_Clear();
14533	<	}else {
14534	<	_v = 1;
14535	<	}
14526	>	}
14527	>	resultobj = result;
14528	>	return resultobj;
14529	>	fail:
14530	>	return NULL;
14531	>	}
14532	>
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());
14553	>	}
14554	>	}
14555	>	resultobj = result;
14556	>	return resultobj;
14557	>	fail:
14558	>	return NULL;
14559	>	}
14560	>
14561	>
14562	>	SWIGINTERN PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
14563	>	int argc;
14564	>	PyObject *argv[11];
14565	>	int ii;
14566	>
14567	>	if (!PyTuple_Check(args)) SWIG_fail;
14568	>	argc = PyObject_Length(args);
14569	>	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	<	{
14630	<	_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
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	>	}
14636	>	}
14637	>	}
14638	>	if (argc == 5) {
14639	>	int _v;
14640	>	void *vptr = 0;
14641	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14642	>	_v = SWIG_CheckState(res);
14643	>	if (_v) {
14644	>	{
14645	>	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);
14659		}
14660	+	}
14661	+	}
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);
14678	+	if (_v) {
14679	+	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
14680	+	_v = SWIG_CheckState(res);
14681	+	if (_v) {
14682	+	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
14683	+	_v = SWIG_CheckState(res);
14684		if (_v) {
14685	<	return _wrap_BossTask_jobMap__SWIG_1(self,args);
14685	>	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	>	}
14690		}
14691	+	}
14692		}
14693	+	}
14694		}
14695	<	if (argc == 3) {
14696	<	int _v;
14697	<	{
14698	<	void *ptr;
14699	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
14700	<	_v = 0;
14701	<	PyErr_Clear();
14702	<	}else {
14703	<	_v = 1;
14695	>	}
14696	>	if (argc == 7) {
14697	>	int _v;
14698	>	void *vptr = 0;
14699	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14700	>	_v = SWIG_CheckState(res);
14701	>	if (_v) {
14702	>	{
14703	>	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	>	}
14725		}
14726	+	}
14727		}
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);
14744		if (_v) {
14745	<	{
14746	<	void *ptr;
14747	<	if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator, 0) == -1) {
14748	<	_v = 0;
14749	<	PyErr_Clear();
14750	<	}else {
14751	<	_v = 1;
14745	>	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
14746	>	_v = SWIG_CheckState(res);
14747	>	if (_v) {
14748	>	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
14749	>	_v = SWIG_CheckState(res);
14750	>	if (_v) {
14751	>	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	>	}
14762		}
14763	+	}
14764		}
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);
14789		if (_v) {
14790	<	{
14791	<	void *ptr;
14792	<	if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_std__mapTstd__string_std__string_t, 0) == -1) {
14793	<	_v = 0;
14794	<	PyErr_Clear();
14795	<	}else {
14796	<	_v = 1;
14790	>	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
14791	>	_v = SWIG_CheckState(res);
14792	>	if (_v) {
14793	>	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
14794	>	_v = SWIG_CheckState(res);
14795	>	if (_v) {
14796	>	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);
14803		}
14804	+	}
14805		}
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);
14838		if (_v) {
14839	<	return _wrap_BossTask_jobMap__SWIG_0(self,args);
14839	>	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	>	}
14854		}
14855	+	}
14856		}
14857	+	}
14858		}
14859	+	}
14860		}
14861	<
14862	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobMap'");
14863	<	return NULL;
14861	>	}
14862	>
14863	>	fail:
14864	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_queryTasks'");
14865	>	return NULL;
14866		}
14867
14868
14869	<	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
14870	<	PyObject *resultobj;
14871	<	BossTask *arg1 = (BossTask *) 0 ;
14872	<	BossJob *arg2 = (BossJob *) 0 ;
14873	<	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
14874	<	PyObject * obj0 = 0 ;
14875	<	PyObject * obj1 = 0 ;
14876	<
14877	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
14878	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
14879	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
14880	<	{
14881	<	try {
14882	<	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
14883	<
14884	<	}catch (const std::exception& e) {
14885	<	SWIG_exception(SWIG_RuntimeError, e.what());
14886	<	}
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	<	std::map<std::string,std::map<std::string,std::string > > * resultptr;
14959	<	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
14960	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
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	<	return resultobj;
14988	<	fail:
14989	<	return NULL;
14987	>	}
14988	>	resultobj = SWIG_FromCharPtr(result);
14989	>	return resultobj;
14990	>	fail:
14991	>	return NULL;
14992		}
14993
14994
14995	<	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
14996	<	PyObject *resultobj;
14997	<	BossTask *arg1 = (BossTask *) 0 ;
14998	<	BossJob *arg2 = (BossJob *) 0 ;
14999	<	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
15000	<	PyObject * obj0 = 0 ;
15001	<	PyObject * obj1 = 0 ;
15002	<
15003	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
15004	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
15005	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
15006	<	{
15007	<	try {
15008	<	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
15009	<
15010	<	}catch (const std::exception& e) {
15011	<	SWIG_exception(SWIG_RuntimeError, e.what());
15012	<	}
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	<	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
15017	<	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
15018	<	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
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	<	return resultobj;
15051	<	fail:
15052	<	return NULL;
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	<	static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
15059	<	PyObject *resultobj;
15060	<	BossTask *arg1 = (BossTask *) 0 ;
15061	<	std::string *arg2 = 0 ;
15062	<	std::string const &arg3_defvalue = "" ;
15063	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
15064	<	std::string temp2 ;
15065	<	std::string temp3 ;
15066	<	PyObject * obj0 = 0 ;
15067	<	PyObject * obj1 = 0 ;
15068	<	PyObject * obj2 = 0 ;
15069	<
15070	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
15071	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
15072	<	{
15073	<	if (PyString_Check(obj1)) {
15074	<	temp2 = std::string(PyString_AsString(obj1));
15075	<	arg2 = &temp2;
15076	<	}else {
15077	<	SWIG_exception(SWIG_TypeError, "string expected");
15078	<	}
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 (obj2) {
15082	<	{
3647	<	if (PyString_Check(obj2)) {
3648	<	temp3 = std::string(PyString_AsString(obj2));
3649	<	arg3 = &temp3;
3650	<	}else {
3651	<	SWIG_exception(SWIG_TypeError, "string expected");
3652	<	}
3653	<	}
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	<	{
15085	<	try {
15086	<	(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
15087	<
15088	<	}catch (const std::exception& e) {
15089	<	SWIG_exception(SWIG_RuntimeError, e.what());
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;
15473	>	}
15474	>
15475	>
15476	>	SWIGINTERN PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
15477	>	int argc;
15478	>	PyObject *argv[4];
15479	>	int ii;
15480	>
15481	>	if (!PyTuple_Check(args)) SWIG_fail;
15482	>	argc = PyObject_Length(args);
15483	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
15484	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
15485	>	}
15486	>	if (argc == 2) {
15487	>	int _v;
15488	>	void *vptr = 0;
15489	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15490	>	_v = SWIG_CheckState(res);
15491	>	if (_v) {
15492	>	{
15493	>	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
15494	>	_v = SWIG_CheckState(res);
15495	>	}
15496	>	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);
15515		}
15516	+	}
15517		}
15518	<	Py_INCREF(Py_None); resultobj = Py_None;
15519	<	return resultobj;
15520	<	fail:
15521	<	return NULL;
15518	>	}
15519	>
15520	>	fail:
15521	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_jobMap'");
15522	>	return NULL;
15523		}
15524
15525
15526	<	static PyObject *_wrap_BossTask_declare__SWIG_1(PyObject *self, PyObject *args) {
15527	<	PyObject *resultobj;
15528	<	BossTask *arg1 = (BossTask *) 0 ;
15529	<	XMLDoc *arg2 = (XMLDoc *) 0 ;
15530	<	std::string const &arg3_defvalue = "" ;
15531	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
15532	<	std::string temp3 ;
15533	<	PyObject * obj0 = 0 ;
15534	<	PyObject * obj1 = 0 ;
15535	<	PyObject * obj2 = 0 ;
15536	<
15537	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
15538	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
15539	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_XMLDoc,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
15540	<	if (obj2) {
15541	<	{
15542	<	if (PyString_Check(obj2)) {
15543	<	temp3 = std::string(PyString_AsString(obj2));
15544	<	arg3 = &temp3;
15545	<	}else {
15546	<	SWIG_exception(SWIG_TypeError, "string expected");
15547	<	}
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());
15691	>	}
15692	>	}
15693	>	resultobj = SWIG_Py_Void();
15694	>	if (SWIG_IsNewObj(res2)) delete arg2;
15695	>	return resultobj;
15696	>	fail:
15697	>	if (SWIG_IsNewObj(res2)) delete arg2;
15698	>	return NULL;
15699	>	}
15700	>
15701	>
15702	>	SWIGINTERN PyObject *_wrap_BossTask_declare__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15703	>	PyObject *resultobj = 0;
15704	>	BossTask *arg1 = (BossTask *) 0 ;
15705	>	XMLDoc *arg2 = (XMLDoc *) 0 ;
15706	>	std::string *arg3 = 0 ;
15707	>	void *argp1 = 0 ;
15708	>	int res1 = 0 ;
15709	>	void *argp2 = 0 ;
15710	>	int res2 = 0 ;
15711	>	int res3 = SWIG_OLDOBJ ;
15712	>	PyObject * obj0 = 0 ;
15713	>	PyObject * obj1 = 0 ;
15714	>	PyObject * obj2 = 0 ;
15715	>
15716	>	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_declare",&obj0,&obj1,&obj2)) SWIG_fail;
15717	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15718	>	if (!SWIG_IsOK(res1)) {
15719	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_declare" "', argument " "1"" of type '" "BossTask *""'");
15720	>	}
15721	>	arg1 = reinterpret_cast< BossTask * >(argp1);
15722	>	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XMLDoc, 0 |  0 );
15723	>	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());
15743	>	}
15744	>	}
15745	>	resultobj = SWIG_Py_Void();
15746	>	if (SWIG_IsNewObj(res3)) delete arg3;
15747	>	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());
15781	>	}
15782	>	}
15783	>	resultobj = SWIG_Py_Void();
15784	>	return resultobj;
15785	>	fail:
15786	>	return NULL;
15787	>	}
15788	>
15789	>
15790	>	SWIGINTERN PyObject *_wrap_BossTask_declare(PyObject *self, PyObject *args) {
15791	>	int argc;
15792	>	PyObject *argv[4];
15793	>	int ii;
15794	>
15795	>	if (!PyTuple_Check(args)) SWIG_fail;
15796	>	argc = PyObject_Length(args);
15797	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
15798	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
15799	>	}
15800	>	if (argc == 2) {
15801	>	int _v;
15802	>	void *vptr = 0;
15803	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15804	>	_v = SWIG_CheckState(res);
15805	>	if (_v) {
15806	>	void *vptr = 0;
15807	>	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XMLDoc, 0);
15808	>	_v = SWIG_CheckState(res);
15809	>	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);
15841		}
15842	+	}
15843		}
15844	<	{
15845	<	try {
15846	<	(arg1)->declare(arg2,(std::string const &)*arg3);
15847	<
15848	<	}catch (const std::exception& e) {
15849	<	SWIG_exception(SWIG_RuntimeError, e.what());
15844	>	}
15845	>	if (argc == 3) {
15846	>	int _v;
15847	>	void *vptr = 0;
15848	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15849	>	_v = SWIG_CheckState(res);
15850	>	if (_v) {
15851	>	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);
15858		}
15859	+	}
15860		}
15861	<	Py_INCREF(Py_None); resultobj = Py_None;
15862	<	return resultobj;
15863	<	fail:
15864	<	return NULL;
15861	>	}
15862	>
15863	>	fail:
15864	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_declare'");
15865	>	return NULL;
15866		}
15867
15868
15869	<	static PyObject *_wrap_BossTask_declare(PyObject *self, PyObject *args) {
15870	<	int argc;
15871	<	PyObject *argv[4];
15872	<	int ii;
15873	<
15874	<	argc = PyObject_Length(args);
15875	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
15876	<	argv[ii] = PyTuple_GetItem(args,ii);
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	<	if ((argc >= 2) && (argc <= 3)) {
15889	<	int _v;
15890	<	{
15891	<	void *ptr;
15892	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
15893	<	_v = 0;
15894	<	PyErr_Clear();
15895	<	}else {
15896	<	_v = 1;
15897	<	}
15888	>	}
15889	>	resultobj = SWIG_Py_Void();
15890	>	return resultobj;
15891	>	fail:
15892	>	return NULL;
15893	>	}
15894	>
15895	>
15896	>	SWIGINTERN PyObject *_wrap_BossTask_archive__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15897	>	PyObject *resultobj = 0;
15898	>	BossTask *arg1 = (BossTask *) 0 ;
15899	>	std::string *arg2 = 0 ;
15900	>	void *argp1 = 0 ;
15901	>	int res1 = 0 ;
15902	>	int res2 = SWIG_OLDOBJ ;
15903	>	PyObject * obj0 = 0 ;
15904	>	PyObject * obj1 = 0 ;
15905	>
15906	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_archive",&obj0,&obj1)) SWIG_fail;
15907	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15908	>	if (!SWIG_IsOK(res1)) {
15909	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_archive" "', argument " "1"" of type '" "BossTask *""'");
15910	>	}
15911	>	arg1 = reinterpret_cast< BossTask * >(argp1);
15912	>	{
15913	>	std::string *ptr = (std::string *)0;
15914	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
15915	>	if (!SWIG_IsOK(res2)) {
15916	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_archive" "', argument " "2"" of type '" "std::string const &""'");
15917	>	}
15918	>	if (!ptr) {
15919	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_archive" "', argument " "2"" of type '" "std::string const &""'");
15920	>	}
15921	>	arg2 = ptr;
15922	>	}
15923	>	{
15924	>	try {
15925	>	(arg1)->archive((std::string const &)*arg2);
15926	>	} catch (const std::exception& e) {
15927	>	SWIG_exception(SWIG_RuntimeError, e.what());
15928	>	}
15929	>	}
15930	>	resultobj = SWIG_Py_Void();
15931	>	if (SWIG_IsNewObj(res2)) delete arg2;
15932	>	return resultobj;
15933	>	fail:
15934	>	if (SWIG_IsNewObj(res2)) delete arg2;
15935	>	return NULL;
15936	>	}
15937	>
15938	>
15939	>	SWIGINTERN PyObject *_wrap_BossTask_archive__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15940	>	PyObject *resultobj = 0;
15941	>	BossTask *arg1 = (BossTask *) 0 ;
15942	>	void *argp1 = 0 ;
15943	>	int res1 = 0 ;
15944	>	PyObject * obj0 = 0 ;
15945	>
15946	>	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_archive",&obj0)) SWIG_fail;
15947	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15948	>	if (!SWIG_IsOK(res1)) {
15949	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_archive" "', argument " "1"" of type '" "BossTask *""'");
15950	>	}
15951	>	arg1 = reinterpret_cast< BossTask * >(argp1);
15952	>	{
15953	>	try {
15954	>	(arg1)->archive();
15955	>	} catch (const std::exception& e) {
15956	>	SWIG_exception(SWIG_RuntimeError, e.what());
15957	>	}
15958	>	}
15959	>	resultobj = SWIG_Py_Void();
15960	>	return resultobj;
15961	>	fail:
15962	>	return NULL;
15963	>	}
15964	>
15965	>
15966	>	SWIGINTERN PyObject *_wrap_BossTask_archive(PyObject *self, PyObject *args) {
15967	>	int argc;
15968	>	PyObject *argv[3];
15969	>	int ii;
15970	>
15971	>	if (!PyTuple_Check(args)) SWIG_fail;
15972	>	argc = PyObject_Length(args);
15973	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
15974	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
15975	>	}
15976	>	if (argc == 1) {
15977	>	int _v;
15978	>	void *vptr = 0;
15979	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15980	>	_v = SWIG_CheckState(res);
15981	>	if (_v) {
15982	>	return _wrap_BossTask_archive__SWIG_1(self, args);
15983	>	}
15984	>	}
15985	>	if (argc == 2) {
15986	>	int _v;
15987	>	void *vptr = 0;
15988	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15989	>	_v = SWIG_CheckState(res);
15990	>	if (_v) {
15991	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
15992	>	_v = SWIG_CheckState(res);
15993	>	if (_v) {
15994	>	return _wrap_BossTask_archive__SWIG_0(self, args);
15995	>	}
15996	>	}
15997	>	}
15998	>
15999	>	fail:
16000	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_archive'");
16001	>	return NULL;
16002	>	}
16003	>
16004	>
16005	>	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16006	>	PyObject *resultobj = 0;
16007	>	BossTask *arg1 = (BossTask *) 0 ;
16008	>	std::string *arg2 = 0 ;
16009	>	std::string *arg3 = 0 ;
16010	>	std::string *arg4 = 0 ;
16011	>	std::string *arg5 = 0 ;
16012	>	std::string *arg6 = 0 ;
16013	>	bool arg7 ;
16014	>	int result;
16015	>	void *argp1 = 0 ;
16016	>	int res1 = 0 ;
16017	>	int res2 = SWIG_OLDOBJ ;
16018	>	int res3 = SWIG_OLDOBJ ;
16019	>	int res4 = SWIG_OLDOBJ ;
16020	>	int res5 = SWIG_OLDOBJ ;
16021	>	int res6 = SWIG_OLDOBJ ;
16022	>	bool val7 ;
16023	>	int ecode7 = 0 ;
16024	>	PyObject * obj0 = 0 ;
16025	>	PyObject * obj1 = 0 ;
16026	>	PyObject * obj2 = 0 ;
16027	>	PyObject * obj3 = 0 ;
16028	>	PyObject * obj4 = 0 ;
16029	>	PyObject * obj5 = 0 ;
16030	>	PyObject * obj6 = 0 ;
16031	>
16032	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16033	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16034	>	if (!SWIG_IsOK(res1)) {
16035	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
16036	>	}
16037	>	arg1 = reinterpret_cast< BossTask * >(argp1);
16038	>	{
16039	>	std::string *ptr = (std::string *)0;
16040	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16041	>	if (!SWIG_IsOK(res2)) {
16042	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16043	>	}
16044	>	if (!ptr) {
16045	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16046	>	}
16047	>	arg2 = ptr;
16048	>	}
16049	>	{
16050	>	std::string *ptr = (std::string *)0;
16051	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
16052	>	if (!SWIG_IsOK(res3)) {
16053	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16054	>	}
16055	>	if (!ptr) {
16056	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16057	>	}
16058	>	arg3 = ptr;
16059	>	}
16060	>	{
16061	>	std::string *ptr = (std::string *)0;
16062	>	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
16063	>	if (!SWIG_IsOK(res4)) {
16064	>	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16065	>	}
16066	>	if (!ptr) {
16067	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16068	>	}
16069	>	arg4 = ptr;
16070	>	}
16071	>	{
16072	>	std::string *ptr = (std::string *)0;
16073	>	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
16074	>	if (!SWIG_IsOK(res5)) {
16075	>	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
16076	>	}
16077	>	if (!ptr) {
16078	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
16079	>	}
16080	>	arg5 = ptr;
16081	>	}
16082	>	{
16083	>	std::string *ptr = (std::string *)0;
16084	>	res6 = SWIG_AsPtr_std_string(obj5, &ptr);
16085	>	if (!SWIG_IsOK(res6)) {
16086	>	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BossTask_submit" "', argument " "6"" of type '" "std::string const &""'");
16087	>	}
16088	>	if (!ptr) {
16089	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "6"" of type '" "std::string const &""'");
16090	>	}
16091	>	arg6 = ptr;
16092	>	}
16093	>	ecode7 = SWIG_AsVal_bool(obj6, &val7);
16094	>	if (!SWIG_IsOK(ecode7)) {
16095	>	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BossTask_submit" "', argument " "7"" of type '" "bool""'");
16096	>	}
16097	>	arg7 = static_cast< bool >(val7);
16098	>	{
16099	>	try {
16100	>	result = (int)(arg1)->submit((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(std::string const &)*arg6,arg7);
16101	>	} catch (const std::exception& e) {
16102	>	SWIG_exception(SWIG_RuntimeError, e.what());
16103	>	}
16104	>	}
16105	>	resultobj = SWIG_From_int(static_cast< int >(result));
16106	>	if (SWIG_IsNewObj(res2)) delete arg2;
16107	>	if (SWIG_IsNewObj(res3)) delete arg3;
16108	>	if (SWIG_IsNewObj(res4)) delete arg4;
16109	>	if (SWIG_IsNewObj(res5)) delete arg5;
16110	>	if (SWIG_IsNewObj(res6)) delete arg6;
16111	>	return resultobj;
16112	>	fail:
16113	>	if (SWIG_IsNewObj(res2)) delete arg2;
16114	>	if (SWIG_IsNewObj(res3)) delete arg3;
16115	>	if (SWIG_IsNewObj(res4)) delete arg4;
16116	>	if (SWIG_IsNewObj(res5)) delete arg5;
16117	>	if (SWIG_IsNewObj(res6)) delete arg6;
16118	>	return NULL;
16119	>	}
16120	>
16121	>
16122	>	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16123	>	PyObject *resultobj = 0;
16124	>	BossTask *arg1 = (BossTask *) 0 ;
16125	>	std::string *arg2 = 0 ;
16126	>	std::string *arg3 = 0 ;
16127	>	std::string *arg4 = 0 ;
16128	>	std::string *arg5 = 0 ;
16129	>	std::string *arg6 = 0 ;
16130	>	int result;
16131	>	void *argp1 = 0 ;
16132	>	int res1 = 0 ;
16133	>	int res2 = SWIG_OLDOBJ ;
16134	>	int res3 = SWIG_OLDOBJ ;
16135	>	int res4 = SWIG_OLDOBJ ;
16136	>	int res5 = SWIG_OLDOBJ ;
16137	>	int res6 = SWIG_OLDOBJ ;
16138	>	PyObject * obj0 = 0 ;
16139	>	PyObject * obj1 = 0 ;
16140	>	PyObject * obj2 = 0 ;
16141	>	PyObject * obj3 = 0 ;
16142	>	PyObject * obj4 = 0 ;
16143	>	PyObject * obj5 = 0 ;
16144	>
16145	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16146	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16147	>	if (!SWIG_IsOK(res1)) {
16148	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
16149	>	}
16150	>	arg1 = reinterpret_cast< BossTask * >(argp1);
16151	>	{
16152	>	std::string *ptr = (std::string *)0;
16153	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16154	>	if (!SWIG_IsOK(res2)) {
16155	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16156	>	}
16157	>	if (!ptr) {
16158	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16159	>	}
16160	>	arg2 = ptr;
16161	>	}
16162	>	{
16163	>	std::string *ptr = (std::string *)0;
16164	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
16165	>	if (!SWIG_IsOK(res3)) {
16166	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16167	>	}
16168	>	if (!ptr) {
16169	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
16170	>	}
16171	>	arg3 = ptr;
16172	>	}
16173	>	{
16174	>	std::string *ptr = (std::string *)0;
16175	>	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
16176	>	if (!SWIG_IsOK(res4)) {
16177	>	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16178	>	}
16179	>	if (!ptr) {
16180	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "4"" of type '" "std::string const &""'");
16181	>	}
16182	>	arg4 = ptr;
16183	>	}
16184	>	{
16185	>	std::string *ptr = (std::string *)0;
16186	>	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
16187	>	if (!SWIG_IsOK(res5)) {
16188	>	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
16189	>	}
16190	>	if (!ptr) {
16191	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "5"" of type '" "std::string const &""'");
16192	>	}
16193	>	arg5 = ptr;
16194	>	}
16195	>	{
16196	>	std::string *ptr = (std::string *)0;
16197	>	res6 = SWIG_AsPtr_std_string(obj5, &ptr);
16198	>	if (!SWIG_IsOK(res6)) {
16199	>	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BossTask_submit" "', argument " "6"" of type '" "std::string const &""'");
16200	>	}
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());
16445	>	}
16446	>	}
16447	>	resultobj = SWIG_From_int(static_cast< int >(result));
16448	>	if (SWIG_IsNewObj(res2)) delete arg2;
16449	>	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;
16455	>	}
16456	>
16457	>
16458	>	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16459	>	PyObject *resultobj = 0;
16460	>	BossTask *arg1 = (BossTask *) 0 ;
16461	>	std::string *arg2 = 0 ;
16462	>	int result;
16463	>	void *argp1 = 0 ;
16464	>	int res1 = 0 ;
16465	>	int res2 = SWIG_OLDOBJ ;
16466	>	PyObject * obj0 = 0 ;
16467	>	PyObject * obj1 = 0 ;
16468	>
16469	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_submit",&obj0,&obj1)) SWIG_fail;
16470	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16471	>	if (!SWIG_IsOK(res1)) {
16472	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
16473	>	}
16474	>	arg1 = reinterpret_cast< BossTask * >(argp1);
16475	>	{
16476	>	std::string *ptr = (std::string *)0;
16477	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16478	>	if (!SWIG_IsOK(res2)) {
16479	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
16480	>	}
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());
16491	>	}
16492	>	}
16493	>	resultobj = SWIG_From_int(static_cast< int >(result));
16494	>	if (SWIG_IsNewObj(res2)) delete arg2;
16495	>	return resultobj;
16496	>	fail:
16497	>	if (SWIG_IsNewObj(res2)) delete arg2;
16498	>	return NULL;
16499	>	}
16500	>
16501	>
16502	>	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());
16521	>	}
16522	>	}
16523	>	resultobj = SWIG_From_int(static_cast< int >(result));
16524	>	return resultobj;
16525	>	fail:
16526	>	return NULL;
16527	>	}
16528	>
16529	>
16530	>	SWIGINTERN PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
16531	>	int argc;
16532	>	PyObject *argv[8];
16533	>	int ii;
16534	>
16535	>	if (!PyTuple_Check(args)) SWIG_fail;
16536	>	argc = PyObject_Length(args);
16537	>	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	+	}
16577	+	}
16578	+	}
16579	+	if (argc == 4) {
16580	+	int _v;
16581	+	void *vptr = 0;
16582	+	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16583	+	_v = SWIG_CheckState(res);
16584	+	if (_v) {
16585	+	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
16586	+	_v = SWIG_CheckState(res);
16587	+	if (_v) {
16588	+	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
16589	+	_v = SWIG_CheckState(res);
16590		if (_v) {
16591	<	{
16592	<	void *ptr;
16593	<	if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_XMLDoc, 0) == -1) {
16594	<	_v = 0;
16595	<	PyErr_Clear();
16596	<	}else {
16597	<	_v = 1;
16598	<	}
16599	<	}
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	>	}
16596	>	}
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);
16611	>	if (_v) {
16612	>	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
16613	>	_v = SWIG_CheckState(res);
16614	>	if (_v) {
16615	>	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
16616	>	_v = SWIG_CheckState(res);
16617		if (_v) {
16618	<	if (argc <= 2) {
3741	<	return _wrap_BossTask_declare__SWIG_1(self,args);
3742	<	}
3743	<	{
3744	<	_v = PyString_Check(argv[2]) ? 1 : 0;
3745	<	}
3746	<	if (_v) {
3747	<	return _wrap_BossTask_declare__SWIG_1(self,args);
3748	<	}
16618	>	return _wrap_BossTask_submit__SWIG_2(self, args);
16619		}
16620	+	}
16621		}
16622	+	}
16623		}
16624	<	if ((argc >= 2) && (argc <= 3)) {
16625	<	int _v;
16626	<	{
16627	<	void *ptr;
16628	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
16629	<	_v = 0;
16630	<	PyErr_Clear();
16631	<	}else {
16632	<	_v = 1;
16624	>	}
16625	>	if (argc == 6) {
16626	>	int _v;
16627	>	void *vptr = 0;
16628	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16629	>	_v = SWIG_CheckState(res);
16630	>	if (_v) {
16631	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
16632	>	_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	>	}
16648		}
16649	+	}
16650		}
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);
16665		if (_v) {
16666	<	{
16667	<	_v = PyString_Check(argv[1]) ? 1 : 0;
16668	<	}
16666	>	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
16667	>	_v = SWIG_CheckState(res);
16668	>	if (_v) {
16669	>	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
16670	>	_v = SWIG_CheckState(res);
16671		if (_v) {
16672	<	if (argc <= 2) {
16673	<	return _wrap_BossTask_declare__SWIG_0(self,args);
16674	<	}
16672	>	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
16673	>	_v = SWIG_CheckState(res);
16674	>	if (_v) {
16675		{
16676	<	_v = PyString_Check(argv[2]) ? 1 : 0;
16676	>	int res = SWIG_AsVal_bool(argv[6], NULL);
16677	>	_v = SWIG_CheckState(res);
16678		}
16679		if (_v) {
16680	<	return _wrap_BossTask_declare__SWIG_0(self,args);
16680	>	return _wrap_BossTask_submit__SWIG_0(self, args);
16681		}
16682	+	}
16683		}
16684	+	}
16685		}
16686	+	}
16687		}
16688	<
16689	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_declare'");
16690	<	return NULL;
16688	>	}
16689	>
16690	>	fail:
16691	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_submit'");
16692	>	return NULL;
16693		}
16694
16695
16696	<	static PyObject *_wrap_BossTask_remove(PyObject *self, PyObject *args) {
16697	<	PyObject *resultobj;
16698	<	BossTask *arg1 = (BossTask *) 0 ;
16699	<	PyObject * obj0 = 0 ;
16700	<
16701	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_remove",&obj0)) goto fail;
16702	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
16703	<	{
16704	<	try {
16705	<	(arg1)->remove();
16706	<
16707	<	}catch (const std::exception& e) {
16708	<	SWIG_exception(SWIG_RuntimeError, e.what());
16709	<	}
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	<	Py_INCREF(Py_None); resultobj = Py_None;
16724	<	return resultobj;
16725	<	fail:
16726	<	return NULL;
16723	>	if (!ptr) {
16724	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_reSubmit" "', argument " "2"" of type '" "std::string const &""'");
16725	>	}
16726	>	arg2 = ptr;
16727	>	}
16728	>	ecode3 = SWIG_AsVal_bool(obj2, &val3);
16729	>	if (!SWIG_IsOK(ecode3)) {
16730	>	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_reSubmit" "', argument " "3"" of type '" "bool""'");
16731	>	}
16732	>	arg3 = static_cast< bool >(val3);
16733	>	{
16734	>	try {
16735	>	result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
16736	>	} catch (const std::exception& e) {
16737	>	SWIG_exception(SWIG_RuntimeError, e.what());
16738	>	}
16739	>	}
16740	>	resultobj = SWIG_From_int(static_cast< int >(result));
16741	>	if (SWIG_IsNewObj(res2)) delete arg2;
16742	>	return resultobj;
16743	>	fail:
16744	>	if (SWIG_IsNewObj(res2)) delete arg2;
16745	>	return NULL;
16746		}
16747
16748
16749	<	static PyObject *_wrap_BossTask_archive(PyObject *self, PyObject *args) {
16750	<	PyObject *resultobj;
16751	<	BossTask *arg1 = (BossTask *) 0 ;
16752	<	std::string const &arg2_defvalue = "all" ;
16753	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
16754	<	std::string temp2 ;
16755	<	PyObject * obj0 = 0 ;
16756	<	PyObject * obj1 = 0 ;
16757	<
16758	<	if(!PyArg_ParseTuple(args,(char *)"O|O:BossTask_archive",&obj0,&obj1)) goto fail;
16759	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
16760	<	if (obj1) {
16761	<	{
16762	<	if (PyString_Check(obj1)) {
16763	<	temp2 = std::string(PyString_AsString(obj1));
16764	<	arg2 = &temp2;
16765	<	}else {
16766	<	SWIG_exception(SWIG_TypeError, "string expected");
16767	<	}
16768	<	}
16749	>	SWIGINTERN PyObject *_wrap_BossTask_reSubmit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16750	>	PyObject *resultobj = 0;
16751	>	BossTask *arg1 = (BossTask *) 0 ;
16752	>	std::string *arg2 = 0 ;
16753	>	int result;
16754	>	void *argp1 = 0 ;
16755	>	int res1 = 0 ;
16756	>	int res2 = SWIG_OLDOBJ ;
16757	>	PyObject * obj0 = 0 ;
16758	>	PyObject * obj1 = 0 ;
16759	>
16760	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_reSubmit",&obj0,&obj1)) SWIG_fail;
16761	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16762	>	if (!SWIG_IsOK(res1)) {
16763	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_reSubmit" "', argument " "1"" of type '" "BossTask *""'");
16764	>	}
16765	>	arg1 = reinterpret_cast< BossTask * >(argp1);
16766	>	{
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	<	{
16773	<	try {
3831	<	(arg1)->archive((std::string const &)*arg2);
3832	<
3833	<	}catch (const std::exception& e) {
3834	<	SWIG_exception(SWIG_RuntimeError, e.what());
3835	<	}
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	<	Py_INCREF(Py_None); resultobj = Py_None;
16776	<	return resultobj;
16777	<	fail:
16778	<	return NULL;
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());
16782	>	}
16783	>	}
16784	>	resultobj = SWIG_From_int(static_cast< int >(result));
16785	>	if (SWIG_IsNewObj(res2)) delete arg2;
16786	>	return resultobj;
16787	>	fail:
16788	>	if (SWIG_IsNewObj(res2)) delete arg2;
16789	>	return NULL;
16790		}
16791
16792
16793	<	static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
16794	<	PyObject *resultobj;
16795	<	BossTask *arg1 = (BossTask *) 0 ;
16796	<	std::string const &arg2_defvalue = "all" ;
16797	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
16798	<	std::string const &arg3_defvalue = "" ;
16799	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
16800	<	std::string const &arg4_defvalue = "" ;
16801	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
16802	<	std::string const &arg5_defvalue = "" ;
16803	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
16804	<	std::string const &arg6_defvalue = "" ;
16805	<	std::string *arg6 = (std::string *) &arg6_defvalue ;
16806	<	bool arg7 = (bool) false ;
16807	<	int result;
16808	<	std::string temp2 ;
16809	<	std::string temp3 ;
16810	<	std::string temp4 ;
16811	<	std::string temp5 ;
16812	<	std::string temp6 ;
16813	<	PyObject * obj0 = 0 ;
16814	<	PyObject * obj1 = 0 ;
16815	<	PyObject * obj2 = 0 ;
16816	<	PyObject * obj3 = 0 ;
16817	<	PyObject * obj4 = 0 ;
16818	<	PyObject * obj5 = 0 ;
16819	<	PyObject * obj6 = 0 ;
16820	<
16821	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
16822	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
16823	<	if (obj1) {
16793	>	SWIGINTERN PyObject *_wrap_BossTask_reSubmit(PyObject *self, PyObject *args) {
16794	>	int argc;
16795	>	PyObject *argv[4];
16796	>	int ii;
16797	>
16798	>	if (!PyTuple_Check(args)) SWIG_fail;
16799	>	argc = PyObject_Length(args);
16800	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
16801	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
16802	>	}
16803	>	if (argc == 2) {
16804	>	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) {
16825		{
16826	<	if (PyString_Check(obj1)) {
16827	<	temp2 = std::string(PyString_AsString(obj1));
16828	<	arg2 = &temp2;
16829	<	}else {
16830	<	SWIG_exception(SWIG_TypeError, "string expected");
3881	<	}
16826	>	int res = SWIG_AsVal_bool(argv[2], NULL);
16827	>	_v = SWIG_CheckState(res);
16828	>	}
16829	>	if (_v) {
16830	>	return _wrap_BossTask_reSubmit__SWIG_0(self, args);
16831		}
16832	+	}
16833		}
16834	<	if (obj2) {
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 &""'");
16871	>	}
16872	>	arg2 = ptr;
16873	>	}
16874	>	ecode3 = SWIG_AsVal_bool(obj2, &val3);
16875	>	if (!SWIG_IsOK(ecode3)) {
16876	>	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_kill" "', argument " "3"" of type '" "bool""'");
16877	>	}
16878	>	arg3 = static_cast< bool >(val3);
16879	>	{
16880	>	try {
16881	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
16882	>	} catch (const std::exception& e) {
16883	>	SWIG_exception(SWIG_RuntimeError, e.what());
16884	>	}
16885	>	}
16886	>	resultobj = SWIG_From_int(static_cast< int >(result));
16887	>	if (SWIG_IsNewObj(res2)) delete arg2;
16888	>	return resultobj;
16889	>	fail:
16890	>	if (SWIG_IsNewObj(res2)) delete arg2;
16891	>	return NULL;
16892	>	}
16893	>
16894	>
16895	>	SWIGINTERN PyObject *_wrap_BossTask_kill__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16896	>	PyObject *resultobj = 0;
16897	>	BossTask *arg1 = (BossTask *) 0 ;
16898	>	std::string *arg2 = 0 ;
16899	>	int result;
16900	>	void *argp1 = 0 ;
16901	>	int res1 = 0 ;
16902	>	int res2 = SWIG_OLDOBJ ;
16903	>	PyObject * obj0 = 0 ;
16904	>	PyObject * obj1 = 0 ;
16905	>
16906	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_kill",&obj0,&obj1)) SWIG_fail;
16907	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16908	>	if (!SWIG_IsOK(res1)) {
16909	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_kill" "', argument " "1"" of type '" "BossTask *""'");
16910	>	}
16911	>	arg1 = reinterpret_cast< BossTask * >(argp1);
16912	>	{
16913	>	std::string *ptr = (std::string *)0;
16914	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16915	>	if (!SWIG_IsOK(res2)) {
16916	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_kill" "', argument " "2"" of type '" "std::string const &""'");
16917	>	}
16918	>	if (!ptr) {
16919	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_kill" "', argument " "2"" of type '" "std::string const &""'");
16920	>	}
16921	>	arg2 = ptr;
16922	>	}
16923	>	{
16924	>	try {
16925	>	result = (int)(arg1)->kill((std::string const &)*arg2);
16926	>	} catch (const std::exception& e) {
16927	>	SWIG_exception(SWIG_RuntimeError, e.what());
16928	>	}
16929	>	}
16930	>	resultobj = SWIG_From_int(static_cast< int >(result));
16931	>	if (SWIG_IsNewObj(res2)) delete arg2;
16932	>	return resultobj;
16933	>	fail:
16934	>	if (SWIG_IsNewObj(res2)) delete arg2;
16935	>	return NULL;
16936	>	}
16937	>
16938	>
16939	>	SWIGINTERN PyObject *_wrap_BossTask_kill(PyObject *self, PyObject *args) {
16940	>	int argc;
16941	>	PyObject *argv[4];
16942	>	int ii;
16943	>
16944	>	if (!PyTuple_Check(args)) SWIG_fail;
16945	>	argc = PyObject_Length(args);
16946	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
16947	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
16948	>	}
16949	>	if (argc == 2) {
16950	>	int _v;
16951	>	void *vptr = 0;
16952	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16953	>	_v = SWIG_CheckState(res);
16954	>	if (_v) {
16955	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
16956	>	_v = SWIG_CheckState(res);
16957	>	if (_v) {
16958	>	return _wrap_BossTask_kill__SWIG_1(self, args);
16959	>	}
16960	>	}
16961	>	}
16962	>	if (argc == 3) {
16963	>	int _v;
16964	>	void *vptr = 0;
16965	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
16966	>	_v = SWIG_CheckState(res);
16967	>	if (_v) {
16968	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
16969	>	_v = SWIG_CheckState(res);
16970	>	if (_v) {
16971		{
16972	<	if (PyString_Check(obj2)) {
16973	<	temp3 = std::string(PyString_AsString(obj2));
3888	<	arg3 = &temp3;
3889	<	}else {
3890	<	SWIG_exception(SWIG_TypeError, "string expected");
3891	<	}
16972	>	int res = SWIG_AsVal_bool(argv[2], NULL);
16973	>	_v = SWIG_CheckState(res);
16974		}
16975	+	if (_v) {
16976	+	return _wrap_BossTask_kill__SWIG_0(self, args);
16977	+	}
16978	+	}
16979		}
16980	<	if (obj3) {
16981	<	{
16982	<	if (PyString_Check(obj3)) {
16983	<	temp4 = std::string(PyString_AsString(obj3));
16984	<	arg4 = &temp4;
16985	<	}else {
16986	<	SWIG_exception(SWIG_TypeError, "string expected");
16987	<	}
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 &""'");
17163	>	}
17164	>	arg2 = ptr;
17165	>	}
17166	>	{
17167	>	std::string *ptr = (std::string *)0;
17168	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17169	>	if (!SWIG_IsOK(res3)) {
17170	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
17171	>	}
17172	>	if (!ptr) {
17173	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
17174	>	}
17175	>	arg3 = ptr;
17176	>	}
17177	>	{
17178	>	try {
17179	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3);
17180	>	} catch (const std::exception& e) {
17181	>	SWIG_exception(SWIG_RuntimeError, e.what());
17182	>	}
17183	>	}
17184	>	resultobj = SWIG_From_int(static_cast< int >(result));
17185	>	if (SWIG_IsNewObj(res2)) delete arg2;
17186	>	if (SWIG_IsNewObj(res3)) delete arg3;
17187	>	return resultobj;
17188	>	fail:
17189	>	if (SWIG_IsNewObj(res2)) delete arg2;
17190	>	if (SWIG_IsNewObj(res3)) delete arg3;
17191	>	return NULL;
17192	>	}
17193	>
17194	>
17195	>	SWIGINTERN PyObject *_wrap_BossTask_getOutput__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17196	>	PyObject *resultobj = 0;
17197	>	BossTask *arg1 = (BossTask *) 0 ;
17198	>	std::string *arg2 = 0 ;
17199	>	int result;
17200	>	void *argp1 = 0 ;
17201	>	int res1 = 0 ;
17202	>	int res2 = SWIG_OLDOBJ ;
17203	>	PyObject * obj0 = 0 ;
17204	>	PyObject * obj1 = 0 ;
17205	>
17206	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_getOutput",&obj0,&obj1)) SWIG_fail;
17207	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17208	>	if (!SWIG_IsOK(res1)) {
17209	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getOutput" "', argument " "1"" of type '" "BossTask *""'");
17210	>	}
17211	>	arg1 = reinterpret_cast< BossTask * >(argp1);
17212	>	{
17213	>	std::string *ptr = (std::string *)0;
17214	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17215	>	if (!SWIG_IsOK(res2)) {
17216	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17217	>	}
17218	>	if (!ptr) {
17219	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17220	>	}
17221	>	arg2 = ptr;
17222	>	}
17223	>	{
17224	>	try {
17225	>	result = (int)(arg1)->getOutput((std::string const &)*arg2);
17226	>	} catch (const std::exception& e) {
17227	>	SWIG_exception(SWIG_RuntimeError, e.what());
17228	>	}
17229	>	}
17230	>	resultobj = SWIG_From_int(static_cast< int >(result));
17231	>	if (SWIG_IsNewObj(res2)) delete arg2;
17232	>	return resultobj;
17233	>	fail:
17234	>	if (SWIG_IsNewObj(res2)) delete arg2;
17235	>	return NULL;
17236	>	}
17237	>
17238	>
17239	>	SWIGINTERN PyObject *_wrap_BossTask_getOutput__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240	>	PyObject *resultobj = 0;
17241	>	BossTask *arg1 = (BossTask *) 0 ;
17242	>	int result;
17243	>	void *argp1 = 0 ;
17244	>	int res1 = 0 ;
17245	>	PyObject * obj0 = 0 ;
17246	>
17247	>	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_getOutput",&obj0)) SWIG_fail;
17248	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17249	>	if (!SWIG_IsOK(res1)) {
17250	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getOutput" "', argument " "1"" of type '" "BossTask *""'");
17251	>	}
17252	>	arg1 = reinterpret_cast< BossTask * >(argp1);
17253	>	{
17254	>	try {
17255	>	result = (int)(arg1)->getOutput();
17256	>	} catch (const std::exception& e) {
17257	>	SWIG_exception(SWIG_RuntimeError, e.what());
17258	>	}
17259	>	}
17260	>	resultobj = SWIG_From_int(static_cast< int >(result));
17261	>	return resultobj;
17262	>	fail:
17263	>	return NULL;
17264	>	}
17265	>
17266	>
17267	>	SWIGINTERN PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
17268	>	int argc;
17269	>	PyObject *argv[6];
17270	>	int ii;
17271	>
17272	>	if (!PyTuple_Check(args)) SWIG_fail;
17273	>	argc = PyObject_Length(args);
17274	>	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
17275	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
17276	>	}
17277	>	if (argc == 1) {
17278	>	int _v;
17279	>	void *vptr = 0;
17280	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17281	>	_v = SWIG_CheckState(res);
17282	>	if (_v) {
17283	>	return _wrap_BossTask_getOutput__SWIG_4(self, args);
17284	>	}
17285	>	}
17286	>	if (argc == 2) {
17287	>	int _v;
17288	>	void *vptr = 0;
17289	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17290	>	_v = SWIG_CheckState(res);
17291	>	if (_v) {
17292	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17293	>	_v = SWIG_CheckState(res);
17294	>	if (_v) {
17295	>	return _wrap_BossTask_getOutput__SWIG_3(self, args);
17296	>	}
17297	>	}
17298	>	}
17299	>	if (argc == 3) {
17300	>	int _v;
17301	>	void *vptr = 0;
17302	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17303	>	_v = SWIG_CheckState(res);
17304	>	if (_v) {
17305	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17306	>	_v = SWIG_CheckState(res);
17307	>	if (_v) {
17308	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
17309	>	_v = SWIG_CheckState(res);
17310	>	if (_v) {
17311	>	return _wrap_BossTask_getOutput__SWIG_2(self, args);
17312		}
17313	+	}
17314		}
17315	<	if (obj4) {
17316	<	{
17317	<	if (PyString_Check(obj4)) {
17318	<	temp5 = std::string(PyString_AsString(obj4));
17319	<	arg5 = &temp5;
17320	<	}else {
17321	<	SWIG_exception(SWIG_TypeError, "string expected");
17322	<	}
17315	>	}
17316	>	if (argc == 4) {
17317	>	int _v;
17318	>	void *vptr = 0;
17319	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17320	>	_v = SWIG_CheckState(res);
17321	>	if (_v) {
17322	>	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	>	}
17335		}
17336	+	}
17337		}
17338	<	if (obj5) {
17339	<	{
17340	<	if (PyString_Check(obj5)) {
17341	<	temp6 = std::string(PyString_AsString(obj5));
17342	<	arg6 = &temp6;
17343	<	}else {
17344	<	SWIG_exception(SWIG_TypeError, "string expected");
17338	>	}
17339	>	if (argc == 5) {
17340	>	int _v;
17341	>	void *vptr = 0;
17342	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17343	>	_v = SWIG_CheckState(res);
17344	>	if (_v) {
17345	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17346	>	_v = SWIG_CheckState(res);
17347	>	if (_v) {
17348	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
17349	>	_v = SWIG_CheckState(res);
17350	>	if (_v) {
17351	>	{
17352	>	int res = SWIG_AsVal_bool(argv[3], NULL);
17353	>	_v = SWIG_CheckState(res);
17354	>	}
17355	>	if (_v) {
17356	>	{
17357	>	int res = SWIG_AsVal_bool(argv[4], NULL);
17358	>	_v = SWIG_CheckState(res);
17359		}
17360	+	if (_v) {
17361	+	return _wrap_BossTask_getOutput__SWIG_0(self, args);
17362	+	}
17363	+	}
17364		}
17365	+	}
17366		}
17367	<	if (obj6) {
17368	<	arg7 = PyInt_AsLong(obj6) ? true : false;
17369	<	if (PyErr_Occurred()) SWIG_fail;
17367	>	}
17368	>
17369	>	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 &""'");
17405		}
17406	<	{
17407	<	try {
3930	<	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);
3931	<
3932	<	}catch (const std::exception& e) {
3933	<	SWIG_exception(SWIG_RuntimeError, e.what());
3934	<	}
17406	>	if (!ptr) {
17407	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
17408		}
17409	<	resultobj = PyInt_FromLong((long)result);
17410	<	return resultobj;
17411	<	fail:
17412	<	return NULL;
17409	>	arg2 = ptr;
17410	>	}
17411	>	ecode3 = SWIG_AsVal_bool(obj2, &val3);
17412	>	if (!SWIG_IsOK(ecode3)) {
17413	>	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_getAllOutput" "', argument " "3"" of type '" "bool""'");
17414	>	}
17415	>	arg3 = static_cast< bool >(val3);
17416	>	ecode4 = SWIG_AsVal_bool(obj3, &val4);
17417	>	if (!SWIG_IsOK(ecode4)) {
17418	>	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_getAllOutput" "', argument " "4"" of type '" "bool""'");
17419	>	}
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());
17426	>	}
17427	>	}
17428	>	resultobj = SWIG_From_int(static_cast< int >(result));
17429	>	if (SWIG_IsNewObj(res2)) delete arg2;
17430	>	return resultobj;
17431	>	fail:
17432	>	if (SWIG_IsNewObj(res2)) delete arg2;
17433	>	return NULL;
17434		}
17435
17436
17437	<	static PyObject *_wrap_BossTask_reSubmit(PyObject *self, PyObject *args) {
17438	<	PyObject *resultobj;
17439	<	BossTask *arg1 = (BossTask *) 0 ;
17440	<	std::string *arg2 = 0 ;
17441	<	bool arg3 = (bool) false ;
17442	<	int result;
17443	<	std::string temp2 ;
17444	<	PyObject * obj0 = 0 ;
17445	<	PyObject * obj1 = 0 ;
17446	<	PyObject * obj2 = 0 ;
17447	<
17448	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_reSubmit",&obj0,&obj1,&obj2)) goto fail;
17449	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
17450	<	{
17451	<	if (PyString_Check(obj1)) {
17452	<	temp2 = std::string(PyString_AsString(obj1));
17453	<	arg2 = &temp2;
17454	<	}else {
17455	<	SWIG_exception(SWIG_TypeError, "string expected");
17456	<	}
17437	>	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17438	>	PyObject *resultobj = 0;
17439	>	BossTask *arg1 = (BossTask *) 0 ;
17440	>	std::string *arg2 = 0 ;
17441	>	bool arg3 ;
17442	>	int result;
17443	>	void *argp1 = 0 ;
17444	>	int res1 = 0 ;
17445	>	int res2 = SWIG_OLDOBJ ;
17446	>	bool val3 ;
17447	>	int ecode3 = 0 ;
17448	>	PyObject * obj0 = 0 ;
17449	>	PyObject * obj1 = 0 ;
17450	>	PyObject * obj2 = 0 ;
17451	>
17452	>	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2)) SWIG_fail;
17453	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17454	>	if (!SWIG_IsOK(res1)) {
17455	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getAllOutput" "', argument " "1"" of type '" "BossTask *""'");
17456	>	}
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 &""'");
17463		}
17464	<	if (obj2) {
17465	<	arg3 = PyInt_AsLong(obj2) ? true : false;
3966	<	if (PyErr_Occurred()) SWIG_fail;
17464	>	if (!ptr) {
17465	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
17466		}
17467	<	{
17468	<	try {
17469	<	result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
17470	<
17471	<	}catch (const std::exception& e) {
17472	<	SWIG_exception(SWIG_RuntimeError, e.what());
17473	<	}
17467	>	arg2 = ptr;
17468	>	}
17469	>	ecode3 = SWIG_AsVal_bool(obj2, &val3);
17470	>	if (!SWIG_IsOK(ecode3)) {
17471	>	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_getAllOutput" "', argument " "3"" of type '" "bool""'");
17472	>	}
17473	>	arg3 = static_cast< bool >(val3);
17474	>	{
17475	>	try {
17476	>	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3);
17477	>	} catch (const std::exception& e) {
17478	>	SWIG_exception(SWIG_RuntimeError, e.what());
17479		}
17480	<	resultobj = PyInt_FromLong((long)result);
17481	<	return resultobj;
17482	<	fail:
17483	<	return NULL;
17480	>	}
17481	>	resultobj = SWIG_From_int(static_cast< int >(result));
17482	>	if (SWIG_IsNewObj(res2)) delete arg2;
17483	>	return resultobj;
17484	>	fail:
17485	>	if (SWIG_IsNewObj(res2)) delete arg2;
17486	>	return NULL;
17487		}
17488
17489
17490	<	static PyObject *_wrap_BossTask_kill(PyObject *self, PyObject *args) {
17491	<	PyObject *resultobj;
17492	<	BossTask *arg1 = (BossTask *) 0 ;
17493	<	std::string *arg2 = 0 ;
17494	<	bool arg3 = (bool) false ;
17495	<	int result;
17496	<	std::string temp2 ;
17497	<	PyObject * obj0 = 0 ;
17498	<	PyObject * obj1 = 0 ;
17499	<	PyObject * obj2 = 0 ;
17500	<
17501	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
17502	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
17503	<	{
17504	<	if (PyString_Check(obj1)) {
17505	<	temp2 = std::string(PyString_AsString(obj1));
17506	<	arg2 = &temp2;
17507	<	}else {
17508	<	SWIG_exception(SWIG_TypeError, "string expected");
17509	<	}
17490	>	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17491	>	PyObject *resultobj = 0;
17492	>	BossTask *arg1 = (BossTask *) 0 ;
17493	>	std::string *arg2 = 0 ;
17494	>	int result;
17495	>	void *argp1 = 0 ;
17496	>	int res1 = 0 ;
17497	>	int res2 = SWIG_OLDOBJ ;
17498	>	PyObject * obj0 = 0 ;
17499	>	PyObject * obj1 = 0 ;
17500	>
17501	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_getAllOutput",&obj0,&obj1)) SWIG_fail;
17502	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17503	>	if (!SWIG_IsOK(res1)) {
17504	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getAllOutput" "', argument " "1"" of type '" "BossTask *""'");
17505	>	}
17506	>	arg1 = reinterpret_cast< BossTask * >(argp1);
17507	>	{
17508	>	std::string *ptr = (std::string *)0;
17509	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17510	>	if (!SWIG_IsOK(res2)) {
17511	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
17512		}
17513	<	if (obj2) {
17514	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4006	<	if (PyErr_Occurred()) SWIG_fail;
17513	>	if (!ptr) {
17514	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
17515		}
17516	<	{
17517	<	try {
17518	<	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
17519	<
17520	<	}catch (const std::exception& e) {
17521	<	SWIG_exception(SWIG_RuntimeError, e.what());
17522	<	}
17516	>	arg2 = ptr;
17517	>	}
17518	>	{
17519	>	try {
17520	>	result = (int)(arg1)->getAllOutput((std::string const &)*arg2);
17521	>	} catch (const std::exception& e) {
17522	>	SWIG_exception(SWIG_RuntimeError, e.what());
17523		}
17524	<	resultobj = PyInt_FromLong((long)result);
17525	<	return resultobj;
17526	<	fail:
17527	<	return NULL;
17524	>	}
17525	>	resultobj = SWIG_From_int(static_cast< int >(result));
17526	>	if (SWIG_IsNewObj(res2)) delete arg2;
17527	>	return resultobj;
17528	>	fail:
17529	>	if (SWIG_IsNewObj(res2)) delete arg2;
17530	>	return NULL;
17531		}
17532
17533
17534	<	static PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *self, PyObject *args) {
17535	<	PyObject *resultobj;
17536	<	BossTask *arg1 = (BossTask *) 0 ;
17537	<	std::string const &arg2_defvalue = "all" ;
17538	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
17539	<	std::string const &arg3_defvalue = "" ;
17540	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
17541	<	bool arg4 = (bool) false ;
17542	<	bool arg5 = (bool) false ;
17543	<	int result;
17544	<	std::string temp2 ;
17545	<	std::string temp3 ;
17546	<	PyObject * obj0 = 0 ;
17547	<	PyObject * obj1 = 0 ;
17548	<	PyObject * obj2 = 0 ;
17549	<	PyObject * obj3 = 0 ;
17550	<	PyObject * obj4 = 0 ;
17551	<
17552	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17553	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
17554	<	if (obj1) {
17534	>	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17535	>	PyObject *resultobj = 0;
17536	>	BossTask *arg1 = (BossTask *) 0 ;
17537	>	int result;
17538	>	void *argp1 = 0 ;
17539	>	int res1 = 0 ;
17540	>	PyObject * obj0 = 0 ;
17541	>
17542	>	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_getAllOutput",&obj0)) SWIG_fail;
17543	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17544	>	if (!SWIG_IsOK(res1)) {
17545	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getAllOutput" "', argument " "1"" of type '" "BossTask *""'");
17546	>	}
17547	>	arg1 = reinterpret_cast< BossTask * >(argp1);
17548	>	{
17549	>	try {
17550	>	result = (int)(arg1)->getAllOutput();
17551	>	} catch (const std::exception& e) {
17552	>	SWIG_exception(SWIG_RuntimeError, e.what());
17553	>	}
17554	>	}
17555	>	resultobj = SWIG_From_int(static_cast< int >(result));
17556	>	return resultobj;
17557	>	fail:
17558	>	return NULL;
17559	>	}
17560	>
17561	>
17562	>	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput(PyObject *self, PyObject *args) {
17563	>	int argc;
17564	>	PyObject *argv[5];
17565	>	int ii;
17566	>
17567	>	if (!PyTuple_Check(args)) SWIG_fail;
17568	>	argc = PyObject_Length(args);
17569	>	for (ii = 0; (ii < argc) && (ii < 4); ii++) {
17570	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
17571	>	}
17572	>	if (argc == 1) {
17573	>	int _v;
17574	>	void *vptr = 0;
17575	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17576	>	_v = SWIG_CheckState(res);
17577	>	if (_v) {
17578	>	return _wrap_BossTask_getAllOutput__SWIG_3(self, args);
17579	>	}
17580	>	}
17581	>	if (argc == 2) {
17582	>	int _v;
17583	>	void *vptr = 0;
17584	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17585	>	_v = SWIG_CheckState(res);
17586	>	if (_v) {
17587	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17588	>	_v = SWIG_CheckState(res);
17589	>	if (_v) {
17590	>	return _wrap_BossTask_getAllOutput__SWIG_2(self, args);
17591	>	}
17592	>	}
17593	>	}
17594	>	if (argc == 3) {
17595	>	int _v;
17596	>	void *vptr = 0;
17597	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
17598	>	_v = SWIG_CheckState(res);
17599	>	if (_v) {
17600	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
17601	>	_v = SWIG_CheckState(res);
17602	>	if (_v) {
17603		{
17604	<	if (PyString_Check(obj1)) {
17605	<	temp2 = std::string(PyString_AsString(obj1));
17606	<	arg2 = &temp2;
17607	<	}else {
17608	<	SWIG_exception(SWIG_TypeError, "string expected");
4050	<	}
17604	>	int res = SWIG_AsVal_bool(argv[2], NULL);
17605	>	_v = SWIG_CheckState(res);
17606	>	}
17607	>	if (_v) {
17608	>	return _wrap_BossTask_getAllOutput__SWIG_1(self, args);
17609		}
17610	+	}
17611		}
17612	<	if (obj2) {
17612	>	}
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) {
17622		{
17623	<	if (PyString_Check(obj2)) {
17624	<	temp3 = std::string(PyString_AsString(obj2));
4057	<	arg3 = &temp3;
4058	<	}else {
4059	<	SWIG_exception(SWIG_TypeError, "string expected");
4060	<	}
17623	>	int res = SWIG_AsVal_bool(argv[2], NULL);
17624	>	_v = SWIG_CheckState(res);
17625		}
17626	+	if (_v) {
17627	+	{
17628	+	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	+	}
17634	+	}
17635	+	}
17636		}
17637	<	if (obj3) {
17638	<	arg4 = PyInt_AsLong(obj3) ? true : false;
17639	<	if (PyErr_Occurred()) SWIG_fail;
17637	>	}
17638	>
17639	>	fail:
17640	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_getAllOutput'");
17641	>	return NULL;
17642	>	}
17643	>
17644	>
17645	>	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17646	>	PyObject *resultobj = 0;
17647	>	BossTask *arg1 = (BossTask *) 0 ;
17648	>	int arg2 ;
17649	>	std::string *arg3 = 0 ;
17650	>	std::string *arg4 = 0 ;
17651	>	std::string arg5 ;
17652	>	std::string arg6 ;
17653	>	std::string arg7 ;
17654	>	std::string arg8 ;
17655	>	bool arg9 ;
17656	>	int result;
17657	>	void *argp1 = 0 ;
17658	>	int res1 = 0 ;
17659	>	int val2 ;
17660	>	int ecode2 = 0 ;
17661	>	int res3 = SWIG_OLDOBJ ;
17662	>	int res4 = SWIG_OLDOBJ ;
17663	>	bool val9 ;
17664	>	int ecode9 = 0 ;
17665	>	PyObject * obj0 = 0 ;
17666	>	PyObject * obj1 = 0 ;
17667	>	PyObject * obj2 = 0 ;
17668	>	PyObject * obj3 = 0 ;
17669	>	PyObject * obj4 = 0 ;
17670	>	PyObject * obj5 = 0 ;
17671	>	PyObject * obj6 = 0 ;
17672	>	PyObject * obj7 = 0 ;
17673	>	PyObject * obj8 = 0 ;
17674	>
17675	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
17676	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17677	>	if (!SWIG_IsOK(res1)) {
17678	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
17679	>	}
17680	>	arg1 = reinterpret_cast< BossTask * >(argp1);
17681	>	ecode2 = SWIG_AsVal_int(obj1, &val2);
17682	>	if (!SWIG_IsOK(ecode2)) {
17683	>	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
17684	>	}
17685	>	arg2 = static_cast< int >(val2);
17686	>	{
17687	>	std::string *ptr = (std::string *)0;
17688	>	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17689	>	if (!SWIG_IsOK(res3)) {
17690	>	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17691		}
17692	<	if (obj4) {
17693	<	arg5 = PyInt_AsLong(obj4) ? true : false;
4069	<	if (PyErr_Occurred()) SWIG_fail;
17692	>	if (!ptr) {
17693	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17694		}
17695	<	{
17696	<	try {
17697	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
17698	<
17699	<	}catch (const std::exception& e) {
17700	<	SWIG_exception(SWIG_RuntimeError, e.what());
17701	<	}
17695	>	arg3 = ptr;
17696	>	}
17697	>	{
17698	>	std::string *ptr = (std::string *)0;
17699	>	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
17700	>	if (!SWIG_IsOK(res4)) {
17701	>	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17702		}
17703	<	resultobj = PyInt_FromLong((long)result);
17704	<	return resultobj;
17705	<	fail:
17706	<	return NULL;
17703	>	if (!ptr) {
17704	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17705	>	}
17706	>	arg4 = ptr;
17707	>	}
17708	>	{
17709	>	std::string *ptr = (std::string *)0;
17710	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
17711	>	if (!SWIG_IsOK(res) || !ptr) {
17712	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
17713	>	}
17714	>	arg5 = *ptr;
17715	>	if (SWIG_IsNewObj(res)) delete ptr;
17716	>	}
17717	>	{
17718	>	std::string *ptr = (std::string *)0;
17719	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
17720	>	if (!SWIG_IsOK(res) || !ptr) {
17721	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "6"" of type '" "std::string""'");
17722	>	}
17723	>	arg6 = *ptr;
17724	>	if (SWIG_IsNewObj(res)) delete ptr;
17725	>	}
17726	>	{
17727	>	std::string *ptr = (std::string *)0;
17728	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
17729	>	if (!SWIG_IsOK(res) || !ptr) {
17730	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "7"" of type '" "std::string""'");
17731	>	}
17732	>	arg7 = *ptr;
17733	>	if (SWIG_IsNewObj(res)) delete ptr;
17734	>	}
17735	>	{
17736	>	std::string *ptr = (std::string *)0;
17737	>	int res = SWIG_AsPtr_std_string(obj7, &ptr);
17738	>	if (!SWIG_IsOK(res) || !ptr) {
17739	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "8"" of type '" "std::string""'");
17740	>	}
17741	>	arg8 = *ptr;
17742	>	if (SWIG_IsNewObj(res)) delete ptr;
17743	>	}
17744	>	ecode9 = SWIG_AsVal_bool(obj8, &val9);
17745	>	if (!SWIG_IsOK(ecode9)) {
17746	>	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BossTask_query" "', argument " "9"" of type '" "bool""'");
17747	>	}
17748	>	arg9 = static_cast< bool >(val9);
17749	>	{
17750	>	try {
17751	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
17752	>	} catch (const std::exception& e) {
17753	>	SWIG_exception(SWIG_RuntimeError, e.what());
17754	>	}
17755	>	}
17756	>	resultobj = SWIG_From_int(static_cast< int >(result));
17757	>	if (SWIG_IsNewObj(res3)) delete arg3;
17758	>	if (SWIG_IsNewObj(res4)) delete arg4;
17759	>	return resultobj;
17760	>	fail:
17761	>	if (SWIG_IsNewObj(res3)) delete arg3;
17762	>	if (SWIG_IsNewObj(res4)) delete arg4;
17763	>	return NULL;
17764		}
17765
17766
17767	<	static PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *self, PyObject *args) {
17768	<	PyObject *resultobj;
17769	<	BossTask *arg1 = (BossTask *) 0 ;
17770	<	std::string const &arg2_defvalue = "" ;
17771	<	std::string *arg2 = (std::string *) &arg2_defvalue ;
17772	<	bool arg3 = (bool) false ;
17773	<	bool arg4 = (bool) false ;
17774	<	int result;
17775	<	std::string temp2 ;
17776	<	PyObject * obj0 = 0 ;
17777	<	PyObject * obj1 = 0 ;
17778	<	PyObject * obj2 = 0 ;
17779	<	PyObject * obj3 = 0 ;
17780	<
17781	<	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
17782	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
17783	<	if (obj1) {
17784	<	{
17785	<	if (PyString_Check(obj1)) {
17786	<	temp2 = std::string(PyString_AsString(obj1));
17787	<	arg2 = &temp2;
17788	<	}else {
17789	<	SWIG_exception(SWIG_TypeError, "string expected");
17790	<	}
17791	<	}
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 (obj2) {
17811	<	arg3 = PyInt_AsLong(obj2) ? true : false;
4114	<	if (PyErr_Occurred()) SWIG_fail;
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	<	if (obj3) {
17814	<	arg4 = PyInt_AsLong(obj3) ? true : false;
17815	<	if (PyErr_Occurred()) SWIG_fail;
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	<	{
17822	<	try {
4122	<	result = (int)(arg1)->getOutput((std::string const &)*arg2,arg3,arg4);
4123	<
4124	<	}catch (const std::exception& e) {
4125	<	SWIG_exception(SWIG_RuntimeError, e.what());
4126	<	}
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	<	resultobj = PyInt_FromLong((long)result);
17825	<	return resultobj;
17826	<	fail:
17827	<	return NULL;
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	<	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
17881	<	int argc;
17882	<	PyObject *argv[6];
17883	<	int ii;
17884	<
17885	<	argc = PyObject_Length(args);
17886	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
17887	<	argv[ii] = PyTuple_GetItem(args,ii);
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 ((argc >= 1) && (argc <= 5)) {
17922	<	int _v;
17923	<	{
17924	<	void *ptr;
17925	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
17926	<	_v = 0;
17927	<	PyErr_Clear();
17928	<	}else {
17929	<	_v = 1;
17930	<	}
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());
18331	>	}
18332	>	}
18333	>	resultobj = SWIG_From_int(static_cast< int >(result));
18334	>	return resultobj;
18335	>	fail:
18336	>	return NULL;
18337	>	}
18338	>
18339	>
18340	>	SWIGINTERN PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
18341	>	int argc;
18342	>	PyObject *argv[10];
18343	>	int ii;
18344	>
18345	>	if (!PyTuple_Check(args)) SWIG_fail;
18346	>	argc = PyObject_Length(args);
18347	>	for (ii = 0; (ii < argc) && (ii < 9); ii++) {
18348	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
18349	>	}
18350	>	if (argc == 1) {
18351	>	int _v;
18352	>	void *vptr = 0;
18353	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18354	>	_v = SWIG_CheckState(res);
18355	>	if (_v) {
18356	>	return _wrap_BossTask_query__SWIG_8(self, args);
18357	>	}
18358	>	}
18359	>	if (argc == 2) {
18360	>	int _v;
18361	>	void *vptr = 0;
18362	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18363	>	_v = SWIG_CheckState(res);
18364	>	if (_v) {
18365	>	{
18366	>	int res = SWIG_AsVal_int(argv[1], NULL);
18367	>	_v = SWIG_CheckState(res);
18368	>	}
18369	>	if (_v) {
18370	>	return _wrap_BossTask_query__SWIG_7(self, args);
18371	>	}
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	<	if (argc <= 1) {
18408	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
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);
18437		}
18438	<	{
18439	<	_v = PyString_Check(argv[1]) ? 1 : 0;
18438	>	}
18439	>	}
18440	>	}
18441	>	}
18442	>	}
18443	>	if (argc == 6) {
18444	>	int _v;
18445	>	void *vptr = 0;
18446	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18447	>	_v = SWIG_CheckState(res);
18448	>	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	>	}
18468		}
18469	+	}
18470	+	}
18471	+	}
18472	+	}
18473	+	}
18474	+	if (argc == 7) {
18475	+	int _v;
18476	+	void *vptr = 0;
18477	+	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18478	+	_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	<	if (argc <= 2) {
18495	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
18496	<	}
18497	<	{
18498	<	_v = PyString_Check(argv[2]) ? 1 : 0;
4168	<	}
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	<	if (argc <= 3) {
4171	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4172	<	}
4173	<	{
4174	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
4175	<	}
4176	<	if (_v) {
4177	<	if (argc <= 4) {
4178	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4179	<	}
4180	<	{
4181	<	_v = (PyInt_Check(argv[4]) || PyLong_Check(argv[4])) ? 1 : 0;
4182	<	}
4183	<	if (_v) {
4184	<	return _wrap_BossTask_getOutput__SWIG_0(self,args);
4185	<	}
4186	<	}
18500	>	return _wrap_BossTask_query__SWIG_2(self, args);
18501		}
18502	+	}
18503		}
18504	+	}
18505		}
18506	+	}
18507		}
18508	<	if ((argc >= 1) && (argc <= 4)) {
18509	<	int _v;
18510	<	{
18511	<	void *ptr;
18512	<	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
18513	<	_v = 0;
18514	<	PyErr_Clear();
18515	<	}else {
18516	<	_v = 1;
18508	>	}
18509	>	if (argc == 8) {
18510	>	int _v;
18511	>	void *vptr = 0;
18512	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18513	>	_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	+	}
18544		}
18545	+	}
18546	+	}
18547	+	}
18548	+	if (argc == 9) {
18549	+	int _v;
18550	+	void *vptr = 0;
18551	+	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18552	+	_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	<	if (argc <= 1) {
18563	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
18564	<	}
18565	<	{
18566	<	_v = PyString_Check(argv[1]) ? 1 : 0;
4208	<	}
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	<	if (argc <= 2) {
18569	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
18570	<	}
18571	<	{
18572	<	_v = (PyInt_Check(argv[2]) || PyLong_Check(argv[2])) ? 1 : 0;
4215	<	}
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	<	if (argc <= 3) {
18575	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
18576	<	}
18574	>	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
18575	>	_v = SWIG_CheckState(res);
18576	>	if (_v) {
18577		{
18578	<	_v = (PyInt_Check(argv[3]) || PyLong_Check(argv[3])) ? 1 : 0;
18578	>	int res = SWIG_AsVal_bool(argv[8], NULL);
18579	>	_v = SWIG_CheckState(res);
18580		}
18581		if (_v) {
18582	<	return _wrap_BossTask_getOutput__SWIG_1(self,args);
18582	>	return _wrap_BossTask_query__SWIG_0(self, args);
18583		}
18584	+	}
18585		}
18586	+	}
18587		}
18588	+	}
18589		}
18590	+	}
18591		}
18592	<
18593	<	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_getOutput'");
18594	<	return NULL;
18592	>	}
18593	>
18594	>	fail:
18595	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_query'");
18596	>	return NULL;
18597		}
18598
18599
18600	<	static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
18601	<	PyObject *resultobj;
18602	<	BossTask *arg1 = (BossTask *) 0 ;
18603	<	int arg2 = (int) SCHEDULED ;
18604	<	std::string const &arg3_defvalue = "all" ;
18605	<	std::string *arg3 = (std::string *) &arg3_defvalue ;
18606	<	std::string const &arg4_defvalue = "" ;
18607	<	std::string *arg4 = (std::string *) &arg4_defvalue ;
18608	<	std::string arg5 = (std::string) "" ;
18609	<	std::string arg6 = (std::string) "" ;
18610	<	std::string arg7 = (std::string) "" ;
18611	<	std::string arg8 = (std::string) "" ;
18612	<	bool arg9 = (bool) false ;
18613	<	int result;
18614	<	std::string temp3 ;
18615	<	std::string temp4 ;
18616	<	PyObject * obj0 = 0 ;
18617	<	PyObject * obj2 = 0 ;
18618	<	PyObject * obj3 = 0 ;
18619	<	PyObject * obj4 = 0 ;
18620	<	PyObject * obj5 = 0 ;
18621	<	PyObject * obj6 = 0 ;
18622	<	PyObject * obj7 = 0 ;
18623	<	PyObject * obj8 = 0 ;
18624	<
18625	<	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
18626	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
18627	<	if (obj2) {
18628	<	{
18629	<	if (PyString_Check(obj2)) {
18630	<	temp3 = std::string(PyString_AsString(obj2));
18631	<	arg3 = &temp3;
18632	<	}else {
18633	<	SWIG_exception(SWIG_TypeError, "string expected");
18634	<	}
18635	<	}
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	<	if (obj3) {
18658	<	{
18659	<	if (PyString_Check(obj3)) {
18660	<	temp4 = std::string(PyString_AsString(obj3));
18661	<	arg4 = &temp4;
18662	<	}else {
18663	<	SWIG_exception(SWIG_TypeError, "string expected");
18664	<	}
4281	<	}
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	<	if (obj4) {
18667	<	{
18668	<	if (PyString_Check(obj4))
18669	<	arg5 = std::string(PyString_AsString(obj4));
18670	<	else
18671	<	SWIG_exception(SWIG_TypeError, "string expected");
18672	<	}
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());
18818	>	}
18819	>	}
18820	>	resultobj = SWIG_Py_Void();
18821	>	return resultobj;
18822	>	fail:
18823	>	return NULL;
18824	>	}
18825	>
18826	>
18827	>	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18828	>	PyObject *resultobj = 0;
18829	>	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());
18845		}
18846	<	if (obj5) {
18846	>	}
18847	>	resultobj = SWIG_Py_Void();
18848	>	return resultobj;
18849	>	fail:
18850	>	return NULL;
18851	>	}
18852	>
18853	>
18854	>	SWIGINTERN PyObject *_wrap_BossTask_query_out(PyObject *self, PyObject *args) {
18855	>	int argc;
18856	>	PyObject *argv[6];
18857	>	int ii;
18858	>
18859	>	if (!PyTuple_Check(args)) SWIG_fail;
18860	>	argc = PyObject_Length(args);
18861	>	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
18862	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
18863	>	}
18864	>	if (argc == 1) {
18865	>	int _v;
18866	>	void *vptr = 0;
18867	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18868	>	_v = SWIG_CheckState(res);
18869	>	if (_v) {
18870	>	return _wrap_BossTask_query_out__SWIG_4(self, args);
18871	>	}
18872	>	}
18873	>	if (argc == 2) {
18874	>	int _v;
18875	>	void *vptr = 0;
18876	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18877	>	_v = SWIG_CheckState(res);
18878	>	if (_v) {
18879	>	void *vptr = 0;
18880	>	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, 0);
18881	>	_v = SWIG_CheckState(res);
18882	>	if (_v) {
18883	>	return _wrap_BossTask_query_out__SWIG_3(self, args);
18884	>	}
18885	>	}
18886	>	}
18887	>	if (argc == 3) {
18888	>	int _v;
18889	>	void *vptr = 0;
18890	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
18891	>	_v = SWIG_CheckState(res);
18892	>	if (_v) {
18893	>	void *vptr = 0;
18894	>	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, 0);
18895	>	_v = SWIG_CheckState(res);
18896	>	if (_v) {
18897		{
18898	<	if (PyString_Check(obj5))
18899	<	arg6 = std::string(PyString_AsString(obj5));
18900	<	else
18901	<	SWIG_exception(SWIG_TypeError, "string expected");
18898	>	int res = SWIG_AsVal_int(argv[2], NULL);
18899	>	_v = SWIG_CheckState(res);
18900	>	}
18901	>	if (_v) {
18902	>	return _wrap_BossTask_query_out__SWIG_2(self, args);
18903		}
18904	+	}
18905		}
18906	<	if (obj6) {
18906	>	}
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) {
18917		{
18918	<	if (PyString_Check(obj6))
18919	<	arg7 = std::string(PyString_AsString(obj6));
18920	<	else
18921	<	SWIG_exception(SWIG_TypeError, "string expected");
18918	>	int res = SWIG_AsVal_int(argv[2], NULL);
18919	>	_v = SWIG_CheckState(res);
18920	>	}
18921	>	if (_v) {
18922	>	{
18923	>	int res = SWIG_AsVal_int(argv[3], NULL);
18924	>	_v = SWIG_CheckState(res);
18925	>	}
18926	>	if (_v) {
18927	>	return _wrap_BossTask_query_out__SWIG_1(self, args);
18928	>	}
18929		}
18930	+	}
18931		}
18932	<	if (obj7) {
18932	>	}
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) {
18943		{
18944	<	if (PyString_Check(obj7))
18945	<	arg8 = std::string(PyString_AsString(obj7));
4311	<	else
4312	<	SWIG_exception(SWIG_TypeError, "string expected");
18944	>	int res = SWIG_AsVal_int(argv[2], NULL);
18945	>	_v = SWIG_CheckState(res);
18946		}
18947	+	if (_v) {
18948	+	{
18949	+	int res = SWIG_AsVal_int(argv[3], NULL);
18950	+	_v = SWIG_CheckState(res);
18951	+	}
18952	+	if (_v) {
18953	+	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	+	}
18959	+	}
18960	+	}
18961		}
18962	<	if (obj8) {
18963	<	arg9 = PyInt_AsLong(obj8) ? true : false;
18964	<	if (PyErr_Occurred()) SWIG_fail;
18962	>	}
18963	>
18964	>	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());
18988		}
18989	<	{
18990	<	try {
18991	<	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
18992	<
18993	<	}catch (const std::exception& e) {
18994	<	SWIG_exception(SWIG_RuntimeError, e.what());
18995	<	}
18989	>	}
18990	>	resultobj = SWIG_Py_Void();
18991	>	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());
19031		}
19032	<	resultobj = PyInt_FromLong((long)result);
19033	<	return resultobj;
19034	<	fail:
19035	<	return NULL;
19032	>	}
19033	>	resultobj = result;
19034	>	return resultobj;
19035	>	fail:
19036	>	return NULL;
19037		}
19038
19039
19040	<	static PyObject *_wrap_BossTask_query_out(PyObject *self, PyObject *args) {
19041	<	PyObject *resultobj;
19042	<	BossTask *arg1 = (BossTask *) 0 ;
19043	<	std::ostream &arg2_defvalue = std::cout ;
19044	<	std::ostream *arg2 = (std::ostream *) &arg2_defvalue ;
19045	<	jobStates const &arg3_defvalue = SCHEDULED ;
19046	<	jobStates *arg3 = (jobStates *) &arg3_defvalue ;
19047	<	printOption const &arg4_defvalue = NORMAL ;
19048	<	printOption *arg4 = (printOption *) &arg4_defvalue ;
19049	<	std::string arg5 = (std::string) "" ;
19050	<	PyObject * obj0 = 0 ;
19051	<	PyObject * obj1 = 0 ;
19052	<	PyObject * obj2 = 0 ;
19053	<	PyObject * obj3 = 0 ;
19054	<	PyObject * obj4 = 0 ;
19055	<
19056	<	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_query_out",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19057	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19058	<	if (obj1) {
19059	<	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19060	<	if (arg2 == NULL) {
19061	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
19062	<	}
19040	>	SWIGINTERN PyObject *_wrap_BossTask_jobDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19041	>	PyObject *resultobj = 0;
19042	>	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());
19071		}
19072	<	if (obj2) {
19073	<	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19074	<	if (arg3 == NULL) {
19075	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
19076	<	}
19072	>	}
19073	>	resultobj = result;
19074	>	return resultobj;
19075	>	fail:
19076	>	return NULL;
19077	>	}
19078	>
19079	>
19080	>	SWIGINTERN PyObject *_wrap_BossTask_jobsDict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19081	>	PyObject *resultobj = 0;
19082	>	BossTask *arg1 = (BossTask *) 0 ;
19083	>	PyObject *result = 0 ;
19084	>	void *argp1 = 0 ;
19085	>	int res1 = 0 ;
19086	>	PyObject * obj0 = 0 ;
19087	>
19088	>	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) SWIG_fail;
19089	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
19090	>	if (!SWIG_IsOK(res1)) {
19091	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_jobsDict" "', argument " "1"" of type '" "BossTask const *""'");
19092	>	}
19093	>	arg1 = reinterpret_cast< BossTask * >(argp1);
19094	>	{
19095	>	try {
19096	>	result = (PyObject *)BossTask_jobsDict((BossTask const *)arg1);
19097	>	} catch (const std::exception& e) {
19098	>	SWIG_exception(SWIG_RuntimeError, e.what());
19099		}
19100	<	if (obj3) {
19101	<	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19102	<	if (arg4 == NULL) {
19103	<	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
19104	<	}
19100	>	}
19101	>	resultobj = result;
19102	>	return resultobj;
19103	>	fail:
19104	>	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());
19139		}
19140	<	if (obj4) {
19141	<	{
19142	<	if (PyString_Check(obj4))
19143	<	arg5 = std::string(PyString_AsString(obj4));
19144	<	else
19145	<	SWIG_exception(SWIG_TypeError, "string expected");
19146	<	}
19140	>	}
19141	>	resultobj = result;
19142	>	return resultobj;
19143	>	fail:
19144	>	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 &""'");
19170		}
19171	<	{
19172	<	try {
4380	<	((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
4381	<
4382	<	}catch (const std::exception& e) {
4383	<	SWIG_exception(SWIG_RuntimeError, e.what());
4384	<	}
19171	>	if (!ptr) {
19172	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_jobPrograms" "', argument " "2"" of type '" "std::string const &""'");
19173		}
19174	<	Py_INCREF(Py_None); resultobj = Py_None;
19175	<	return resultobj;
19176	<	fail:
19177	<	return NULL;
19174	>	arg2 = ptr;
19175	>	}
19176	>	{
19177	>	try {
19178	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
19179	>	} catch (const std::exception& e) {
19180	>	SWIG_exception(SWIG_RuntimeError, e.what());
19181	>	}
19182	>	}
19183	>	resultobj = result;
19184	>	if (SWIG_IsNewObj(res2)) delete arg2;
19185	>	return resultobj;
19186	>	fail:
19187	>	if (SWIG_IsNewObj(res2)) delete arg2;
19188	>	return NULL;
19189		}
19190
19191
19192	<	static PyObject *_wrap_BossTask_clear(PyObject *self, PyObject *args) {
19193	<	PyObject *resultobj;
19194	<	BossTask *arg1 = (BossTask *) 0 ;
19195	<	PyObject * obj0 = 0 ;
19196	<
19197	<	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_clear",&obj0)) goto fail;
19198	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19199	<	{
19200	<	try {
19201	<	(arg1)->clear();
19202	<
19203	<	}catch (const std::exception& e) {
19204	<	SWIG_exception(SWIG_RuntimeError, e.what());
19205	<	}
19192	>	SWIGINTERN PyObject *BossTask_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19193	>	PyObject *obj;
19194	>	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
19195	>	SWIG_TypeNewClientData(SWIGTYPE_p_BossTask, SWIG_NewClientData(obj));
19196	>	return SWIG_Py_Void();
19197	>	}
19198	>
19199	>	SWIGINTERN PyObject *_wrap_prompt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19200	>	PyObject *resultobj = 0;
19201	>	std::string *arg1 = 0 ;
19202	>	bool result;
19203	>	int res1 = SWIG_OLDOBJ ;
19204	>	PyObject * obj0 = 0 ;
19205	>
19206	>	if (!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) SWIG_fail;
19207	>	{
19208	>	std::string *ptr = (std::string *)0;
19209	>	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	<	Py_INCREF(Py_None); resultobj = Py_None;
19214	<	return resultobj;
19215	<	fail:
19216	<	return NULL;
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());
19223	>	}
19224	>	}
19225	>	resultobj = SWIG_From_bool(static_cast< bool >(result));
19226	>	if (SWIG_IsNewObj(res1)) delete arg1;
19227	>	return resultobj;
19228	>	fail:
19229	>	if (SWIG_IsNewObj(res1)) delete arg1;
19230	>	return NULL;
19231		}
19232
19233
19234	<	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
19235	<	PyObject *obj;
19236	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19237	<	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
19238	<	Py_INCREF(obj);
19239	<	return Py_BuildValue((char *)"");
19240	<	}
19241	<	static PyObject *_wrap_prompt(PyObject *self, PyObject *args) {
19242	<	PyObject *resultobj;
19243	<	std::string *arg1 = 0 ;
19244	<	bool result;
19245	<	std::string temp1 ;
19246	<	PyObject * obj0 = 0 ;
19247	<
19248	<	if(!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) goto fail;
19249	<	{
4431	<	if (PyString_Check(obj0)) {
4432	<	temp1 = std::string(PyString_AsString(obj0));
4433	<	arg1 = &temp1;
4434	<	}else {
4435	<	SWIG_exception(SWIG_TypeError, "string expected");
4436	<	}
19234	>	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19235	>	PyObject *resultobj = 0;
19236	>	std::string arg1 ;
19237	>	bool arg2 ;
19238	>	BossAdministratorSession *result = 0 ;
19239	>	bool val2 ;
19240	>	int ecode2 = 0 ;
19241	>	PyObject * obj0 = 0 ;
19242	>	PyObject * obj1 = 0 ;
19243	>
19244	>	if (!PyArg_ParseTuple(args,(char *)"OO:new_BossAdministratorSession",&obj0,&obj1)) SWIG_fail;
19245	>	{
19246	>	std::string *ptr = (std::string *)0;
19247	>	int res = SWIG_AsPtr_std_string(obj0, &ptr);
19248	>	if (!SWIG_IsOK(res) || !ptr) {
19249	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BossAdministratorSession" "', argument " "1"" of type '" "std::string""'");
19250		}
19251	<	{
19252	<	try {
19253	<	result = (bool)prompt((std::string const &)*arg1);
19254	<
19255	<	}catch (const std::exception& e) {
19256	<	SWIG_exception(SWIG_RuntimeError, e.what());
19257	<	}
19251	>	arg1 = *ptr;
19252	>	if (SWIG_IsNewObj(res)) delete ptr;
19253	>	}
19254	>	ecode2 = SWIG_AsVal_bool(obj1, &val2);
19255	>	if (!SWIG_IsOK(ecode2)) {
19256	>	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BossAdministratorSession" "', argument " "2"" of type '" "bool""'");
19257	>	}
19258	>	arg2 = static_cast< bool >(val2);
19259	>	{
19260	>	try {
19261	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
19262	>	} catch (const std::exception& e) {
19263	>	SWIG_exception(SWIG_RuntimeError, e.what());
19264		}
19265	<	resultobj = PyInt_FromLong((long)result);
19266	<	return resultobj;
19267	<	fail:
19268	<	return NULL;
19265	>	}
19266	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_NEW |  0 );
19267	>	return resultobj;
19268	>	fail:
19269	>	return NULL;
19270		}
19271
19272
19273	<	static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
19274	<	PyObject *resultobj;
19275	<	std::string arg1 = (std::string) "" ;
19276	<	bool arg2 = (bool) false ;
19277	<	BossAdministratorSession *result;
19278	<	PyObject * obj0 = 0 ;
19279	<	PyObject * obj1 = 0 ;
19280	<
19281	<	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
19282	<	if (obj0) {
19283	<	{
19284	<	if (PyString_Check(obj0))
4465	<	arg1 = std::string(PyString_AsString(obj0));
4466	<	else
4467	<	SWIG_exception(SWIG_TypeError, "string expected");
4468	<	}
19273	>	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19274	>	PyObject *resultobj = 0;
19275	>	std::string arg1 ;
19276	>	BossAdministratorSession *result = 0 ;
19277	>	PyObject * obj0 = 0 ;
19278	>
19279	>	if (!PyArg_ParseTuple(args,(char *)"O:new_BossAdministratorSession",&obj0)) SWIG_fail;
19280	>	{
19281	>	std::string *ptr = (std::string *)0;
19282	>	int res = SWIG_AsPtr_std_string(obj0, &ptr);
19283	>	if (!SWIG_IsOK(res) || !ptr) {
19284	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BossAdministratorSession" "', argument " "1"" of type '" "std::string""'");
19285		}
19286	<	if (obj1) {
19287	<	arg2 = PyInt_AsLong(obj1) ? true : false;
19288	<	if (PyErr_Occurred()) SWIG_fail;
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());
19294		}
19295	<	{
19296	<	try {
19297	<	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
19298	<
19299	<	}catch (const std::exception& e) {
19300	<	SWIG_exception(SWIG_RuntimeError, e.what());
19301	<	}
19295	>	}
19296	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_NEW |  0 );
19297	>	return resultobj;
19298	>	fail:
19299	>	return NULL;
19300	>	}
19301	>
19302	>
19303	>	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19304	>	PyObject *resultobj = 0;
19305	>	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());
19313		}
19314	<	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
19315	<	return resultobj;
19316	<	fail:
19317	<	return NULL;
19314	>	}
19315	>	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_NEW |  0 );
19316	>	return resultobj;
19317	>	fail:
19318	>	return NULL;
19319		}
19320
19321
19322	<	static PyObject *_wrap_delete_BossAdministratorSession(PyObject *self, PyObject *args) {
19323	<	PyObject *resultobj;
19324	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19325	<	PyObject * obj0 = 0 ;
19326	<
19327	<	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossAdministratorSession",&obj0)) goto fail;
19328	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19329	<	{
19330	<	try {
19331	<	delete arg1;
19332	<
19333	<	}catch (const std::exception& e) {
19334	<	SWIG_exception(SWIG_RuntimeError, e.what());
19335	<	}
19322	>	SWIGINTERN PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
19323	>	int argc;
19324	>	PyObject *argv[3];
19325	>	int ii;
19326	>
19327	>	if (!PyTuple_Check(args)) SWIG_fail;
19328	>	argc = PyObject_Length(args);
19329	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
19330	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
19331	>	}
19332	>	if (argc == 0) {
19333	>	return _wrap_new_BossAdministratorSession__SWIG_2(self, args);
19334	>	}
19335	>	if (argc == 1) {
19336	>	int _v;
19337	>	int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
19338	>	_v = SWIG_CheckState(res);
19339	>	if (_v) {
19340	>	return _wrap_new_BossAdministratorSession__SWIG_1(self, args);
19341		}
19342	<	Py_INCREF(Py_None); resultobj = Py_None;
19343	<	return resultobj;
19344	<	fail:
19345	<	return NULL;
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	>	}
19355	>	}
19356	>	}
19357	>
19358	>	fail:
19359	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BossAdministratorSession'");
19360	>	return NULL;
19361		}
19362
19363
19364	<	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
19365	<	PyObject *resultobj;
19366	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19367	<	int result;
19368	<	PyObject * obj0 = 0 ;
19369	<
19370	<	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
19371	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19372	<	{
19373	<	try {
19374	<	result = (int)(arg1)->configureDB();
19375	<
19376	<	}catch (const std::exception& e) {
19377	<	SWIG_exception(SWIG_RuntimeError, e.what());
19378	<	}
19364	>	SWIGINTERN PyObject *_wrap_delete_BossAdministratorSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19365	>	PyObject *resultobj = 0;
19366	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19367	>	void *argp1 = 0 ;
19368	>	int res1 = 0 ;
19369	>	PyObject * obj0 = 0 ;
19370	>
19371	>	if (!PyArg_ParseTuple(args,(char *)"O:delete_BossAdministratorSession",&obj0)) SWIG_fail;
19372	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, SWIG_POINTER_DISOWN |  0 );
19373	>	if (!SWIG_IsOK(res1)) {
19374	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BossAdministratorSession" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19375	>	}
19376	>	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());
19383		}
19384	<	resultobj = PyInt_FromLong((long)result);
19385	<	return resultobj;
19386	<	fail:
19387	<	return NULL;
19384	>	}
19385	>	resultobj = SWIG_Py_Void();
19386	>	return resultobj;
19387	>	fail:
19388	>	return NULL;
19389		}
19390
19391
19392	<	static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
19393	<	PyObject *resultobj;
19394	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19395	<	std::string *arg2 = 0 ;
19396	<	int result;
19397	<	std::string temp2 ;
19398	<	PyObject * obj0 = 0 ;
19399	<	PyObject * obj1 = 0 ;
19400	<
19401	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureRTMonDB",&obj0,&obj1)) goto fail;
19402	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19403	<	{
19404	<	if (PyString_Check(obj1)) {
19405	<	temp2 = std::string(PyString_AsString(obj1));
19406	<	arg2 = &temp2;
19407	<	}else {
19408	<	SWIG_exception(SWIG_TypeError, "string expected");
19409	<	}
19392	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19393	>	PyObject *resultobj = 0;
19394	>	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());
19411		}
19412	<	{
19413	<	try {
19414	<	result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
19415	<
19416	<	}catch (const std::exception& e) {
19417	<	SWIG_exception(SWIG_RuntimeError, e.what());
19418	<	}
19412	>	}
19413	>	resultobj = SWIG_From_int(static_cast< int >(result));
19414	>	return resultobj;
19415	>	fail:
19416	>	return NULL;
19417	>	}
19418	>
19419	>
19420	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19421	>	PyObject *resultobj = 0;
19422	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19423	>	std::string *arg2 = 0 ;
19424	>	int result;
19425	>	void *argp1 = 0 ;
19426	>	int res1 = 0 ;
19427	>	int res2 = SWIG_OLDOBJ ;
19428	>	PyObject * obj0 = 0 ;
19429	>	PyObject * obj1 = 0 ;
19430	>
19431	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureRTMonDB",&obj0,&obj1)) SWIG_fail;
19432	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19433	>	if (!SWIG_IsOK(res1)) {
19434	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_configureRTMonDB" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19435	>	}
19436	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19437	>	{
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	<	resultobj = PyInt_FromLong((long)result);
19444	<	return resultobj;
19445	<	fail:
19446	<	return NULL;
19443	>	if (!ptr) {
19444	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_configureRTMonDB" "', argument " "2"" of type '" "std::string const &""'");
19445	>	}
19446	>	arg2 = ptr;
19447	>	}
19448	>	{
19449	>	try {
19450	>	result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
19451	>	} catch (const std::exception& e) {
19452	>	SWIG_exception(SWIG_RuntimeError, e.what());
19453	>	}
19454	>	}
19455	>	resultobj = SWIG_From_int(static_cast< int >(result));
19456	>	if (SWIG_IsNewObj(res2)) delete arg2;
19457	>	return resultobj;
19458	>	fail:
19459	>	if (SWIG_IsNewObj(res2)) delete arg2;
19460	>	return NULL;
19461		}
19462
19463
19464	<	static PyObject *_wrap_BossAdministratorSession_deleteCHTool(PyObject *self, PyObject *args) {
19465	<	PyObject *resultobj;
19466	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19467	<	std::string *arg2 = 0 ;
19468	<	int result;
19469	<	std::string temp2 ;
19470	<	PyObject * obj0 = 0 ;
19471	<	PyObject * obj1 = 0 ;
19472	<
19473	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteCHTool",&obj0,&obj1)) goto fail;
19474	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19475	<	{
19476	<	if (PyString_Check(obj1)) {
19477	<	temp2 = std::string(PyString_AsString(obj1));
19478	<	arg2 = &temp2;
19479	<	}else {
19480	<	SWIG_exception(SWIG_TypeError, "string expected");
19481	<	}
19464	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_deleteCHTool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19465	>	PyObject *resultobj = 0;
19466	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19467	>	std::string *arg2 = 0 ;
19468	>	int result;
19469	>	void *argp1 = 0 ;
19470	>	int res1 = 0 ;
19471	>	int res2 = SWIG_OLDOBJ ;
19472	>	PyObject * obj0 = 0 ;
19473	>	PyObject * obj1 = 0 ;
19474	>
19475	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteCHTool",&obj0,&obj1)) SWIG_fail;
19476	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19477	>	if (!SWIG_IsOK(res1)) {
19478	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_deleteCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19479	>	}
19480	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19481	>	{
19482	>	std::string *ptr = (std::string *)0;
19483	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
19484	>	if (!SWIG_IsOK(res2)) {
19485	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_deleteCHTool" "', argument " "2"" of type '" "std::string const &""'");
19486		}
19487	<	{
19488	<	try {
4589	<	result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
4590	<
4591	<	}catch (const std::exception& e) {
4592	<	SWIG_exception(SWIG_RuntimeError, e.what());
4593	<	}
19487	>	if (!ptr) {
19488	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteCHTool" "', argument " "2"" of type '" "std::string const &""'");
19489		}
19490	<	resultobj = PyInt_FromLong((long)result);
19491	<	return resultobj;
19492	<	fail:
19493	<	return NULL;
19490	>	arg2 = ptr;
19491	>	}
19492	>	{
19493	>	try {
19494	>	result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
19495	>	} catch (const std::exception& e) {
19496	>	SWIG_exception(SWIG_RuntimeError, e.what());
19497	>	}
19498	>	}
19499	>	resultobj = SWIG_From_int(static_cast< int >(result));
19500	>	if (SWIG_IsNewObj(res2)) delete arg2;
19501	>	return resultobj;
19502	>	fail:
19503	>	if (SWIG_IsNewObj(res2)) delete arg2;
19504	>	return NULL;
19505		}
19506
19507
19508	<	static PyObject *_wrap_BossAdministratorSession_deleteProgramType(PyObject *self, PyObject *args) {
19509	<	PyObject *resultobj;
19510	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19511	<	std::string *arg2 = 0 ;
19512	<	int result;
19513	<	std::string temp2 ;
19514	<	PyObject * obj0 = 0 ;
19515	<	PyObject * obj1 = 0 ;
19516	<
19517	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteProgramType",&obj0,&obj1)) goto fail;
19518	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19519	<	{
19520	<	if (PyString_Check(obj1)) {
19521	<	temp2 = std::string(PyString_AsString(obj1));
19522	<	arg2 = &temp2;
19523	<	}else {
19524	<	SWIG_exception(SWIG_TypeError, "string expected");
19525	<	}
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 &""'");
19530		}
19531	<	{
19532	<	try {
4623	<	result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
4624	<
4625	<	}catch (const std::exception& e) {
4626	<	SWIG_exception(SWIG_RuntimeError, e.what());
4627	<	}
19531	>	if (!ptr) {
19532	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteProgramType" "', argument " "2"" of type '" "std::string const &""'");
19533		}
19534	<	resultobj = PyInt_FromLong((long)result);
19535	<	return resultobj;
19536	<	fail:
19537	<	return NULL;
19534	>	arg2 = ptr;
19535	>	}
19536	>	{
19537	>	try {
19538	>	result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
19539	>	} catch (const std::exception& e) {
19540	>	SWIG_exception(SWIG_RuntimeError, e.what());
19541	>	}
19542	>	}
19543	>	resultobj = SWIG_From_int(static_cast< int >(result));
19544	>	if (SWIG_IsNewObj(res2)) delete arg2;
19545	>	return resultobj;
19546	>	fail:
19547	>	if (SWIG_IsNewObj(res2)) delete arg2;
19548	>	return NULL;
19549		}
19550
19551
19552	<	static PyObject *_wrap_BossAdministratorSession_deleteRTMon(PyObject *self, PyObject *args) {
19553	<	PyObject *resultobj;
19554	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19555	<	std::string *arg2 = 0 ;
19556	<	int result;
19557	<	std::string temp2 ;
19558	<	PyObject * obj0 = 0 ;
19559	<	PyObject * obj1 = 0 ;
19560	<
19561	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteRTMon",&obj0,&obj1)) goto fail;
19562	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19563	<	{
19564	<	if (PyString_Check(obj1)) {
19565	<	temp2 = std::string(PyString_AsString(obj1));
19566	<	arg2 = &temp2;
19567	<	}else {
19568	<	SWIG_exception(SWIG_TypeError, "string expected");
19569	<	}
19552	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_deleteRTMon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19553	>	PyObject *resultobj = 0;
19554	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19555	>	std::string *arg2 = 0 ;
19556	>	int result;
19557	>	void *argp1 = 0 ;
19558	>	int res1 = 0 ;
19559	>	int res2 = SWIG_OLDOBJ ;
19560	>	PyObject * obj0 = 0 ;
19561	>	PyObject * obj1 = 0 ;
19562	>
19563	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteRTMon",&obj0,&obj1)) SWIG_fail;
19564	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19565	>	if (!SWIG_IsOK(res1)) {
19566	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_deleteRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19567	>	}
19568	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19569	>	{
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	<	{
19576	<	try {
4657	<	result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
4658	<
4659	<	}catch (const std::exception& e) {
4660	<	SWIG_exception(SWIG_RuntimeError, e.what());
4661	<	}
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	<	resultobj = PyInt_FromLong((long)result);
19579	<	return resultobj;
19580	<	fail:
19581	<	return NULL;
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());
19585	>	}
19586	>	}
19587	>	resultobj = SWIG_From_int(static_cast< int >(result));
19588	>	if (SWIG_IsNewObj(res2)) delete arg2;
19589	>	return resultobj;
19590	>	fail:
19591	>	if (SWIG_IsNewObj(res2)) delete arg2;
19592	>	return NULL;
19593		}
19594
19595
19596	<	static PyObject *_wrap_BossAdministratorSession_deleteScheduler(PyObject *self, PyObject *args) {
19597	<	PyObject *resultobj;
19598	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19599	<	std::string *arg2 = 0 ;
19600	<	int result;
19601	<	std::string temp2 ;
19602	<	PyObject * obj0 = 0 ;
19603	<	PyObject * obj1 = 0 ;
19604	<
19605	<	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteScheduler",&obj0,&obj1)) goto fail;
19606	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19607	<	{
19608	<	if (PyString_Check(obj1)) {
19609	<	temp2 = std::string(PyString_AsString(obj1));
19610	<	arg2 = &temp2;
19611	<	}else {
19612	<	SWIG_exception(SWIG_TypeError, "string expected");
19613	<	}
19596	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_deleteScheduler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19597	>	PyObject *resultobj = 0;
19598	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19599	>	std::string *arg2 = 0 ;
19600	>	int result;
19601	>	void *argp1 = 0 ;
19602	>	int res1 = 0 ;
19603	>	int res2 = SWIG_OLDOBJ ;
19604	>	PyObject * obj0 = 0 ;
19605	>	PyObject * obj1 = 0 ;
19606	>
19607	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteScheduler",&obj0,&obj1)) SWIG_fail;
19608	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19609	>	if (!SWIG_IsOK(res1)) {
19610	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_deleteScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19611	>	}
19612	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19613	>	{
19614	>	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	<	{
19620	<	try {
4691	<	result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
4692	<
4693	<	}catch (const std::exception& e) {
4694	<	SWIG_exception(SWIG_RuntimeError, e.what());
4695	<	}
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	<	resultobj = PyInt_FromLong((long)result);
19623	<	return resultobj;
19624	<	fail:
19625	<	return NULL;
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());
19629	>	}
19630	>	}
19631	>	resultobj = SWIG_From_int(static_cast< int >(result));
19632	>	if (SWIG_IsNewObj(res2)) delete arg2;
19633	>	return resultobj;
19634	>	fail:
19635	>	if (SWIG_IsNewObj(res2)) delete arg2;
19636	>	return NULL;
19637		}
19638
19639
19640	<	static PyObject *_wrap_BossAdministratorSession_registerCHTool(PyObject *self, PyObject *args) {
19641	<	PyObject *resultobj;
19642	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19643	<	std::string *arg2 = 0 ;
19644	<	std::string arg3 = (std::string) "NULL" ;
19645	<	std::string arg4 = (std::string) "NULL" ;
19646	<	bool arg5 = (bool) false ;
19647	<	bool arg6 = (bool) false ;
19648	<	int result;
19649	<	std::string temp2 ;
19650	<	PyObject * obj0 = 0 ;
19651	<	PyObject * obj1 = 0 ;
19652	<	PyObject * obj2 = 0 ;
19653	<	PyObject * obj3 = 0 ;
19654	<	PyObject * obj4 = 0 ;
19655	<	PyObject * obj5 = 0 ;
19656	<
19657	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
19658	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
19659	<	{
19660	<	if (PyString_Check(obj1)) {
19661	<	temp2 = std::string(PyString_AsString(obj1));
19662	<	arg2 = &temp2;
19663	<	}else {
19664	<	SWIG_exception(SWIG_TypeError, "string expected");
19640	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19641	>	PyObject *resultobj = 0;
19642	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19643	>	std::string *arg2 = 0 ;
19644	>	std::string arg3 ;
19645	>	std::string arg4 ;
19646	>	bool arg5 ;
19647	>	bool arg6 ;
19648	>	int result;
19649	>	void *argp1 = 0 ;
19650	>	int res1 = 0 ;
19651	>	int res2 = SWIG_OLDOBJ ;
19652	>	bool val5 ;
19653	>	int ecode5 = 0 ;
19654	>	bool val6 ;
19655	>	int ecode6 = 0 ;
19656	>	PyObject * obj0 = 0 ;
19657	>	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""'");
19694	>	}
19695	>	arg4 = *ptr;
19696	>	if (SWIG_IsNewObj(res)) delete ptr;
19697	>	}
19698	>	ecode5 = SWIG_AsVal_bool(obj4, &val5);
19699	>	if (!SWIG_IsOK(ecode5)) {
19700	>	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "5"" of type '" "bool""'");
19701	>	}
19702	>	arg5 = static_cast< bool >(val5);
19703	>	ecode6 = SWIG_AsVal_bool(obj5, &val6);
19704	>	if (!SWIG_IsOK(ecode6)) {
19705	>	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());
19713	>	}
19714	>	}
19715	>	resultobj = SWIG_From_int(static_cast< int >(result));
19716	>	if (SWIG_IsNewObj(res2)) delete arg2;
19717	>	return resultobj;
19718	>	fail:
19719	>	if (SWIG_IsNewObj(res2)) delete arg2;
19720	>	return NULL;
19721	>	}
19722	>
19723	>
19724	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19725	>	PyObject *resultobj = 0;
19726	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19727	>	std::string *arg2 = 0 ;
19728	>	std::string arg3 ;
19729	>	std::string arg4 ;
19730	>	bool arg5 ;
19731	>	int result;
19732	>	void *argp1 = 0 ;
19733	>	int res1 = 0 ;
19734	>	int res2 = SWIG_OLDOBJ ;
19735	>	bool val5 ;
19736	>	int ecode5 = 0 ;
19737	>	PyObject * obj0 = 0 ;
19738	>	PyObject * obj1 = 0 ;
19739	>	PyObject * obj2 = 0 ;
19740	>	PyObject * obj3 = 0 ;
19741	>	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""'");
19774	>	}
19775	>	arg4 = *ptr;
19776	>	if (SWIG_IsNewObj(res)) delete ptr;
19777	>	}
19778	>	ecode5 = SWIG_AsVal_bool(obj4, &val5);
19779	>	if (!SWIG_IsOK(ecode5)) {
19780	>	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "5"" of type '" "bool""'");
19781	>	}
19782	>	arg5 = static_cast< bool >(val5);
19783	>	{
19784	>	try {
19785	>	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5);
19786	>	} catch (const std::exception& e) {
19787	>	SWIG_exception(SWIG_RuntimeError, e.what());
19788	>	}
19789	>	}
19790	>	resultobj = SWIG_From_int(static_cast< int >(result));
19791	>	if (SWIG_IsNewObj(res2)) delete arg2;
19792	>	return resultobj;
19793	>	fail:
19794	>	if (SWIG_IsNewObj(res2)) delete arg2;
19795	>	return NULL;
19796	>	}
19797	>
19798	>
19799	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19800	>	PyObject *resultobj = 0;
19801	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19802	>	std::string *arg2 = 0 ;
19803	>	std::string arg3 ;
19804	>	std::string arg4 ;
19805	>	int result;
19806	>	void *argp1 = 0 ;
19807	>	int res1 = 0 ;
19808	>	int res2 = SWIG_OLDOBJ ;
19809	>	PyObject * obj0 = 0 ;
19810	>	PyObject * obj1 = 0 ;
19811	>	PyObject * obj2 = 0 ;
19812	>	PyObject * obj3 = 0 ;
19813	>
19814	>	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19815	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19816	>	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""'");
19845	>	}
19846	>	arg4 = *ptr;
19847	>	if (SWIG_IsNewObj(res)) delete ptr;
19848	>	}
19849	>	{
19850	>	try {
19851	>	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4);
19852	>	} catch (const std::exception& e) {
19853	>	SWIG_exception(SWIG_RuntimeError, e.what());
19854	>	}
19855	>	}
19856	>	resultobj = SWIG_From_int(static_cast< int >(result));
19857	>	if (SWIG_IsNewObj(res2)) delete arg2;
19858	>	return resultobj;
19859	>	fail:
19860	>	if (SWIG_IsNewObj(res2)) delete arg2;
19861	>	return NULL;
19862	>	}
19863	>
19864	>
19865	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19866	>	PyObject *resultobj = 0;
19867	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19868	>	std::string *arg2 = 0 ;
19869	>	std::string arg3 ;
19870	>	int result;
19871	>	void *argp1 = 0 ;
19872	>	int res1 = 0 ;
19873	>	int res2 = SWIG_OLDOBJ ;
19874	>	PyObject * obj0 = 0 ;
19875	>	PyObject * obj1 = 0 ;
19876	>	PyObject * obj2 = 0 ;
19877	>
19878	>	if (!PyArg_ParseTuple(args,(char *)"OOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2)) SWIG_fail;
19879	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19880	>	if (!SWIG_IsOK(res1)) {
19881	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19882	>	}
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""'");
19900	>	}
19901	>	arg3 = *ptr;
19902	>	if (SWIG_IsNewObj(res)) delete ptr;
19903	>	}
19904	>	{
19905	>	try {
19906	>	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3);
19907	>	} catch (const std::exception& e) {
19908	>	SWIG_exception(SWIG_RuntimeError, e.what());
19909	>	}
19910	>	}
19911	>	resultobj = SWIG_From_int(static_cast< int >(result));
19912	>	if (SWIG_IsNewObj(res2)) delete arg2;
19913	>	return resultobj;
19914	>	fail:
19915	>	if (SWIG_IsNewObj(res2)) delete arg2;
19916	>	return NULL;
19917	>	}
19918	>
19919	>
19920	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19921	>	PyObject *resultobj = 0;
19922	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
19923	>	std::string *arg2 = 0 ;
19924	>	int result;
19925	>	void *argp1 = 0 ;
19926	>	int res1 = 0 ;
19927	>	int res2 = SWIG_OLDOBJ ;
19928	>	PyObject * obj0 = 0 ;
19929	>	PyObject * obj1 = 0 ;
19930	>
19931	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerCHTool",&obj0,&obj1)) SWIG_fail;
19932	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
19933	>	if (!SWIG_IsOK(res1)) {
19934	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerCHTool" "', argument " "1"" of type '" "BossAdministratorSession *""'");
19935	>	}
19936	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
19937	>	{
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 &""'");
19945	>	}
19946	>	arg2 = ptr;
19947	>	}
19948	>	{
19949	>	try {
19950	>	result = (int)(arg1)->registerCHTool((std::string const &)*arg2);
19951	>	} catch (const std::exception& e) {
19952	>	SWIG_exception(SWIG_RuntimeError, e.what());
19953	>	}
19954	>	}
19955	>	resultobj = SWIG_From_int(static_cast< int >(result));
19956	>	if (SWIG_IsNewObj(res2)) delete arg2;
19957	>	return resultobj;
19958	>	fail:
19959	>	if (SWIG_IsNewObj(res2)) delete arg2;
19960	>	return NULL;
19961	>	}
19962	>
19963	>
19964	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerCHTool(PyObject *self, PyObject *args) {
19965	>	int argc;
19966	>	PyObject *argv[7];
19967	>	int ii;
19968	>
19969	>	if (!PyTuple_Check(args)) SWIG_fail;
19970	>	argc = PyObject_Length(args);
19971	>	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
19972	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
19973	>	}
19974	>	if (argc == 2) {
19975	>	int _v;
19976	>	void *vptr = 0;
19977	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
19978	>	_v = SWIG_CheckState(res);
19979	>	if (_v) {
19980	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
19981	>	_v = SWIG_CheckState(res);
19982	>	if (_v) {
19983	>	return _wrap_BossAdministratorSession_registerCHTool__SWIG_4(self, args);
19984	>	}
19985	>	}
19986	>	}
19987	>	if (argc == 3) {
19988	>	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	<	if (obj2) {
20004	<	{
20005	<	if (PyString_Check(obj2))
20006	<	arg3 = std::string(PyString_AsString(obj2));
20007	<	else
20008	<	SWIG_exception(SWIG_TypeError, "string expected");
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	>	}
20021		}
20022	+	}
20023		}
20024	<	if (obj3) {
20025	<	{
20026	<	if (PyString_Check(obj3))
20027	<	arg4 = std::string(PyString_AsString(obj3));
20028	<	else
20029	<	SWIG_exception(SWIG_TypeError, "string expected");
20024	>	}
20025	>	if (argc == 5) {
20026	>	int _v;
20027	>	void *vptr = 0;
20028	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
20029	>	_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	>	}
20048		}
20049	+	}
20050	+	}
20051	+	}
20052	+	if (argc == 6) {
20053	+	int _v;
20054	+	void *vptr = 0;
20055	+	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
20056	+	_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	+	}
20081	+	}
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 (obj4) {
20130	<	arg5 = PyInt_AsLong(obj4) ? true : false;
4749	<	if (PyErr_Occurred()) SWIG_fail;
20129	>	if (!ptr) {
20130	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20131		}
20132	<	if (obj5) {
20133	<	arg6 = PyInt_AsLong(obj5) ? true : false;
20134	<	if (PyErr_Occurred()) SWIG_fail;
20132	>	arg2 = ptr;
20133	>	}
20134	>	{
20135	>	std::string *ptr = (std::string *)0;
20136	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20137	>	if (!SWIG_IsOK(res) || !ptr) {
20138	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "3"" of type '" "std::string""'");
20139		}
20140	<	{
20141	<	try {
20142	<	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
20143	<
20144	<	}catch (const std::exception& e) {
20145	<	SWIG_exception(SWIG_RuntimeError, e.what());
20146	<	}
20140	>	arg3 = *ptr;
20141	>	if (SWIG_IsNewObj(res)) delete ptr;
20142	>	}
20143	>	{
20144	>	std::string *ptr = (std::string *)0;
20145	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20146	>	if (!SWIG_IsOK(res) || !ptr) {
20147	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "4"" of type '" "std::string""'");
20148		}
20149	<	resultobj = PyInt_FromLong((long)result);
20150	<	return resultobj;
20151	<	fail:
20152	<	return NULL;
20149	>	arg4 = *ptr;
20150	>	if (SWIG_IsNewObj(res)) delete ptr;
20151	>	}
20152	>	{
20153	>	std::string *ptr = (std::string *)0;
20154	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20155	>	if (!SWIG_IsOK(res) || !ptr) {
20156	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "5"" of type '" "std::string""'");
20157	>	}
20158	>	arg5 = *ptr;
20159	>	if (SWIG_IsNewObj(res)) delete ptr;
20160	>	}
20161	>	{
20162	>	std::string *ptr = (std::string *)0;
20163	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
20164	>	if (!SWIG_IsOK(res) || !ptr) {
20165	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "6"" of type '" "std::string""'");
20166	>	}
20167	>	arg6 = *ptr;
20168	>	if (SWIG_IsNewObj(res)) delete ptr;
20169	>	}
20170	>	{
20171	>	std::string *ptr = (std::string *)0;
20172	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
20173	>	if (!SWIG_IsOK(res) || !ptr) {
20174	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "7"" of type '" "std::string""'");
20175	>	}
20176	>	arg7 = *ptr;
20177	>	if (SWIG_IsNewObj(res)) delete ptr;
20178	>	}
20179	>	ecode8 = SWIG_AsVal_bool(obj7, &val8);
20180	>	if (!SWIG_IsOK(ecode8)) {
20181	>	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BossAdministratorSession_registerProgram" "', argument " "8"" of type '" "bool""'");
20182	>	}
20183	>	arg8 = static_cast< bool >(val8);
20184	>	{
20185	>	try {
20186	>	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
20187	>	} catch (const std::exception& e) {
20188	>	SWIG_exception(SWIG_RuntimeError, e.what());
20189	>	}
20190	>	}
20191	>	resultobj = SWIG_From_int(static_cast< int >(result));
20192	>	if (SWIG_IsNewObj(res2)) delete arg2;
20193	>	return resultobj;
20194	>	fail:
20195	>	if (SWIG_IsNewObj(res2)) delete arg2;
20196	>	return NULL;
20197		}
20198
20199
20200	<	static PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
20201	<	PyObject *resultobj;
20202	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20203	<	std::string *arg2 = 0 ;
20204	<	std::string arg3 = (std::string) "NULL" ;
20205	<	std::string arg4 = (std::string) "NULL" ;
20206	<	std::string arg5 = (std::string) "NULL" ;
20207	<	std::string arg6 = (std::string) "NULL" ;
20208	<	std::string arg7 = (std::string) "" ;
20209	<	bool arg8 = (bool) false ;
20210	<	int result;
20211	<	std::string temp2 ;
20212	<	PyObject * obj0 = 0 ;
20213	<	PyObject * obj1 = 0 ;
20214	<	PyObject * obj2 = 0 ;
20215	<	PyObject * obj3 = 0 ;
20216	<	PyObject * obj4 = 0 ;
20217	<	PyObject * obj5 = 0 ;
20218	<	PyObject * obj6 = 0 ;
20219	<	PyObject * obj7 = 0 ;
20220	<
20221	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20222	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
20223	<	{
20224	<	if (PyString_Check(obj1)) {
20225	<	temp2 = std::string(PyString_AsString(obj1));
20226	<	arg2 = &temp2;
20227	<	}else {
20228	<	SWIG_exception(SWIG_TypeError, "string expected");
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());
20618	>	}
20619	>	}
20620	>	resultobj = SWIG_From_int(static_cast< int >(result));
20621	>	if (SWIG_IsNewObj(res2)) delete arg2;
20622	>	return resultobj;
20623	>	fail:
20624	>	if (SWIG_IsNewObj(res2)) delete arg2;
20625	>	return NULL;
20626	>	}
20627	>
20628	>
20629	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
20630	>	int argc;
20631	>	PyObject *argv[9];
20632	>	int ii;
20633	>
20634	>	if (!PyTuple_Check(args)) SWIG_fail;
20635	>	argc = PyObject_Length(args);
20636	>	for (ii = 0; (ii < argc) && (ii < 8); ii++) {
20637	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
20638	>	}
20639	>	if (argc == 2) {
20640	>	int _v;
20641	>	void *vptr = 0;
20642	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
20643	>	_v = SWIG_CheckState(res);
20644	>	if (_v) {
20645	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
20646	>	_v = SWIG_CheckState(res);
20647	>	if (_v) {
20648	>	return _wrap_BossAdministratorSession_registerProgram__SWIG_6(self, args);
20649	>	}
20650	>	}
20651	>	}
20652	>	if (argc == 3) {
20653	>	int _v;
20654	>	void *vptr = 0;
20655	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
20656	>	_v = SWIG_CheckState(res);
20657	>	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);
20665		}
20666	+	}
20667		}
20668	<	if (obj2) {
20669	<	{
20670	<	if (PyString_Check(obj2))
20671	<	arg3 = std::string(PyString_AsString(obj2));
20672	<	else
20673	<	SWIG_exception(SWIG_TypeError, "string expected");
20668	>	}
20669	>	if (argc == 4) {
20670	>	int _v;
20671	>	void *vptr = 0;
20672	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
20673	>	_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	>	}
20686		}
20687	+	}
20688		}
20689	<	if (obj3) {
20690	<	{
20691	<	if (PyString_Check(obj3))
20692	<	arg4 = std::string(PyString_AsString(obj3));
20693	<	else
20694	<	SWIG_exception(SWIG_TypeError, "string expected");
20689	>	}
20690	>	if (argc == 5) {
20691	>	int _v;
20692	>	void *vptr = 0;
20693	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
20694	>	_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	>	}
20711		}
20712	+	}
20713		}
20714	<	if (obj4) {
20715	<	{
20716	<	if (PyString_Check(obj4))
20717	<	arg5 = std::string(PyString_AsString(obj4));
20718	<	else
20719	<	SWIG_exception(SWIG_TypeError, "string expected");
20714	>	}
20715	>	if (argc == 6) {
20716	>	int _v;
20717	>	void *vptr = 0;
20718	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
20719	>	_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	>	}
20740		}
20741	+	}
20742		}
20743	<	if (obj5) {
20744	<	{
20745	<	if (PyString_Check(obj5))
20746	<	arg6 = std::string(PyString_AsString(obj5));
20747	<	else
20748	<	SWIG_exception(SWIG_TypeError, "string expected");
20743	>	}
20744	>	if (argc == 7) {
20745	>	int _v;
20746	>	void *vptr = 0;
20747	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
20748	>	_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	>	}
20773		}
20774	+	}
20775		}
20776	<	if (obj6) {
20777	<	{
20778	<	if (PyString_Check(obj6))
20779	<	arg7 = std::string(PyString_AsString(obj6));
20780	<	else
20781	<	SWIG_exception(SWIG_TypeError, "string expected");
20776	>	}
20777	>	if (argc == 8) {
20778	>	int _v;
20779	>	void *vptr = 0;
20780	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
20781	>	_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	>	}
20812		}
20813	+	}
20814	+	}
20815	+	}
20816	+
20817	+	fail:
20818	+	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_registerProgram'");
20819	+	return NULL;
20820	+	}
20821	+
20822	+
20823	+	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20824	+	PyObject *resultobj = 0;
20825	+	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20826	+	std::string *arg2 = 0 ;
20827	+	std::string arg3 ;
20828	+	std::string arg4 ;
20829	+	std::string arg5 ;
20830	+	bool arg6 ;
20831	+	bool arg7 ;
20832	+	int result;
20833	+	void *argp1 = 0 ;
20834	+	int res1 = 0 ;
20835	+	int res2 = SWIG_OLDOBJ ;
20836	+	bool val6 ;
20837	+	int ecode6 = 0 ;
20838	+	bool val7 ;
20839	+	int ecode7 = 0 ;
20840	+	PyObject * obj0 = 0 ;
20841	+	PyObject * obj1 = 0 ;
20842	+	PyObject * obj2 = 0 ;
20843	+	PyObject * obj3 = 0 ;
20844	+	PyObject * obj4 = 0 ;
20845	+	PyObject * obj5 = 0 ;
20846	+	PyObject * obj6 = 0 ;
20847	+
20848	+	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
20849	+	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20850	+	if (!SWIG_IsOK(res1)) {
20851	+	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20852	+	}
20853	+	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20854	+	{
20855	+	std::string *ptr = (std::string *)0;
20856	+	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20857	+	if (!SWIG_IsOK(res2)) {
20858	+	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
20859		}
20860	<	if (obj7) {
20861	<	arg8 = PyInt_AsLong(obj7) ? true : false;
4843	<	if (PyErr_Occurred()) SWIG_fail;
20860	>	if (!ptr) {
20861	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
20862		}
20863	<	{
20864	<	try {
20865	<	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
20866	<
20867	<	}catch (const std::exception& e) {
20868	<	SWIG_exception(SWIG_RuntimeError, e.what());
20869	<	}
20863	>	arg2 = ptr;
20864	>	}
20865	>	{
20866	>	std::string *ptr = (std::string *)0;
20867	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20868	>	if (!SWIG_IsOK(res) || !ptr) {
20869	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
20870		}
20871	<	resultobj = PyInt_FromLong((long)result);
20872	<	return resultobj;
20873	<	fail:
20874	<	return NULL;
20871	>	arg3 = *ptr;
20872	>	if (SWIG_IsNewObj(res)) delete ptr;
20873	>	}
20874	>	{
20875	>	std::string *ptr = (std::string *)0;
20876	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20877	>	if (!SWIG_IsOK(res) || !ptr) {
20878	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "4"" of type '" "std::string""'");
20879	>	}
20880	>	arg4 = *ptr;
20881	>	if (SWIG_IsNewObj(res)) delete ptr;
20882	>	}
20883	>	{
20884	>	std::string *ptr = (std::string *)0;
20885	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20886	>	if (!SWIG_IsOK(res) || !ptr) {
20887	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "5"" of type '" "std::string""'");
20888	>	}
20889	>	arg5 = *ptr;
20890	>	if (SWIG_IsNewObj(res)) delete ptr;
20891	>	}
20892	>	ecode6 = SWIG_AsVal_bool(obj5, &val6);
20893	>	if (!SWIG_IsOK(ecode6)) {
20894	>	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "6"" of type '" "bool""'");
20895	>	}
20896	>	arg6 = static_cast< bool >(val6);
20897	>	ecode7 = SWIG_AsVal_bool(obj6, &val7);
20898	>	if (!SWIG_IsOK(ecode7)) {
20899	>	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "7"" of type '" "bool""'");
20900	>	}
20901	>	arg7 = static_cast< bool >(val7);
20902	>	{
20903	>	try {
20904	>	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
20905	>	} catch (const std::exception& e) {
20906	>	SWIG_exception(SWIG_RuntimeError, e.what());
20907	>	}
20908	>	}
20909	>	resultobj = SWIG_From_int(static_cast< int >(result));
20910	>	if (SWIG_IsNewObj(res2)) delete arg2;
20911	>	return resultobj;
20912	>	fail:
20913	>	if (SWIG_IsNewObj(res2)) delete arg2;
20914	>	return NULL;
20915		}
20916
20917
20918	<	static PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
20919	<	PyObject *resultobj;
20920	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20921	<	std::string *arg2 = 0 ;
20922	<	std::string arg3 = (std::string) "NULL" ;
20923	<	std::string arg4 = (std::string) "NULL" ;
20924	<	std::string arg5 = (std::string) "NULL" ;
20925	<	bool arg6 = (bool) false ;
20926	<	bool arg7 = (bool) false ;
20927	<	int result;
20928	<	std::string temp2 ;
20929	<	PyObject * obj0 = 0 ;
20930	<	PyObject * obj1 = 0 ;
20931	<	PyObject * obj2 = 0 ;
20932	<	PyObject * obj3 = 0 ;
20933	<	PyObject * obj4 = 0 ;
20934	<	PyObject * obj5 = 0 ;
20935	<	PyObject * obj6 = 0 ;
20936	<
20937	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
20938	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
20939	<	{
20940	<	if (PyString_Check(obj1)) {
20941	<	temp2 = std::string(PyString_AsString(obj1));
20942	<	arg2 = &temp2;
20943	<	}else {
20944	<	SWIG_exception(SWIG_TypeError, "string expected");
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());
21235	>	}
21236	>	}
21237	>	resultobj = SWIG_From_int(static_cast< int >(result));
21238	>	if (SWIG_IsNewObj(res2)) delete arg2;
21239	>	return resultobj;
21240	>	fail:
21241	>	if (SWIG_IsNewObj(res2)) delete arg2;
21242	>	return NULL;
21243	>	}
21244	>
21245	>
21246	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
21247	>	int argc;
21248	>	PyObject *argv[8];
21249	>	int ii;
21250	>
21251	>	if (!PyTuple_Check(args)) SWIG_fail;
21252	>	argc = PyObject_Length(args);
21253	>	for (ii = 0; (ii < argc) && (ii < 7); ii++) {
21254	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
21255	>	}
21256	>	if (argc == 2) {
21257	>	int _v;
21258	>	void *vptr = 0;
21259	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
21260	>	_v = SWIG_CheckState(res);
21261	>	if (_v) {
21262	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
21263	>	_v = SWIG_CheckState(res);
21264	>	if (_v) {
21265	>	return _wrap_BossAdministratorSession_registerRTMon__SWIG_5(self, args);
21266	>	}
21267	>	}
21268	>	}
21269	>	if (argc == 3) {
21270	>	int _v;
21271	>	void *vptr = 0;
21272	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
21273	>	_v = SWIG_CheckState(res);
21274	>	if (_v) {
21275	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
21276	>	_v = SWIG_CheckState(res);
21277	>	if (_v) {
21278	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
21279	>	_v = SWIG_CheckState(res);
21280	>	if (_v) {
21281	>	return _wrap_BossAdministratorSession_registerRTMon__SWIG_4(self, args);
21282		}
21283	+	}
21284		}
21285	<	if (obj2) {
21286	<	{
21287	<	if (PyString_Check(obj2))
21288	<	arg3 = std::string(PyString_AsString(obj2));
21289	<	else
21290	<	SWIG_exception(SWIG_TypeError, "string expected");
21285	>	}
21286	>	if (argc == 4) {
21287	>	int _v;
21288	>	void *vptr = 0;
21289	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
21290	>	_v = SWIG_CheckState(res);
21291	>	if (_v) {
21292	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
21293	>	_v = SWIG_CheckState(res);
21294	>	if (_v) {
21295	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
21296	>	_v = SWIG_CheckState(res);
21297	>	if (_v) {
21298	>	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
21299	>	_v = SWIG_CheckState(res);
21300	>	if (_v) {
21301	>	return _wrap_BossAdministratorSession_registerRTMon__SWIG_3(self, args);
21302	>	}
21303		}
21304	+	}
21305		}
21306	<	if (obj3) {
21307	<	{
21308	<	if (PyString_Check(obj3))
21309	<	arg4 = std::string(PyString_AsString(obj3));
21310	<	else
21311	<	SWIG_exception(SWIG_TypeError, "string expected");
21306	>	}
21307	>	if (argc == 5) {
21308	>	int _v;
21309	>	void *vptr = 0;
21310	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
21311	>	_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	>	}
21328		}
21329	+	}
21330		}
21331	<	if (obj4) {
21332	<	{
21333	<	if (PyString_Check(obj4))
21334	<	arg5 = std::string(PyString_AsString(obj4));
21335	<	else
21336	<	SWIG_exception(SWIG_TypeError, "string expected");
21331	>	}
21332	>	if (argc == 6) {
21333	>	int _v;
21334	>	void *vptr = 0;
21335	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
21336	>	_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	<	if (obj5) {
21363	<	arg6 = PyInt_AsLong(obj5) ? true : false;
21364	<	if (PyErr_Occurred()) SWIG_fail;
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	>	}
21396	>	}
21397	>	}
21398		}
21399	<	if (obj6) {
21400	<	arg7 = PyInt_AsLong(obj6) ? true : false;
21401	<	if (PyErr_Occurred()) SWIG_fail;
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	<	{
21462	<	try {
4923	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
4924	<
4925	<	}catch (const std::exception& e) {
4926	<	SWIG_exception(SWIG_RuntimeError, e.what());
4927	<	}
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	<	resultobj = PyInt_FromLong((long)result);
21465	<	return resultobj;
21466	<	fail:
21467	<	return NULL;
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	<	static PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
21596	<	PyObject *resultobj;
21597	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21598	<	std::string *arg2 = 0 ;
21599	<	std::string arg3 = (std::string) "NULL" ;
21600	<	std::string arg4 = (std::string) "NULL" ;
21601	<	std::string arg5 = (std::string) "NULL" ;
21602	<	std::string arg6 = (std::string) "NULL" ;
21603	<	std::string arg7 = (std::string) "" ;
21604	<	std::string arg8 = (std::string) "" ;
21605	<	std::string arg9 = (std::string) "" ;
21606	<	std::string arg10 = (std::string) "" ;
21607	<	std::string const &arg11_defvalue = "" ;
21608	<	std::string *arg11 = (std::string *) &arg11_defvalue ;
21609	<	std::string arg12 = (std::string) "" ;
21610	<	std::string arg13 = (std::string) "" ;
21611	<	bool arg14 = (bool) false ;
21612	<	bool arg15 = (bool) false ;
21613	<	int result;
21614	<	std::string temp2 ;
21615	<	std::string temp11 ;
21616	<	PyObject * obj0 = 0 ;
21617	<	PyObject * obj1 = 0 ;
21618	<	PyObject * obj2 = 0 ;
21619	<	PyObject * obj3 = 0 ;
21620	<	PyObject * obj4 = 0 ;
21621	<	PyObject * obj5 = 0 ;
21622	<	PyObject * obj6 = 0 ;
21623	<	PyObject * obj7 = 0 ;
21624	<	PyObject * obj8 = 0 ;
21625	<	PyObject * obj9 = 0 ;
21626	<	PyObject * obj10 = 0 ;
21627	<	PyObject * obj11 = 0 ;
21628	<	PyObject * obj12 = 0 ;
21629	<	PyObject * obj13 = 0 ;
21630	<	PyObject * obj14 = 0 ;
21631	<
21632	<	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) goto fail;
21633	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
21634	<	{
21635	<	if (PyString_Check(obj1)) {
21636	<	temp2 = std::string(PyString_AsString(obj1));
21637	<	arg2 = &temp2;
21638	<	}else {
21639	<	SWIG_exception(SWIG_TypeError, "string expected");
21640	<	}
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 (obj2) {
21646	<	{
4985	<	if (PyString_Check(obj2))
4986	<	arg3 = std::string(PyString_AsString(obj2));
4987	<	else
4988	<	SWIG_exception(SWIG_TypeError, "string expected");
4989	<	}
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	<	if (obj3) {
21649	<	{
21650	<	if (PyString_Check(obj3))
21651	<	arg4 = std::string(PyString_AsString(obj3));
21652	<	else
21653	<	SWIG_exception(SWIG_TypeError, "string expected");
21648	>	arg2 = ptr;
21649	>	}
21650	>	{
21651	>	std::string *ptr = (std::string *)0;
21652	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21653	>	if (!SWIG_IsOK(res) || !ptr) {
21654	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
21655	>	}
21656	>	arg3 = *ptr;
21657	>	if (SWIG_IsNewObj(res)) delete ptr;
21658	>	}
21659	>	{
21660	>	std::string *ptr = (std::string *)0;
21661	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21662	>	if (!SWIG_IsOK(res) || !ptr) {
21663	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
21664	>	}
21665	>	arg4 = *ptr;
21666	>	if (SWIG_IsNewObj(res)) delete ptr;
21667	>	}
21668	>	{
21669	>	std::string *ptr = (std::string *)0;
21670	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
21671	>	if (!SWIG_IsOK(res) || !ptr) {
21672	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
21673	>	}
21674	>	arg5 = *ptr;
21675	>	if (SWIG_IsNewObj(res)) delete ptr;
21676	>	}
21677	>	{
21678	>	std::string *ptr = (std::string *)0;
21679	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
21680	>	if (!SWIG_IsOK(res) || !ptr) {
21681	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
21682	>	}
21683	>	arg6 = *ptr;
21684	>	if (SWIG_IsNewObj(res)) delete ptr;
21685	>	}
21686	>	{
21687	>	std::string *ptr = (std::string *)0;
21688	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
21689	>	if (!SWIG_IsOK(res) || !ptr) {
21690	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
21691	>	}
21692	>	arg7 = *ptr;
21693	>	if (SWIG_IsNewObj(res)) delete ptr;
21694	>	}
21695	>	{
21696	>	std::string *ptr = (std::string *)0;
21697	>	int res = SWIG_AsPtr_std_string(obj7, &ptr);
21698	>	if (!SWIG_IsOK(res) || !ptr) {
21699	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
21700	>	}
21701	>	arg8 = *ptr;
21702	>	if (SWIG_IsNewObj(res)) delete ptr;
21703	>	}
21704	>	{
21705	>	std::string *ptr = (std::string *)0;
21706	>	int res = SWIG_AsPtr_std_string(obj8, &ptr);
21707	>	if (!SWIG_IsOK(res) || !ptr) {
21708	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
21709	>	}
21710	>	arg9 = *ptr;
21711	>	if (SWIG_IsNewObj(res)) delete ptr;
21712	>	}
21713	>	{
21714	>	std::string *ptr = (std::string *)0;
21715	>	int res = SWIG_AsPtr_std_string(obj9, &ptr);
21716	>	if (!SWIG_IsOK(res) || !ptr) {
21717	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
21718	>	}
21719	>	arg10 = *ptr;
21720	>	if (SWIG_IsNewObj(res)) delete ptr;
21721	>	}
21722	>	{
21723	>	std::string *ptr = (std::string *)0;
21724	>	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
21725	>	if (!SWIG_IsOK(res11)) {
21726	>	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21727	>	}
21728	>	if (!ptr) {
21729	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21730	>	}
21731	>	arg11 = ptr;
21732	>	}
21733	>	{
21734	>	std::string *ptr = (std::string *)0;
21735	>	int res = SWIG_AsPtr_std_string(obj11, &ptr);
21736	>	if (!SWIG_IsOK(res) || !ptr) {
21737	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "12"" of type '" "std::string""'");
21738	>	}
21739	>	arg12 = *ptr;
21740	>	if (SWIG_IsNewObj(res)) delete ptr;
21741	>	}
21742	>	{
21743	>	std::string *ptr = (std::string *)0;
21744	>	int res = SWIG_AsPtr_std_string(obj12, &ptr);
21745	>	if (!SWIG_IsOK(res) || !ptr) {
21746	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "13"" of type '" "std::string""'");
21747	>	}
21748	>	arg13 = *ptr;
21749	>	if (SWIG_IsNewObj(res)) delete ptr;
21750	>	}
21751	>	ecode14 = SWIG_AsVal_bool(obj13, &val14);
21752	>	if (!SWIG_IsOK(ecode14)) {
21753	>	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "14"" of type '" "bool""'");
21754	>	}
21755	>	arg14 = static_cast< bool >(val14);
21756	>	{
21757	>	try {
21758	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14);
21759	>	} catch (const std::exception& e) {
21760	>	SWIG_exception(SWIG_RuntimeError, e.what());
21761	>	}
21762	>	}
21763	>	resultobj = SWIG_From_int(static_cast< int >(result));
21764	>	if (SWIG_IsNewObj(res2)) delete arg2;
21765	>	if (SWIG_IsNewObj(res11)) delete arg11;
21766	>	return resultobj;
21767	>	fail:
21768	>	if (SWIG_IsNewObj(res2)) delete arg2;
21769	>	if (SWIG_IsNewObj(res11)) delete arg11;
21770	>	return NULL;
21771	>	}
21772	>
21773	>
21774	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21775	>	PyObject *resultobj = 0;
21776	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21777	>	std::string *arg2 = 0 ;
21778	>	std::string arg3 ;
21779	>	std::string arg4 ;
21780	>	std::string arg5 ;
21781	>	std::string arg6 ;
21782	>	std::string arg7 ;
21783	>	std::string arg8 ;
21784	>	std::string arg9 ;
21785	>	std::string arg10 ;
21786	>	std::string *arg11 = 0 ;
21787	>	std::string arg12 ;
21788	>	std::string arg13 ;
21789	>	int result;
21790	>	void *argp1 = 0 ;
21791	>	int res1 = 0 ;
21792	>	int res2 = SWIG_OLDOBJ ;
21793	>	int res11 = SWIG_OLDOBJ ;
21794	>	PyObject * obj0 = 0 ;
21795	>	PyObject * obj1 = 0 ;
21796	>	PyObject * obj2 = 0 ;
21797	>	PyObject * obj3 = 0 ;
21798	>	PyObject * obj4 = 0 ;
21799	>	PyObject * obj5 = 0 ;
21800	>	PyObject * obj6 = 0 ;
21801	>	PyObject * obj7 = 0 ;
21802	>	PyObject * obj8 = 0 ;
21803	>	PyObject * obj9 = 0 ;
21804	>	PyObject * obj10 = 0 ;
21805	>	PyObject * obj11 = 0 ;
21806	>	PyObject * obj12 = 0 ;
21807	>
21808	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
21809	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21810	>	if (!SWIG_IsOK(res1)) {
21811	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21812	>	}
21813	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21814	>	{
21815	>	std::string *ptr = (std::string *)0;
21816	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21817	>	if (!SWIG_IsOK(res2)) {
21818	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21819	>	}
21820	>	if (!ptr) {
21821	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21822	>	}
21823	>	arg2 = ptr;
21824	>	}
21825	>	{
21826	>	std::string *ptr = (std::string *)0;
21827	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21828	>	if (!SWIG_IsOK(res) || !ptr) {
21829	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
21830	>	}
21831	>	arg3 = *ptr;
21832	>	if (SWIG_IsNewObj(res)) delete ptr;
21833	>	}
21834	>	{
21835	>	std::string *ptr = (std::string *)0;
21836	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21837	>	if (!SWIG_IsOK(res) || !ptr) {
21838	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
21839	>	}
21840	>	arg4 = *ptr;
21841	>	if (SWIG_IsNewObj(res)) delete ptr;
21842	>	}
21843	>	{
21844	>	std::string *ptr = (std::string *)0;
21845	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
21846	>	if (!SWIG_IsOK(res) || !ptr) {
21847	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
21848	>	}
21849	>	arg5 = *ptr;
21850	>	if (SWIG_IsNewObj(res)) delete ptr;
21851	>	}
21852	>	{
21853	>	std::string *ptr = (std::string *)0;
21854	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
21855	>	if (!SWIG_IsOK(res) || !ptr) {
21856	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
21857	>	}
21858	>	arg6 = *ptr;
21859	>	if (SWIG_IsNewObj(res)) delete ptr;
21860	>	}
21861	>	{
21862	>	std::string *ptr = (std::string *)0;
21863	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
21864	>	if (!SWIG_IsOK(res) || !ptr) {
21865	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
21866	>	}
21867	>	arg7 = *ptr;
21868	>	if (SWIG_IsNewObj(res)) delete ptr;
21869	>	}
21870	>	{
21871	>	std::string *ptr = (std::string *)0;
21872	>	int res = SWIG_AsPtr_std_string(obj7, &ptr);
21873	>	if (!SWIG_IsOK(res) || !ptr) {
21874	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
21875	>	}
21876	>	arg8 = *ptr;
21877	>	if (SWIG_IsNewObj(res)) delete ptr;
21878	>	}
21879	>	{
21880	>	std::string *ptr = (std::string *)0;
21881	>	int res = SWIG_AsPtr_std_string(obj8, &ptr);
21882	>	if (!SWIG_IsOK(res) || !ptr) {
21883	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
21884	>	}
21885	>	arg9 = *ptr;
21886	>	if (SWIG_IsNewObj(res)) delete ptr;
21887	>	}
21888	>	{
21889	>	std::string *ptr = (std::string *)0;
21890	>	int res = SWIG_AsPtr_std_string(obj9, &ptr);
21891	>	if (!SWIG_IsOK(res) || !ptr) {
21892	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
21893	>	}
21894	>	arg10 = *ptr;
21895	>	if (SWIG_IsNewObj(res)) delete ptr;
21896	>	}
21897	>	{
21898	>	std::string *ptr = (std::string *)0;
21899	>	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
21900	>	if (!SWIG_IsOK(res11)) {
21901	>	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21902	>	}
21903	>	if (!ptr) {
21904	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21905	>	}
21906	>	arg11 = ptr;
21907	>	}
21908	>	{
21909	>	std::string *ptr = (std::string *)0;
21910	>	int res = SWIG_AsPtr_std_string(obj11, &ptr);
21911	>	if (!SWIG_IsOK(res) || !ptr) {
21912	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "12"" of type '" "std::string""'");
21913	>	}
21914	>	arg12 = *ptr;
21915	>	if (SWIG_IsNewObj(res)) delete ptr;
21916	>	}
21917	>	{
21918	>	std::string *ptr = (std::string *)0;
21919	>	int res = SWIG_AsPtr_std_string(obj12, &ptr);
21920	>	if (!SWIG_IsOK(res) || !ptr) {
21921	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "13"" of type '" "std::string""'");
21922	>	}
21923	>	arg13 = *ptr;
21924	>	if (SWIG_IsNewObj(res)) delete ptr;
21925	>	}
21926	>	{
21927	>	try {
21928	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13);
21929	>	} catch (const std::exception& e) {
21930	>	SWIG_exception(SWIG_RuntimeError, e.what());
21931	>	}
21932	>	}
21933	>	resultobj = SWIG_From_int(static_cast< int >(result));
21934	>	if (SWIG_IsNewObj(res2)) delete arg2;
21935	>	if (SWIG_IsNewObj(res11)) delete arg11;
21936	>	return resultobj;
21937	>	fail:
21938	>	if (SWIG_IsNewObj(res2)) delete arg2;
21939	>	if (SWIG_IsNewObj(res11)) delete arg11;
21940	>	return NULL;
21941	>	}
21942	>
21943	>
21944	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21945	>	PyObject *resultobj = 0;
21946	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21947	>	std::string *arg2 = 0 ;
21948	>	std::string arg3 ;
21949	>	std::string arg4 ;
21950	>	std::string arg5 ;
21951	>	std::string arg6 ;
21952	>	std::string arg7 ;
21953	>	std::string arg8 ;
21954	>	std::string arg9 ;
21955	>	std::string arg10 ;
21956	>	std::string *arg11 = 0 ;
21957	>	std::string arg12 ;
21958	>	int result;
21959	>	void *argp1 = 0 ;
21960	>	int res1 = 0 ;
21961	>	int res2 = SWIG_OLDOBJ ;
21962	>	int res11 = SWIG_OLDOBJ ;
21963	>	PyObject * obj0 = 0 ;
21964	>	PyObject * obj1 = 0 ;
21965	>	PyObject * obj2 = 0 ;
21966	>	PyObject * obj3 = 0 ;
21967	>	PyObject * obj4 = 0 ;
21968	>	PyObject * obj5 = 0 ;
21969	>	PyObject * obj6 = 0 ;
21970	>	PyObject * obj7 = 0 ;
21971	>	PyObject * obj8 = 0 ;
21972	>	PyObject * obj9 = 0 ;
21973	>	PyObject * obj10 = 0 ;
21974	>	PyObject * obj11 = 0 ;
21975	>
21976	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
21977	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21978	>	if (!SWIG_IsOK(res1)) {
21979	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21980	>	}
21981	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21982	>	{
21983	>	std::string *ptr = (std::string *)0;
21984	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21985	>	if (!SWIG_IsOK(res2)) {
21986	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21987	>	}
21988	>	if (!ptr) {
21989	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21990	>	}
21991	>	arg2 = ptr;
21992	>	}
21993	>	{
21994	>	std::string *ptr = (std::string *)0;
21995	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21996	>	if (!SWIG_IsOK(res) || !ptr) {
21997	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
21998	>	}
21999	>	arg3 = *ptr;
22000	>	if (SWIG_IsNewObj(res)) delete ptr;
22001	>	}
22002	>	{
22003	>	std::string *ptr = (std::string *)0;
22004	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22005	>	if (!SWIG_IsOK(res) || !ptr) {
22006	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22007	>	}
22008	>	arg4 = *ptr;
22009	>	if (SWIG_IsNewObj(res)) delete ptr;
22010	>	}
22011	>	{
22012	>	std::string *ptr = (std::string *)0;
22013	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22014	>	if (!SWIG_IsOK(res) || !ptr) {
22015	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22016	>	}
22017	>	arg5 = *ptr;
22018	>	if (SWIG_IsNewObj(res)) delete ptr;
22019	>	}
22020	>	{
22021	>	std::string *ptr = (std::string *)0;
22022	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22023	>	if (!SWIG_IsOK(res) || !ptr) {
22024	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22025	>	}
22026	>	arg6 = *ptr;
22027	>	if (SWIG_IsNewObj(res)) delete ptr;
22028	>	}
22029	>	{
22030	>	std::string *ptr = (std::string *)0;
22031	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22032	>	if (!SWIG_IsOK(res) || !ptr) {
22033	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22034	>	}
22035	>	arg7 = *ptr;
22036	>	if (SWIG_IsNewObj(res)) delete ptr;
22037	>	}
22038	>	{
22039	>	std::string *ptr = (std::string *)0;
22040	>	int res = SWIG_AsPtr_std_string(obj7, &ptr);
22041	>	if (!SWIG_IsOK(res) || !ptr) {
22042	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
22043	>	}
22044	>	arg8 = *ptr;
22045	>	if (SWIG_IsNewObj(res)) delete ptr;
22046	>	}
22047	>	{
22048	>	std::string *ptr = (std::string *)0;
22049	>	int res = SWIG_AsPtr_std_string(obj8, &ptr);
22050	>	if (!SWIG_IsOK(res) || !ptr) {
22051	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
22052	>	}
22053	>	arg9 = *ptr;
22054	>	if (SWIG_IsNewObj(res)) delete ptr;
22055	>	}
22056	>	{
22057	>	std::string *ptr = (std::string *)0;
22058	>	int res = SWIG_AsPtr_std_string(obj9, &ptr);
22059	>	if (!SWIG_IsOK(res) || !ptr) {
22060	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
22061	>	}
22062	>	arg10 = *ptr;
22063	>	if (SWIG_IsNewObj(res)) delete ptr;
22064	>	}
22065	>	{
22066	>	std::string *ptr = (std::string *)0;
22067	>	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
22068	>	if (!SWIG_IsOK(res11)) {
22069	>	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
22070	>	}
22071	>	if (!ptr) {
22072	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
22073	>	}
22074	>	arg11 = ptr;
22075	>	}
22076	>	{
22077	>	std::string *ptr = (std::string *)0;
22078	>	int res = SWIG_AsPtr_std_string(obj11, &ptr);
22079	>	if (!SWIG_IsOK(res) || !ptr) {
22080	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "12"" of type '" "std::string""'");
22081	>	}
22082	>	arg12 = *ptr;
22083	>	if (SWIG_IsNewObj(res)) delete ptr;
22084	>	}
22085	>	{
22086	>	try {
22087	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12);
22088	>	} catch (const std::exception& e) {
22089	>	SWIG_exception(SWIG_RuntimeError, e.what());
22090	>	}
22091	>	}
22092	>	resultobj = SWIG_From_int(static_cast< int >(result));
22093	>	if (SWIG_IsNewObj(res2)) delete arg2;
22094	>	if (SWIG_IsNewObj(res11)) delete arg11;
22095	>	return resultobj;
22096	>	fail:
22097	>	if (SWIG_IsNewObj(res2)) delete arg2;
22098	>	if (SWIG_IsNewObj(res11)) delete arg11;
22099	>	return NULL;
22100	>	}
22101	>
22102	>
22103	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22104	>	PyObject *resultobj = 0;
22105	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22106	>	std::string *arg2 = 0 ;
22107	>	std::string arg3 ;
22108	>	std::string arg4 ;
22109	>	std::string arg5 ;
22110	>	std::string arg6 ;
22111	>	std::string arg7 ;
22112	>	std::string arg8 ;
22113	>	std::string arg9 ;
22114	>	std::string arg10 ;
22115	>	std::string *arg11 = 0 ;
22116	>	int result;
22117	>	void *argp1 = 0 ;
22118	>	int res1 = 0 ;
22119	>	int res2 = SWIG_OLDOBJ ;
22120	>	int res11 = SWIG_OLDOBJ ;
22121	>	PyObject * obj0 = 0 ;
22122	>	PyObject * obj1 = 0 ;
22123	>	PyObject * obj2 = 0 ;
22124	>	PyObject * obj3 = 0 ;
22125	>	PyObject * obj4 = 0 ;
22126	>	PyObject * obj5 = 0 ;
22127	>	PyObject * obj6 = 0 ;
22128	>	PyObject * obj7 = 0 ;
22129	>	PyObject * obj8 = 0 ;
22130	>	PyObject * obj9 = 0 ;
22131	>	PyObject * obj10 = 0 ;
22132	>
22133	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
22134	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22135	>	if (!SWIG_IsOK(res1)) {
22136	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22137	>	}
22138	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22139	>	{
22140	>	std::string *ptr = (std::string *)0;
22141	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22142	>	if (!SWIG_IsOK(res2)) {
22143	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22144	>	}
22145	>	if (!ptr) {
22146	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22147	>	}
22148	>	arg2 = ptr;
22149	>	}
22150	>	{
22151	>	std::string *ptr = (std::string *)0;
22152	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22153	>	if (!SWIG_IsOK(res) || !ptr) {
22154	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22155	>	}
22156	>	arg3 = *ptr;
22157	>	if (SWIG_IsNewObj(res)) delete ptr;
22158	>	}
22159	>	{
22160	>	std::string *ptr = (std::string *)0;
22161	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22162	>	if (!SWIG_IsOK(res) || !ptr) {
22163	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22164	>	}
22165	>	arg4 = *ptr;
22166	>	if (SWIG_IsNewObj(res)) delete ptr;
22167	>	}
22168	>	{
22169	>	std::string *ptr = (std::string *)0;
22170	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22171	>	if (!SWIG_IsOK(res) || !ptr) {
22172	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22173	>	}
22174	>	arg5 = *ptr;
22175	>	if (SWIG_IsNewObj(res)) delete ptr;
22176	>	}
22177	>	{
22178	>	std::string *ptr = (std::string *)0;
22179	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22180	>	if (!SWIG_IsOK(res) || !ptr) {
22181	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22182	>	}
22183	>	arg6 = *ptr;
22184	>	if (SWIG_IsNewObj(res)) delete ptr;
22185	>	}
22186	>	{
22187	>	std::string *ptr = (std::string *)0;
22188	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22189	>	if (!SWIG_IsOK(res) || !ptr) {
22190	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22191	>	}
22192	>	arg7 = *ptr;
22193	>	if (SWIG_IsNewObj(res)) delete ptr;
22194	>	}
22195	>	{
22196	>	std::string *ptr = (std::string *)0;
22197	>	int res = SWIG_AsPtr_std_string(obj7, &ptr);
22198	>	if (!SWIG_IsOK(res) || !ptr) {
22199	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
22200	>	}
22201	>	arg8 = *ptr;
22202	>	if (SWIG_IsNewObj(res)) delete ptr;
22203	>	}
22204	>	{
22205	>	std::string *ptr = (std::string *)0;
22206	>	int res = SWIG_AsPtr_std_string(obj8, &ptr);
22207	>	if (!SWIG_IsOK(res) || !ptr) {
22208	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
22209	>	}
22210	>	arg9 = *ptr;
22211	>	if (SWIG_IsNewObj(res)) delete ptr;
22212	>	}
22213	>	{
22214	>	std::string *ptr = (std::string *)0;
22215	>	int res = SWIG_AsPtr_std_string(obj9, &ptr);
22216	>	if (!SWIG_IsOK(res) || !ptr) {
22217	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
22218	>	}
22219	>	arg10 = *ptr;
22220	>	if (SWIG_IsNewObj(res)) delete ptr;
22221	>	}
22222	>	{
22223	>	std::string *ptr = (std::string *)0;
22224	>	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
22225	>	if (!SWIG_IsOK(res11)) {
22226	>	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
22227	>	}
22228	>	if (!ptr) {
22229	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
22230	>	}
22231	>	arg11 = ptr;
22232	>	}
22233	>	{
22234	>	try {
22235	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11);
22236	>	} catch (const std::exception& e) {
22237	>	SWIG_exception(SWIG_RuntimeError, e.what());
22238	>	}
22239	>	}
22240	>	resultobj = SWIG_From_int(static_cast< int >(result));
22241	>	if (SWIG_IsNewObj(res2)) delete arg2;
22242	>	if (SWIG_IsNewObj(res11)) delete arg11;
22243	>	return resultobj;
22244	>	fail:
22245	>	if (SWIG_IsNewObj(res2)) delete arg2;
22246	>	if (SWIG_IsNewObj(res11)) delete arg11;
22247	>	return NULL;
22248	>	}
22249	>
22250	>
22251	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22252	>	PyObject *resultobj = 0;
22253	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22254	>	std::string *arg2 = 0 ;
22255	>	std::string arg3 ;
22256	>	std::string arg4 ;
22257	>	std::string arg5 ;
22258	>	std::string arg6 ;
22259	>	std::string arg7 ;
22260	>	std::string arg8 ;
22261	>	std::string arg9 ;
22262	>	std::string arg10 ;
22263	>	int result;
22264	>	void *argp1 = 0 ;
22265	>	int res1 = 0 ;
22266	>	int res2 = SWIG_OLDOBJ ;
22267	>	PyObject * obj0 = 0 ;
22268	>	PyObject * obj1 = 0 ;
22269	>	PyObject * obj2 = 0 ;
22270	>	PyObject * obj3 = 0 ;
22271	>	PyObject * obj4 = 0 ;
22272	>	PyObject * obj5 = 0 ;
22273	>	PyObject * obj6 = 0 ;
22274	>	PyObject * obj7 = 0 ;
22275	>	PyObject * obj8 = 0 ;
22276	>	PyObject * obj9 = 0 ;
22277	>
22278	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
22279	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22280	>	if (!SWIG_IsOK(res1)) {
22281	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22282	>	}
22283	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22284	>	{
22285	>	std::string *ptr = (std::string *)0;
22286	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22287	>	if (!SWIG_IsOK(res2)) {
22288	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22289	>	}
22290	>	if (!ptr) {
22291	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22292	>	}
22293	>	arg2 = ptr;
22294	>	}
22295	>	{
22296	>	std::string *ptr = (std::string *)0;
22297	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22298	>	if (!SWIG_IsOK(res) || !ptr) {
22299	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22300	>	}
22301	>	arg3 = *ptr;
22302	>	if (SWIG_IsNewObj(res)) delete ptr;
22303	>	}
22304	>	{
22305	>	std::string *ptr = (std::string *)0;
22306	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22307	>	if (!SWIG_IsOK(res) || !ptr) {
22308	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22309	>	}
22310	>	arg4 = *ptr;
22311	>	if (SWIG_IsNewObj(res)) delete ptr;
22312	>	}
22313	>	{
22314	>	std::string *ptr = (std::string *)0;
22315	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22316	>	if (!SWIG_IsOK(res) || !ptr) {
22317	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22318	>	}
22319	>	arg5 = *ptr;
22320	>	if (SWIG_IsNewObj(res)) delete ptr;
22321	>	}
22322	>	{
22323	>	std::string *ptr = (std::string *)0;
22324	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22325	>	if (!SWIG_IsOK(res) || !ptr) {
22326	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22327	>	}
22328	>	arg6 = *ptr;
22329	>	if (SWIG_IsNewObj(res)) delete ptr;
22330	>	}
22331	>	{
22332	>	std::string *ptr = (std::string *)0;
22333	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22334	>	if (!SWIG_IsOK(res) || !ptr) {
22335	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22336	>	}
22337	>	arg7 = *ptr;
22338	>	if (SWIG_IsNewObj(res)) delete ptr;
22339	>	}
22340	>	{
22341	>	std::string *ptr = (std::string *)0;
22342	>	int res = SWIG_AsPtr_std_string(obj7, &ptr);
22343	>	if (!SWIG_IsOK(res) || !ptr) {
22344	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
22345	>	}
22346	>	arg8 = *ptr;
22347	>	if (SWIG_IsNewObj(res)) delete ptr;
22348	>	}
22349	>	{
22350	>	std::string *ptr = (std::string *)0;
22351	>	int res = SWIG_AsPtr_std_string(obj8, &ptr);
22352	>	if (!SWIG_IsOK(res) || !ptr) {
22353	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
22354	>	}
22355	>	arg9 = *ptr;
22356	>	if (SWIG_IsNewObj(res)) delete ptr;
22357	>	}
22358	>	{
22359	>	std::string *ptr = (std::string *)0;
22360	>	int res = SWIG_AsPtr_std_string(obj9, &ptr);
22361	>	if (!SWIG_IsOK(res) || !ptr) {
22362	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
22363	>	}
22364	>	arg10 = *ptr;
22365	>	if (SWIG_IsNewObj(res)) delete ptr;
22366	>	}
22367	>	{
22368	>	try {
22369	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
22370	>	} catch (const std::exception& e) {
22371	>	SWIG_exception(SWIG_RuntimeError, e.what());
22372	>	}
22373	>	}
22374	>	resultobj = SWIG_From_int(static_cast< int >(result));
22375	>	if (SWIG_IsNewObj(res2)) delete arg2;
22376	>	return resultobj;
22377	>	fail:
22378	>	if (SWIG_IsNewObj(res2)) delete arg2;
22379	>	return NULL;
22380	>	}
22381	>
22382	>
22383	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22384	>	PyObject *resultobj = 0;
22385	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22386	>	std::string *arg2 = 0 ;
22387	>	std::string arg3 ;
22388	>	std::string arg4 ;
22389	>	std::string arg5 ;
22390	>	std::string arg6 ;
22391	>	std::string arg7 ;
22392	>	std::string arg8 ;
22393	>	std::string arg9 ;
22394	>	int result;
22395	>	void *argp1 = 0 ;
22396	>	int res1 = 0 ;
22397	>	int res2 = SWIG_OLDOBJ ;
22398	>	PyObject * obj0 = 0 ;
22399	>	PyObject * obj1 = 0 ;
22400	>	PyObject * obj2 = 0 ;
22401	>	PyObject * obj3 = 0 ;
22402	>	PyObject * obj4 = 0 ;
22403	>	PyObject * obj5 = 0 ;
22404	>	PyObject * obj6 = 0 ;
22405	>	PyObject * obj7 = 0 ;
22406	>	PyObject * obj8 = 0 ;
22407	>
22408	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
22409	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22410	>	if (!SWIG_IsOK(res1)) {
22411	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22412	>	}
22413	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22414	>	{
22415	>	std::string *ptr = (std::string *)0;
22416	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22417	>	if (!SWIG_IsOK(res2)) {
22418	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22419	>	}
22420	>	if (!ptr) {
22421	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22422	>	}
22423	>	arg2 = ptr;
22424	>	}
22425	>	{
22426	>	std::string *ptr = (std::string *)0;
22427	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22428	>	if (!SWIG_IsOK(res) || !ptr) {
22429	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22430	>	}
22431	>	arg3 = *ptr;
22432	>	if (SWIG_IsNewObj(res)) delete ptr;
22433	>	}
22434	>	{
22435	>	std::string *ptr = (std::string *)0;
22436	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22437	>	if (!SWIG_IsOK(res) || !ptr) {
22438	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22439	>	}
22440	>	arg4 = *ptr;
22441	>	if (SWIG_IsNewObj(res)) delete ptr;
22442	>	}
22443	>	{
22444	>	std::string *ptr = (std::string *)0;
22445	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22446	>	if (!SWIG_IsOK(res) || !ptr) {
22447	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22448	>	}
22449	>	arg5 = *ptr;
22450	>	if (SWIG_IsNewObj(res)) delete ptr;
22451	>	}
22452	>	{
22453	>	std::string *ptr = (std::string *)0;
22454	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22455	>	if (!SWIG_IsOK(res) || !ptr) {
22456	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22457	>	}
22458	>	arg6 = *ptr;
22459	>	if (SWIG_IsNewObj(res)) delete ptr;
22460	>	}
22461	>	{
22462	>	std::string *ptr = (std::string *)0;
22463	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22464	>	if (!SWIG_IsOK(res) || !ptr) {
22465	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22466	>	}
22467	>	arg7 = *ptr;
22468	>	if (SWIG_IsNewObj(res)) delete ptr;
22469	>	}
22470	>	{
22471	>	std::string *ptr = (std::string *)0;
22472	>	int res = SWIG_AsPtr_std_string(obj7, &ptr);
22473	>	if (!SWIG_IsOK(res) || !ptr) {
22474	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
22475	>	}
22476	>	arg8 = *ptr;
22477	>	if (SWIG_IsNewObj(res)) delete ptr;
22478	>	}
22479	>	{
22480	>	std::string *ptr = (std::string *)0;
22481	>	int res = SWIG_AsPtr_std_string(obj8, &ptr);
22482	>	if (!SWIG_IsOK(res) || !ptr) {
22483	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
22484	>	}
22485	>	arg9 = *ptr;
22486	>	if (SWIG_IsNewObj(res)) delete ptr;
22487	>	}
22488	>	{
22489	>	try {
22490	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
22491	>	} catch (const std::exception& e) {
22492	>	SWIG_exception(SWIG_RuntimeError, e.what());
22493	>	}
22494	>	}
22495	>	resultobj = SWIG_From_int(static_cast< int >(result));
22496	>	if (SWIG_IsNewObj(res2)) delete arg2;
22497	>	return resultobj;
22498	>	fail:
22499	>	if (SWIG_IsNewObj(res2)) delete arg2;
22500	>	return NULL;
22501	>	}
22502	>
22503	>
22504	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22505	>	PyObject *resultobj = 0;
22506	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22507	>	std::string *arg2 = 0 ;
22508	>	std::string arg3 ;
22509	>	std::string arg4 ;
22510	>	std::string arg5 ;
22511	>	std::string arg6 ;
22512	>	std::string arg7 ;
22513	>	std::string arg8 ;
22514	>	int result;
22515	>	void *argp1 = 0 ;
22516	>	int res1 = 0 ;
22517	>	int res2 = SWIG_OLDOBJ ;
22518	>	PyObject * obj0 = 0 ;
22519	>	PyObject * obj1 = 0 ;
22520	>	PyObject * obj2 = 0 ;
22521	>	PyObject * obj3 = 0 ;
22522	>	PyObject * obj4 = 0 ;
22523	>	PyObject * obj5 = 0 ;
22524	>	PyObject * obj6 = 0 ;
22525	>	PyObject * obj7 = 0 ;
22526	>
22527	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
22528	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22529	>	if (!SWIG_IsOK(res1)) {
22530	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22531	>	}
22532	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22533	>	{
22534	>	std::string *ptr = (std::string *)0;
22535	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22536	>	if (!SWIG_IsOK(res2)) {
22537	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22538	>	}
22539	>	if (!ptr) {
22540	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22541	>	}
22542	>	arg2 = ptr;
22543	>	}
22544	>	{
22545	>	std::string *ptr = (std::string *)0;
22546	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22547	>	if (!SWIG_IsOK(res) || !ptr) {
22548	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22549	>	}
22550	>	arg3 = *ptr;
22551	>	if (SWIG_IsNewObj(res)) delete ptr;
22552	>	}
22553	>	{
22554	>	std::string *ptr = (std::string *)0;
22555	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22556	>	if (!SWIG_IsOK(res) || !ptr) {
22557	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22558	>	}
22559	>	arg4 = *ptr;
22560	>	if (SWIG_IsNewObj(res)) delete ptr;
22561	>	}
22562	>	{
22563	>	std::string *ptr = (std::string *)0;
22564	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22565	>	if (!SWIG_IsOK(res) || !ptr) {
22566	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22567	>	}
22568	>	arg5 = *ptr;
22569	>	if (SWIG_IsNewObj(res)) delete ptr;
22570	>	}
22571	>	{
22572	>	std::string *ptr = (std::string *)0;
22573	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22574	>	if (!SWIG_IsOK(res) || !ptr) {
22575	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22576	>	}
22577	>	arg6 = *ptr;
22578	>	if (SWIG_IsNewObj(res)) delete ptr;
22579	>	}
22580	>	{
22581	>	std::string *ptr = (std::string *)0;
22582	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22583	>	if (!SWIG_IsOK(res) || !ptr) {
22584	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22585	>	}
22586	>	arg7 = *ptr;
22587	>	if (SWIG_IsNewObj(res)) delete ptr;
22588	>	}
22589	>	{
22590	>	std::string *ptr = (std::string *)0;
22591	>	int res = SWIG_AsPtr_std_string(obj7, &ptr);
22592	>	if (!SWIG_IsOK(res) || !ptr) {
22593	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
22594	>	}
22595	>	arg8 = *ptr;
22596	>	if (SWIG_IsNewObj(res)) delete ptr;
22597	>	}
22598	>	{
22599	>	try {
22600	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
22601	>	} catch (const std::exception& e) {
22602	>	SWIG_exception(SWIG_RuntimeError, e.what());
22603	>	}
22604	>	}
22605	>	resultobj = SWIG_From_int(static_cast< int >(result));
22606	>	if (SWIG_IsNewObj(res2)) delete arg2;
22607	>	return resultobj;
22608	>	fail:
22609	>	if (SWIG_IsNewObj(res2)) delete arg2;
22610	>	return NULL;
22611	>	}
22612	>
22613	>
22614	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22615	>	PyObject *resultobj = 0;
22616	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22617	>	std::string *arg2 = 0 ;
22618	>	std::string arg3 ;
22619	>	std::string arg4 ;
22620	>	std::string arg5 ;
22621	>	std::string arg6 ;
22622	>	std::string arg7 ;
22623	>	int result;
22624	>	void *argp1 = 0 ;
22625	>	int res1 = 0 ;
22626	>	int res2 = SWIG_OLDOBJ ;
22627	>	PyObject * obj0 = 0 ;
22628	>	PyObject * obj1 = 0 ;
22629	>	PyObject * obj2 = 0 ;
22630	>	PyObject * obj3 = 0 ;
22631	>	PyObject * obj4 = 0 ;
22632	>	PyObject * obj5 = 0 ;
22633	>	PyObject * obj6 = 0 ;
22634	>
22635	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22636	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22637	>	if (!SWIG_IsOK(res1)) {
22638	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22639	>	}
22640	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22641	>	{
22642	>	std::string *ptr = (std::string *)0;
22643	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22644	>	if (!SWIG_IsOK(res2)) {
22645	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22646	>	}
22647	>	if (!ptr) {
22648	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22649	>	}
22650	>	arg2 = ptr;
22651	>	}
22652	>	{
22653	>	std::string *ptr = (std::string *)0;
22654	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22655	>	if (!SWIG_IsOK(res) || !ptr) {
22656	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22657	>	}
22658	>	arg3 = *ptr;
22659	>	if (SWIG_IsNewObj(res)) delete ptr;
22660	>	}
22661	>	{
22662	>	std::string *ptr = (std::string *)0;
22663	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22664	>	if (!SWIG_IsOK(res) || !ptr) {
22665	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22666	>	}
22667	>	arg4 = *ptr;
22668	>	if (SWIG_IsNewObj(res)) delete ptr;
22669	>	}
22670	>	{
22671	>	std::string *ptr = (std::string *)0;
22672	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22673	>	if (!SWIG_IsOK(res) || !ptr) {
22674	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22675	>	}
22676	>	arg5 = *ptr;
22677	>	if (SWIG_IsNewObj(res)) delete ptr;
22678	>	}
22679	>	{
22680	>	std::string *ptr = (std::string *)0;
22681	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22682	>	if (!SWIG_IsOK(res) || !ptr) {
22683	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22684	>	}
22685	>	arg6 = *ptr;
22686	>	if (SWIG_IsNewObj(res)) delete ptr;
22687	>	}
22688	>	{
22689	>	std::string *ptr = (std::string *)0;
22690	>	int res = SWIG_AsPtr_std_string(obj6, &ptr);
22691	>	if (!SWIG_IsOK(res) || !ptr) {
22692	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
22693	>	}
22694	>	arg7 = *ptr;
22695	>	if (SWIG_IsNewObj(res)) delete ptr;
22696	>	}
22697	>	{
22698	>	try {
22699	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
22700	>	} catch (const std::exception& e) {
22701	>	SWIG_exception(SWIG_RuntimeError, e.what());
22702	>	}
22703	>	}
22704	>	resultobj = SWIG_From_int(static_cast< int >(result));
22705	>	if (SWIG_IsNewObj(res2)) delete arg2;
22706	>	return resultobj;
22707	>	fail:
22708	>	if (SWIG_IsNewObj(res2)) delete arg2;
22709	>	return NULL;
22710	>	}
22711	>
22712	>
22713	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22714	>	PyObject *resultobj = 0;
22715	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22716	>	std::string *arg2 = 0 ;
22717	>	std::string arg3 ;
22718	>	std::string arg4 ;
22719	>	std::string arg5 ;
22720	>	std::string arg6 ;
22721	>	int result;
22722	>	void *argp1 = 0 ;
22723	>	int res1 = 0 ;
22724	>	int res2 = SWIG_OLDOBJ ;
22725	>	PyObject * obj0 = 0 ;
22726	>	PyObject * obj1 = 0 ;
22727	>	PyObject * obj2 = 0 ;
22728	>	PyObject * obj3 = 0 ;
22729	>	PyObject * obj4 = 0 ;
22730	>	PyObject * obj5 = 0 ;
22731	>
22732	>	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
22733	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22734	>	if (!SWIG_IsOK(res1)) {
22735	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22736	>	}
22737	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22738	>	{
22739	>	std::string *ptr = (std::string *)0;
22740	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22741	>	if (!SWIG_IsOK(res2)) {
22742	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22743	>	}
22744	>	if (!ptr) {
22745	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22746	>	}
22747	>	arg2 = ptr;
22748	>	}
22749	>	{
22750	>	std::string *ptr = (std::string *)0;
22751	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22752	>	if (!SWIG_IsOK(res) || !ptr) {
22753	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22754	>	}
22755	>	arg3 = *ptr;
22756	>	if (SWIG_IsNewObj(res)) delete ptr;
22757	>	}
22758	>	{
22759	>	std::string *ptr = (std::string *)0;
22760	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22761	>	if (!SWIG_IsOK(res) || !ptr) {
22762	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22763	>	}
22764	>	arg4 = *ptr;
22765	>	if (SWIG_IsNewObj(res)) delete ptr;
22766	>	}
22767	>	{
22768	>	std::string *ptr = (std::string *)0;
22769	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22770	>	if (!SWIG_IsOK(res) || !ptr) {
22771	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22772	>	}
22773	>	arg5 = *ptr;
22774	>	if (SWIG_IsNewObj(res)) delete ptr;
22775	>	}
22776	>	{
22777	>	std::string *ptr = (std::string *)0;
22778	>	int res = SWIG_AsPtr_std_string(obj5, &ptr);
22779	>	if (!SWIG_IsOK(res) || !ptr) {
22780	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
22781	>	}
22782	>	arg6 = *ptr;
22783	>	if (SWIG_IsNewObj(res)) delete ptr;
22784	>	}
22785	>	{
22786	>	try {
22787	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6);
22788	>	} catch (const std::exception& e) {
22789	>	SWIG_exception(SWIG_RuntimeError, e.what());
22790	>	}
22791	>	}
22792	>	resultobj = SWIG_From_int(static_cast< int >(result));
22793	>	if (SWIG_IsNewObj(res2)) delete arg2;
22794	>	return resultobj;
22795	>	fail:
22796	>	if (SWIG_IsNewObj(res2)) delete arg2;
22797	>	return NULL;
22798	>	}
22799	>
22800	>
22801	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22802	>	PyObject *resultobj = 0;
22803	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22804	>	std::string *arg2 = 0 ;
22805	>	std::string arg3 ;
22806	>	std::string arg4 ;
22807	>	std::string arg5 ;
22808	>	int result;
22809	>	void *argp1 = 0 ;
22810	>	int res1 = 0 ;
22811	>	int res2 = SWIG_OLDOBJ ;
22812	>	PyObject * obj0 = 0 ;
22813	>	PyObject * obj1 = 0 ;
22814	>	PyObject * obj2 = 0 ;
22815	>	PyObject * obj3 = 0 ;
22816	>	PyObject * obj4 = 0 ;
22817	>
22818	>	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22819	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22820	>	if (!SWIG_IsOK(res1)) {
22821	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22822	>	}
22823	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22824	>	{
22825	>	std::string *ptr = (std::string *)0;
22826	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22827	>	if (!SWIG_IsOK(res2)) {
22828	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22829	>	}
22830	>	if (!ptr) {
22831	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22832	>	}
22833	>	arg2 = ptr;
22834	>	}
22835	>	{
22836	>	std::string *ptr = (std::string *)0;
22837	>	int res = SWIG_AsPtr_std_string(obj2, &ptr);
22838	>	if (!SWIG_IsOK(res) || !ptr) {
22839	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
22840	>	}
22841	>	arg3 = *ptr;
22842	>	if (SWIG_IsNewObj(res)) delete ptr;
22843	>	}
22844	>	{
22845	>	std::string *ptr = (std::string *)0;
22846	>	int res = SWIG_AsPtr_std_string(obj3, &ptr);
22847	>	if (!SWIG_IsOK(res) || !ptr) {
22848	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
22849	>	}
22850	>	arg4 = *ptr;
22851	>	if (SWIG_IsNewObj(res)) delete ptr;
22852	>	}
22853	>	{
22854	>	std::string *ptr = (std::string *)0;
22855	>	int res = SWIG_AsPtr_std_string(obj4, &ptr);
22856	>	if (!SWIG_IsOK(res) || !ptr) {
22857	>	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
22858	>	}
22859	>	arg5 = *ptr;
22860	>	if (SWIG_IsNewObj(res)) delete ptr;
22861	>	}
22862	>	{
22863	>	try {
22864	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5);
22865	>	} catch (const std::exception& e) {
22866	>	SWIG_exception(SWIG_RuntimeError, e.what());
22867	>	}
22868	>	}
22869	>	resultobj = SWIG_From_int(static_cast< int >(result));
22870	>	if (SWIG_IsNewObj(res2)) delete arg2;
22871	>	return resultobj;
22872	>	fail:
22873	>	if (SWIG_IsNewObj(res2)) delete arg2;
22874	>	return NULL;
22875	>	}
22876	>
22877	>
22878	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22879	>	PyObject *resultobj = 0;
22880	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
22881	>	std::string *arg2 = 0 ;
22882	>	std::string arg3 ;
22883	>	std::string arg4 ;
22884	>	int result;
22885	>	void *argp1 = 0 ;
22886	>	int res1 = 0 ;
22887	>	int res2 = SWIG_OLDOBJ ;
22888	>	PyObject * obj0 = 0 ;
22889	>	PyObject * obj1 = 0 ;
22890	>	PyObject * obj2 = 0 ;
22891	>	PyObject * obj3 = 0 ;
22892	>
22893	>	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22894	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
22895	>	if (!SWIG_IsOK(res1)) {
22896	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
22897	>	}
22898	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
22899	>	{
22900	>	std::string *ptr = (std::string *)0;
22901	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
22902	>	if (!SWIG_IsOK(res2)) {
22903	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
22904	>	}
22905	>	if (!ptr) {
22906	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
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());
23032	>	}
23033	>	}
23034	>	resultobj = SWIG_From_int(static_cast< int >(result));
23035	>	if (SWIG_IsNewObj(res2)) delete arg2;
23036	>	return resultobj;
23037	>	fail:
23038	>	if (SWIG_IsNewObj(res2)) delete arg2;
23039	>	return NULL;
23040	>	}
23041	>
23042	>
23043	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
23044	>	int argc;
23045	>	PyObject *argv[16];
23046	>	int ii;
23047	>
23048	>	if (!PyTuple_Check(args)) SWIG_fail;
23049	>	argc = PyObject_Length(args);
23050	>	for (ii = 0; (ii < argc) && (ii < 15); ii++) {
23051	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
23052	>	}
23053	>	if (argc == 2) {
23054	>	int _v;
23055	>	void *vptr = 0;
23056	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23057	>	_v = SWIG_CheckState(res);
23058	>	if (_v) {
23059	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23060	>	_v = SWIG_CheckState(res);
23061	>	if (_v) {
23062	>	return _wrap_BossAdministratorSession_registerScheduler__SWIG_13(self, args);
23063	>	}
23064	>	}
23065	>	}
23066	>	if (argc == 3) {
23067	>	int _v;
23068	>	void *vptr = 0;
23069	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23070	>	_v = SWIG_CheckState(res);
23071	>	if (_v) {
23072	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23073	>	_v = SWIG_CheckState(res);
23074	>	if (_v) {
23075	>	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
23076	>	_v = SWIG_CheckState(res);
23077	>	if (_v) {
23078	>	return _wrap_BossAdministratorSession_registerScheduler__SWIG_12(self, args);
23079		}
23080	+	}
23081		}
23082	<	if (obj4) {
23083	<	{
23084	<	if (PyString_Check(obj4))
23085	<	arg5 = std::string(PyString_AsString(obj4));
23086	<	else
23087	<	SWIG_exception(SWIG_TypeError, "string expected");
23082	>	}
23083	>	if (argc == 4) {
23084	>	int _v;
23085	>	void *vptr = 0;
23086	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23087	>	_v = SWIG_CheckState(res);
23088	>	if (_v) {
23089	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23090	>	_v = SWIG_CheckState(res);
23091	>	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	>	}
23100		}
23101	+	}
23102		}
23103	<	if (obj5) {
23104	<	{
23105	<	if (PyString_Check(obj5))
23106	<	arg6 = std::string(PyString_AsString(obj5));
23107	<	else
23108	<	SWIG_exception(SWIG_TypeError, "string expected");
23103	>	}
23104	>	if (argc == 5) {
23105	>	int _v;
23106	>	void *vptr = 0;
23107	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23108	>	_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	>	}
23125		}
23126	+	}
23127		}
23128	<	if (obj6) {
23129	<	{
23130	<	if (PyString_Check(obj6))
23131	<	arg7 = std::string(PyString_AsString(obj6));
23132	<	else
23133	<	SWIG_exception(SWIG_TypeError, "string expected");
23128	>	}
23129	>	if (argc == 6) {
23130	>	int _v;
23131	>	void *vptr = 0;
23132	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23133	>	_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	>	}
23154		}
23155	+	}
23156		}
23157	<	if (obj7) {
23158	<	{
23159	<	if (PyString_Check(obj7))
23160	<	arg8 = std::string(PyString_AsString(obj7));
23161	<	else
23162	<	SWIG_exception(SWIG_TypeError, "string expected");
23157	>	}
23158	>	if (argc == 7) {
23159	>	int _v;
23160	>	void *vptr = 0;
23161	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23162	>	_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	>	}
23187		}
23188	+	}
23189		}
23190	<	if (obj8) {
23191	<	{
23192	<	if (PyString_Check(obj8))
23193	<	arg9 = std::string(PyString_AsString(obj8));
23194	<	else
23195	<	SWIG_exception(SWIG_TypeError, "string expected");
23190	>	}
23191	>	if (argc == 8) {
23192	>	int _v;
23193	>	void *vptr = 0;
23194	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23195	>	_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	>	}
23224		}
23225	+	}
23226		}
23227	<	if (obj9) {
23228	<	{
23229	<	if (PyString_Check(obj9))
23230	<	arg10 = std::string(PyString_AsString(obj9));
23231	<	else
23232	<	SWIG_exception(SWIG_TypeError, "string expected");
23227	>	}
23228	>	if (argc == 9) {
23229	>	int _v;
23230	>	void *vptr = 0;
23231	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23232	>	_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	>	}
23265		}
23266	+	}
23267		}
23268	<	if (obj10) {
23269	<	{
23270	<	if (PyString_Check(obj10)) {
23271	<	temp11 = std::string(PyString_AsString(obj10));
23272	<	arg11 = &temp11;
23273	<	}else {
23274	<	SWIG_exception(SWIG_TypeError, "string expected");
23268	>	}
23269	>	if (argc == 10) {
23270	>	int _v;
23271	>	void *vptr = 0;
23272	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23273	>	_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	+	}
23310		}
23311	+	}
23312		}
23313	<	if (obj11) {
23314	<	{
23315	<	if (PyString_Check(obj11))
23316	<	arg12 = std::string(PyString_AsString(obj11));
23317	<	else
23318	<	SWIG_exception(SWIG_TypeError, "string expected");
23313	>	}
23314	>	if (argc == 11) {
23315	>	int _v;
23316	>	void *vptr = 0;
23317	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23318	>	_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	>	}
23359		}
23360	+	}
23361		}
23362	<	if (obj12) {
23363	<	{
23364	<	if (PyString_Check(obj12))
23365	<	arg13 = std::string(PyString_AsString(obj12));
23366	<	else
23367	<	SWIG_exception(SWIG_TypeError, "string expected");
23362	>	}
23363	>	if (argc == 12) {
23364	>	int _v;
23365	>	void *vptr = 0;
23366	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23367	>	_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	>	}
23412		}
23413	+	}
23414		}
23415	<	if (obj13) {
23416	<	arg14 = PyInt_AsLong(obj13) ? true : false;
23417	<	if (PyErr_Occurred()) SWIG_fail;
23415	>	}
23416	>	if (argc == 13) {
23417	>	int _v;
23418	>	void *vptr = 0;
23419	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23420	>	_v = SWIG_CheckState(res);
23421	>	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	>	}
23467	>	}
23468	>	}
23469	>	}
23470	>	}
23471		}
23472	<	if (obj14) {
23473	<	arg15 = PyInt_AsLong(obj14) ? true : false;
23474	<	if (PyErr_Occurred()) SWIG_fail;
23472	>	}
23473	>	if (argc == 14) {
23474	>	int _v;
23475	>	void *vptr = 0;
23476	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23477	>	_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	>	}
23532	>	}
23533	>	}
23534		}
23535	<	{
23536	<	try {
23537	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
23538	<
23539	<	}catch (const std::exception& e) {
23540	<	SWIG_exception(SWIG_RuntimeError, e.what());
23535	>	}
23536	>	if (argc == 15) {
23537	>	int _v;
23538	>	void *vptr = 0;
23539	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23540	>	_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	>	}
23601		}
23602	+	}
23603		}
23604	<	resultobj = PyInt_FromLong((long)result);
23605	<	return resultobj;
23606	<	fail:
23607	<	return NULL;
23604	>	}
23605	>
23606	>	fail:
23607	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_registerScheduler'");
23608	>	return NULL;
23609		}
23610
23611
23612	<	static PyObject *_wrap_BossAdministratorSession_help(PyObject *self, PyObject *args) {
23613	<	PyObject *resultobj;
23614	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
23615	<	std::string result;
23616	<	PyObject * obj0 = 0 ;
23617	<
23618	<	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_help",&obj0)) goto fail;
23619	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
23620	<	{
23621	<	try {
23622	<	result = (arg1)->help();
23623	<
23624	<	}catch (const std::exception& e) {
23625	<	SWIG_exception(SWIG_RuntimeError, e.what());
23626	<	}
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());
23631		}
23632	<	{
23633	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
23632	>	}
23633	>	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
23634	>	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""'");
23665		}
23666	<	return resultobj;
23667	<	fail:
23668	<	return NULL;
23666	>	arg2 = *ptr;
23667	>	if (SWIG_IsNewObj(res)) delete ptr;
23668	>	}
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());
23679	>	}
23680	>	}
23681	>	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
23682	>	return resultobj;
23683	>	fail:
23684	>	return NULL;
23685		}
23686
23687
23688	<	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
23689	<	PyObject *resultobj;
23690	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
23691	<	std::string arg2 ;
23692	<	bool arg3 = (bool) false ;
23693	<	std::string result;
23694	<	PyObject * obj0 = 0 ;
23695	<	PyObject * obj1 = 0 ;
23696	<	PyObject * obj2 = 0 ;
23697	<
23698	<	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
23699	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
23700	<	{
23701	<	if (PyString_Check(obj1))
23702	<	arg2 = std::string(PyString_AsString(obj1));
23703	<	else
23704	<	SWIG_exception(SWIG_TypeError, "string expected");
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""'");
23709		}
23710	<	if (obj2) {
23711	<	arg3 = PyInt_AsLong(obj2) ? true : false;
23712	<	if (PyErr_Occurred()) SWIG_fail;
23710	>	arg2 = *ptr;
23711	>	if (SWIG_IsNewObj(res)) delete ptr;
23712	>	}
23713	>	{
23714	>	try {
23715	>	result = (arg1)->SQL(arg2);
23716	>	} catch (const std::exception& e) {
23717	>	SWIG_exception(SWIG_RuntimeError, e.what());
23718		}
23719	<	{
23720	<	try {
23721	<	result = (arg1)->SQL(arg2,arg3);
23722	<
23723	<	}catch (const std::exception& e) {
23724	<	SWIG_exception(SWIG_RuntimeError, e.what());
23719	>	}
23720	>	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
23721	>	return resultobj;
23722	>	fail:
23723	>	return NULL;
23724	>	}
23725	>
23726	>
23727	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
23728	>	int argc;
23729	>	PyObject *argv[4];
23730	>	int ii;
23731	>
23732	>	if (!PyTuple_Check(args)) SWIG_fail;
23733	>	argc = PyObject_Length(args);
23734	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
23735	>	argv[ii] = PyTuple_GET_ITEM(args,ii);
23736	>	}
23737	>	if (argc == 2) {
23738	>	int _v;
23739	>	void *vptr = 0;
23740	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23741	>	_v = SWIG_CheckState(res);
23742	>	if (_v) {
23743	>	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
23744	>	_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);
23765		}
23766	+	}
23767		}
23768	<	{
23769	<	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
23768	>	}
23769	>
23770	>	fail:
23771	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_SQL'");
23772	>	return NULL;
23773	>	}
23774	>
23775	>
23776	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_purge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23777	>	PyObject *resultobj = 0;
23778	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
23779	>	std::string *arg2 = 0 ;
23780	>	std::string *arg3 = 0 ;
23781	>	std::string *arg4 = 0 ;
23782	>	std::string *arg5 = 0 ;
23783	>	int result;
23784	>	void *argp1 = 0 ;
23785	>	int res1 = 0 ;
23786	>	int res2 = SWIG_OLDOBJ ;
23787	>	int res3 = SWIG_OLDOBJ ;
23788	>	int res4 = SWIG_OLDOBJ ;
23789	>	int res5 = SWIG_OLDOBJ ;
23790	>	PyObject * obj0 = 0 ;
23791	>	PyObject * obj1 = 0 ;
23792	>	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	<	return resultobj;
23809	<	fail:
23810	<	return NULL;
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 &""'");
23832	>	}
23833	>	arg4 = ptr;
23834	>	}
23835	>	{
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 &""'");
23840	>	}
23841	>	if (!ptr) {
23842	>	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "5"" of type '" "std::string const &""'");
23843	>	}
23844	>	arg5 = ptr;
23845	>	}
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());
23851	>	}
23852	>	}
23853	>	resultobj = SWIG_From_int(static_cast< int >(result));
23854	>	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;
23865		}
23866
23867
23868	<	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
23869	<	PyObject *resultobj;
23870	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
23871	<	std::string *arg2 = 0 ;
23872	<	std::string *arg3 = 0 ;
23873	<	std::string *arg4 = 0 ;
23874	<	std::string const &arg5_defvalue = "0" ;
23875	<	std::string *arg5 = (std::string *) &arg5_defvalue ;
23876	<	int result;
23877	<	std::string temp2 ;
23878	<	std::string temp3 ;
23879	<	std::string temp4 ;
23880	<	std::string temp5 ;
23881	<	PyObject * obj0 = 0 ;
23882	<	PyObject * obj1 = 0 ;
23883	<	PyObject * obj2 = 0 ;
23884	<	PyObject * obj3 = 0 ;
23885	<	PyObject * obj4 = 0 ;
23886	<
23887	<	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
23888	<	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
23889	<	{
23890	<	if (PyString_Check(obj1)) {
23891	<	temp2 = std::string(PyString_AsString(obj1));
23892	<	arg2 = &temp2;
23893	<	}else {
23894	<	SWIG_exception(SWIG_TypeError, "string expected");
23895	<	}
23868	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_purge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869	>	PyObject *resultobj = 0;
23870	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
23871	>	std::string *arg2 = 0 ;
23872	>	std::string *arg3 = 0 ;
23873	>	std::string *arg4 = 0 ;
23874	>	int result;
23875	>	void *argp1 = 0 ;
23876	>	int res1 = 0 ;
23877	>	int res2 = SWIG_OLDOBJ ;
23878	>	int res3 = SWIG_OLDOBJ ;
23879	>	int res4 = SWIG_OLDOBJ ;
23880	>	PyObject * obj0 = 0 ;
23881	>	PyObject * obj1 = 0 ;
23882	>	PyObject * obj2 = 0 ;
23883	>	PyObject * obj3 = 0 ;
23884	>
23885	>	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23886	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
23887	>	if (!SWIG_IsOK(res1)) {
23888	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_purge" "', argument " "1"" of type '" "BossAdministratorSession *""'");
23889	>	}
23890	>	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
23891	>	{
23892	>	std::string *ptr = (std::string *)0;
23893	>	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
23894	>	if (!SWIG_IsOK(res2)) {
23895	>	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_purge" "', argument " "2"" of type '" "std::string const &""'");
23896		}
23897	<	{
23898	<	if (PyString_Check(obj2)) {
5191	<	temp3 = std::string(PyString_AsString(obj2));
5192	<	arg3 = &temp3;
5193	<	}else {
5194	<	SWIG_exception(SWIG_TypeError, "string expected");
5195	<	}
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	<	{
23901	<	if (PyString_Check(obj3)) {
23902	<	temp4 = std::string(PyString_AsString(obj3));
23903	<	arg4 = &temp4;
23904	<	}else {
23905	<	SWIG_exception(SWIG_TypeError, "string expected");
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 &""'");
23921	>	}
23922	>	arg4 = ptr;
23923	>	}
23924	>	{
23925	>	try {
23926	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
23927	>	} catch (const std::exception& e) {
23928	>	SWIG_exception(SWIG_RuntimeError, e.what());
23929	>	}
23930	>	}
23931	>	resultobj = SWIG_From_int(static_cast< int >(result));
23932	>	if (SWIG_IsNewObj(res2)) delete arg2;
23933	>	if (SWIG_IsNewObj(res3)) delete arg3;
23934	>	if (SWIG_IsNewObj(res4)) delete arg4;
23935	>	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	>	}
23971		}
23972	+	}
23973		}
23974	<	if (obj4) {
23975	<	{
23976	<	if (PyString_Check(obj4)) {
23977	<	temp5 = std::string(PyString_AsString(obj4));
23978	<	arg5 = &temp5;
23979	<	}else {
23980	<	SWIG_exception(SWIG_TypeError, "string expected");
23974	>	}
23975	>	if (argc == 5) {
23976	>	int _v;
23977	>	void *vptr = 0;
23978	>	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
23979	>	_v = SWIG_CheckState(res);
23980	>	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);
23994		}
23995	+	}
23996		}
23997	+	}
23998		}
23999	<	{
24000	<	try {
24001	<	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
24002	<
24003	<	}catch (const std::exception& e) {
24004	<	SWIG_exception(SWIG_RuntimeError, e.what());
24005	<	}
23999	>	}
24000	>
24001	>	fail:
24002	>	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_purge'");
24003	>	return NULL;
24004	>	}
24005	>
24006	>
24007	>	SWIGINTERN PyObject *_wrap_BossAdministratorSession_configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24008	>	PyObject *resultobj = 0;
24009	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
24010	>	std::string arg2 ;
24011	>	int result;
24012	>	void *argp1 = 0 ;
24013	>	int res1 = 0 ;
24014	>	PyObject * obj0 = 0 ;
24015	>	PyObject * obj1 = 0 ;
24016	>
24017	>	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configure",&obj0,&obj1)) SWIG_fail;
24018	>	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
24019	>	if (!SWIG_IsOK(res1)) {
24020	>	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_configure" "', argument " "1"" of type '" "BossAdministratorSession *""'");
24021	>	}
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""'");
24028		}
24029	<	resultobj = PyInt_FromLong((long)result);
24030	<	return resultobj;
24031	<	fail:
24032	<	return NULL;
24029	>	arg2 = *ptr;
24030	>	if (SWIG_IsNewObj(res)) delete ptr;
24031	>	}
24032	>	{
24033	>	try {
24034	>	result = (int)(arg1)->configure(arg2);
24035	>	} catch (const std::exception& e) {
24036	>	SWIG_exception(SWIG_RuntimeError, e.what());
24037	>	}
24038	>	}
24039	>	resultobj = SWIG_From_int(static_cast< int >(result));
24040	>	return resultobj;
24041	>	fail:
24042	>	return NULL;
24043		}
24044
24045
24046	<	static PyObject * BossAdministratorSession_swigregister(PyObject *self, PyObject *args) {
24047	<	PyObject *obj;
24048	<	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24049	<	SWIG_TypeClientData(SWIGTYPE_p_BossAdministratorSession, obj);
24050	<	Py_INCREF(obj);
5235	<	return Py_BuildValue((char *)"");
24046	>	SWIGINTERN PyObject *BossAdministratorSession_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24047	>	PyObject *obj;
24048	>	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
24049	>	SWIG_TypeNewClientData(SWIGTYPE_p_BossAdministratorSession, SWIG_NewClientData(obj));
24050	>	return SWIG_Py_Void();
24051		}
24052	+
24053		static PyMethodDef SwigMethods[] = {
24054	<	{ (char *)"new_objectMap", _wrap_new_objectMap, METH_VARARGS },
24055	<	{ (char *)"objectMap___len__", _wrap_objectMap___len__, METH_VARARGS },
24056	<	{ (char *)"objectMap_clear", _wrap_objectMap_clear, METH_VARARGS },
24057	<	{ (char *)"objectMap___nonzero__", _wrap_objectMap___nonzero__, METH_VARARGS },
24058	<	{ (char *)"objectMap___getitem__", _wrap_objectMap___getitem__, METH_VARARGS },
24059	<	{ (char *)"objectMap___setitem__", _wrap_objectMap___setitem__, METH_VARARGS },
24060	<	{ (char *)"objectMap___delitem__", _wrap_objectMap___delitem__, METH_VARARGS },
24061	<	{ (char *)"objectMap_has_key", _wrap_objectMap_has_key, METH_VARARGS },
24062	<	{ (char *)"objectMap_keys", _wrap_objectMap_keys, METH_VARARGS },
24063	<	{ (char *)"objectMap_values", _wrap_objectMap_values, METH_VARARGS },
24064	<	{ (char *)"objectMap_items", _wrap_objectMap_items, METH_VARARGS },
24065	<	{ (char *)"objectMap___contains__", _wrap_objectMap___contains__, METH_VARARGS },
24066	<	{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
24067	<	{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
24068	<	{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
24069	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
24070	<	{ (char *)"BossSession_showCHTools", _wrap_BossSession_showCHTools, METH_VARARGS },
24071	<	{ (char *)"BossSession_showProgramTypes", _wrap_BossSession_showProgramTypes, METH_VARARGS },
24072	<	{ (char *)"BossSession_showRTMon", _wrap_BossSession_showRTMon, METH_VARARGS },
24073	<	{ (char *)"BossSession_showSchedulers", _wrap_BossSession_showSchedulers, METH_VARARGS },
24074	<	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
24075	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
24076	<	{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
24077	<	{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
24078	<	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
24079	<	{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
24080	<	{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
24081	<	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
24082	<	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
24083	<	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
24084	<	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS },
24085	<	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
24086	<	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
24087	<	{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
24088	<	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
24089	<	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
24090	<	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
24091	<	{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
24092	<	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
24093	<	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
24094	<	{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
24095	<	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
24096	<	{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
24097	<	{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
24098	<	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
24099	<	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
24100	<	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
24101	<	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
24102	<	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
24103	<	{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
24104	<	{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
24105	<	{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
24106	<	{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
24107	<	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
24108	<	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
24109	<	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
24110	<	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
24111	<	{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
24112	<	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
24113	<	{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
24114	<	{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
24115	<	{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
24116	<	{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
24117	<	{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
24118	<	{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
24119	<	{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
24120	<	{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
24121	<	{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
24122	<	{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
24123	<	{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
24124	<	{ (char *)"prompt", _wrap_prompt, METH_VARARGS },
24125	<	{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
24126	<	{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
24127	<	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
24128	<	{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
24129	<	{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
24130	<	{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
24131	<	{ (char *)"BossAdministratorSession_deleteRTMon", _wrap_BossAdministratorSession_deleteRTMon, METH_VARARGS },
24132	<	{ (char *)"BossAdministratorSession_deleteScheduler", _wrap_BossAdministratorSession_deleteScheduler, METH_VARARGS },
24133	<	{ (char *)"BossAdministratorSession_registerCHTool", _wrap_BossAdministratorSession_registerCHTool, METH_VARARGS },
24134	<	{ (char *)"BossAdministratorSession_registerProgram", _wrap_BossAdministratorSession_registerProgram, METH_VARARGS },
24135	<	{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
24136	<	{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
24137	<	{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
24138	<	{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
24139	<	{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
24140	<	{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
24141	<	{ NULL, NULL }
24054	>	{ (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
24055	>	{ (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
24056	>	{ (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
24057	>	{ (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
24058	>	{ (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
24059	>	{ (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
24060	>	{ (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
24061	>	{ (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
24062	>	{ (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
24063	>	{ (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
24064	>	{ (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
24065	>	{ (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
24066	>	{ (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
24067	>	{ (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
24068	>	{ (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
24069	>	{ (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
24070	>	{ (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
24071	>	{ (char *)"objectMap_iterator", _wrap_objectMap_iterator, METH_VARARGS, NULL},
24072	>	{ (char *)"objectMap___nonzero__", _wrap_objectMap___nonzero__, METH_VARARGS, NULL},
24073	>	{ (char *)"objectMap___len__", _wrap_objectMap___len__, METH_VARARGS, NULL},
24074	>	{ (char *)"objectMap___getitem__", _wrap_objectMap___getitem__, METH_VARARGS, NULL},
24075	>	{ (char *)"objectMap___setitem__", _wrap_objectMap___setitem__, METH_VARARGS, NULL},
24076	>	{ (char *)"objectMap___delitem__", _wrap_objectMap___delitem__, METH_VARARGS, NULL},
24077	>	{ (char *)"objectMap_has_key", _wrap_objectMap_has_key, METH_VARARGS, NULL},
24078	>	{ (char *)"objectMap_keys", _wrap_objectMap_keys, METH_VARARGS, NULL},
24079	>	{ (char *)"objectMap_values", _wrap_objectMap_values, METH_VARARGS, NULL},
24080	>	{ (char *)"objectMap_items", _wrap_objectMap_items, METH_VARARGS, NULL},
24081	>	{ (char *)"objectMap___contains__", _wrap_objectMap___contains__, METH_VARARGS, NULL},
24082	>	{ (char *)"objectMap_key_iterator", _wrap_objectMap_key_iterator, METH_VARARGS, NULL},
24083	>	{ (char *)"objectMap_value_iterator", _wrap_objectMap_value_iterator, METH_VARARGS, NULL},
24084	>	{ (char *)"new_objectMap", _wrap_new_objectMap, METH_VARARGS, NULL},
24085	>	{ (char *)"objectMap_empty", _wrap_objectMap_empty, METH_VARARGS, NULL},
24086	>	{ (char *)"objectMap_size", _wrap_objectMap_size, METH_VARARGS, NULL},
24087	>	{ (char *)"objectMap_clear", _wrap_objectMap_clear, METH_VARARGS, NULL},
24088	>	{ (char *)"objectMap_swap", _wrap_objectMap_swap, METH_VARARGS, NULL},
24089	>	{ (char *)"objectMap_get_allocator", _wrap_objectMap_get_allocator, METH_VARARGS, NULL},
24090	>	{ (char *)"objectMap_begin", _wrap_objectMap_begin, METH_VARARGS, NULL},
24091	>	{ (char *)"objectMap_end", _wrap_objectMap_end, METH_VARARGS, NULL},
24092	>	{ (char *)"objectMap_rbegin", _wrap_objectMap_rbegin, METH_VARARGS, NULL},
24093	>	{ (char *)"objectMap_rend", _wrap_objectMap_rend, METH_VARARGS, NULL},
24094	>	{ (char *)"objectMap_count", _wrap_objectMap_count, METH_VARARGS, NULL},
24095	>	{ (char *)"objectMap_erase", _wrap_objectMap_erase, METH_VARARGS, NULL},
24096	>	{ (char *)"objectMap_find", _wrap_objectMap_find, METH_VARARGS, NULL},
24097	>	{ (char *)"objectMap_lower_bound", _wrap_objectMap_lower_bound, METH_VARARGS, NULL},
24098	>	{ (char *)"objectMap_upper_bound", _wrap_objectMap_upper_bound, METH_VARARGS, NULL},
24099	>	{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS, NULL},
24100	>	{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS, NULL},
24101	>	{ (char *)"vector_string_iterator", _wrap_vector_string_iterator, METH_VARARGS, NULL},
24102	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS, NULL},
24103	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS, NULL},
24104	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS, NULL},
24105	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS, NULL},
24106	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS, NULL},
24107	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS, NULL},
24108	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS, NULL},
24109	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS, NULL},
24110	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS, NULL},
24111	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS, NULL},
24112	>	{ (char *)"vector_string_empty", _wrap_vector_string_empty, METH_VARARGS, NULL},
24113	>	{ (char *)"vector_string_size", _wrap_vector_string_size, METH_VARARGS, NULL},
24114	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS, NULL},
24115	>	{ (char *)"vector_string_swap", _wrap_vector_string_swap, METH_VARARGS, NULL},
24116	>	{ (char *)"vector_string_get_allocator", _wrap_vector_string_get_allocator, METH_VARARGS, NULL},
24117	>	{ (char *)"vector_string_begin", _wrap_vector_string_begin, METH_VARARGS, NULL},
24118	>	{ (char *)"vector_string_end", _wrap_vector_string_end, METH_VARARGS, NULL},
24119	>	{ (char *)"vector_string_rbegin", _wrap_vector_string_rbegin, METH_VARARGS, NULL},
24120	>	{ (char *)"vector_string_rend", _wrap_vector_string_rend, METH_VARARGS, NULL},
24121	>	{ (char *)"vector_string_pop_back", _wrap_vector_string_pop_back, METH_VARARGS, NULL},
24122	>	{ (char *)"vector_string_erase", _wrap_vector_string_erase, METH_VARARGS, NULL},
24123	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS, NULL},
24124	>	{ (char *)"vector_string_push_back", _wrap_vector_string_push_back, METH_VARARGS, NULL},
24125	>	{ (char *)"vector_string_front", _wrap_vector_string_front, METH_VARARGS, NULL},
24126	>	{ (char *)"vector_string_back", _wrap_vector_string_back, METH_VARARGS, NULL},
24127	>	{ (char *)"vector_string_assign", _wrap_vector_string_assign, METH_VARARGS, NULL},
24128	>	{ (char *)"vector_string_resize", _wrap_vector_string_resize, METH_VARARGS, NULL},
24129	>	{ (char *)"vector_string_insert", _wrap_vector_string_insert, METH_VARARGS, NULL},
24130	>	{ (char *)"vector_string_reserve", _wrap_vector_string_reserve, METH_VARARGS, NULL},
24131	>	{ (char *)"vector_string_capacity", _wrap_vector_string_capacity, METH_VARARGS, NULL},
24132	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS, NULL},
24133	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS, NULL},
24134	>	{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS, NULL},
24135	>	{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS, NULL},
24136	>	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS, NULL},
24137	>	{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS, NULL},
24138	>	{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS, NULL},
24139	>	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS, NULL},
24140	>	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS, NULL},
24141	>	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS, NULL},
24142	>	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS, NULL},
24143	>	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS, NULL},
24144	>	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS, NULL},
24145	>	{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS, NULL},
24146	>	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS, NULL},
24147	>	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS, NULL},
24148	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS, NULL},
24149	>	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS, NULL},
24150	>	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS, NULL},
24151	>	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS, NULL},
24152	>	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS, NULL},
24153	>	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS, NULL},
24154	>	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS, NULL},
24155	>	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS, NULL},
24156	>	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS, NULL},
24157	>	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS, NULL},
24158	>	{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS, NULL},
24159	>	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS, NULL},
24160	>	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS, NULL},
24161	>	{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS, NULL},
24162	>	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS, NULL},
24163	>	{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS, NULL},
24164	>	{ (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 }
24212		};
24213
24214
24215		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
24216
24217	<	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
24218	<	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}};
24219	<	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}};
24220	<	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}};
24221	<	static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
24222	<	static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
24223	<	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
24224	<	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
24225	<	static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
24226	<	static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
24227	<	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
24228	<	static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
24229	<	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}};
24230	<	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}};
24231	<	static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
24232	<	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}};
24233	<	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}};
24234	<	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
24235	<
24236	<	static swig_type_info *swig_types_initial[] = {
24237	<	_swigt__p_XMLDoc,
24238	<	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
24239	<	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
24240	<	_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
24241	<	_swigt__p_BossTask,
24242	<	_swigt__p_BossTaskException,
24243	<	_swigt__p_std__ostream,
24244	<	_swigt__p_BossAttributeContainer,
24245	<	_swigt__p_printOption,
24246	<	_swigt__p_BossJob,
24247	<	_swigt__p_BossDatabase,
24248	<	_swigt__p_BossSession,
24249	<	_swigt__p_std__vectorTstd__string_t,
24250	<	_swigt__p_std__mapTstd__string_std__string_t,
24251	<	_swigt__p_BossAdministratorSession,
24252	<	_swigt__p_BossTask__job_iterator,
24253	<	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
24254	<	_swigt__p_jobStates,
24255	<	0
24217	>	static void *_p_BossTaskExceptionTo_p_std__exception(void *x) {
24218	>	return (void *)((std::exception *)  ((BossTaskException *) x));
24219	>	}
24220	>	static swig_type_info _swigt__p_BossAdministratorSession = {"_p_BossAdministratorSession", "BossAdministratorSession *", 0, 0, (void*)0, 0};
24221	>	static swig_type_info _swigt__p_BossAttributeContainer = {"_p_BossAttributeContainer", "BossAttributeContainer *", 0, 0, (void*)0, 0};
24222	>	static swig_type_info _swigt__p_BossDatabase = {"_p_BossDatabase", "BossDatabase *", 0, 0, (void*)0, 0};
24223	>	static swig_type_info _swigt__p_BossJob = {"_p_BossJob", "BossJob *", 0, 0, (void*)0, 0};
24224	>	static swig_type_info _swigt__p_BossSession = {"_p_BossSession", "BossSession *", 0, 0, (void*)0, 0};
24225	>	static swig_type_info _swigt__p_BossTask = {"_p_BossTask", "BossTask *", 0, 0, (void*)0, 0};
24226	>	static swig_type_info _swigt__p_BossTaskException = {"_p_BossTaskException", "BossTaskException *", 0, 0, (void*)0, 0};
24227	>	static swig_type_info _swigt__p_XMLDoc = {"_p_XMLDoc", "XMLDoc *", 0, 0, (void*)0, 0};
24228	>	static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
24229	>	static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
24230	>	static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
24231	>	static swig_type_info _swigt__p_job_iterator = {"_p_job_iterator", "job_iterator *", 0, 0, (void*)0, 0};
24232	>	static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
24233	>	static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
24234	>	static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
24235	>	static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
24236	>	static swig_type_info _swigt__p_std__exception = {"_p_std__exception", "std::exception *", 0, 0, (void*)0, 0};
24237	>	static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
24238	>	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};
24239	>	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};
24240	>	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};
24241	>	static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
24242	>	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};
24243	>	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};
24244	>	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};
24245	>	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};
24246	>	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};
24247	>	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};
24248	>	static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
24249	>	static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
24250	>
24251	>	static swig_type_info *swig_type_initial[] = {
24252	>	&_swigt__p_BossAdministratorSession,
24253	>	&_swigt__p_BossAttributeContainer,
24254	>	&_swigt__p_BossDatabase,
24255	>	&_swigt__p_BossJob,
24256	>	&_swigt__p_BossSession,
24257	>	&_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,
24346		};
24347
24348
24349		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
24350
24351		static swig_const_info swig_const_table[] = {
24352	<	{ SWIG_PY_INT,     (char *)"RUNNING", (long) RUNNING, 0, 0, 0},
5377	<	{ SWIG_PY_INT,     (char *)"SCHEDULED", (long) SCHEDULED, 0, 0, 0},
5378	<	{ SWIG_PY_INT,     (char *)"SUBMITTED", (long) SUBMITTED, 0, 0, 0},
5379	<	{ SWIG_PY_INT,     (char *)"ALL", (long) ALL, 0, 0, 0},
5380	<	{ SWIG_PY_INT,     (char *)"STATUS_ONLY", (long) STATUS_ONLY, 0, 0, 0},
5381	<	{ SWIG_PY_INT,     (char *)"NORMAL", (long) NORMAL, 0, 0, 0},
5382	<	{ SWIG_PY_INT,     (char *)"SPECIFIC", (long) SPECIFIC, 0, 0, 0},
5383	<	{ SWIG_PY_INT,     (char *)"PROGRAMS", (long) PROGRAMS, 0, 0, 0},
5384	<	{ SWIG_PY_INT,     (char *)"FULL", (long) FULL, 0, 0, 0},
5385	<	{0}};
24352	>	{0, 0, 0, 0.0, 0, 0}};
24353
24354		#ifdef __cplusplus
24355		}
24356		#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	+	* ----------------------------------------------------------------------------- */
24397
24398		#ifdef __cplusplus
24399	<	extern "C"
24399	>	extern "C" {
24400	>	#if 0
24401	>	} /* c-mode */
24402		#endif
24403	<	SWIGEXPORT(void) SWIG_init(void) {
24404	<	static PyObject *SWIG_globals = 0;
24405	<	static int       typeinit = 0;
24406	<	PyObject *m, *d;
24407	<	int       i;
24408	<	if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
24409	<	m = Py_InitModule((char *) SWIG_name, SwigMethods);
24410	<	d = PyModule_GetDict(m);
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	<	if (!typeinit) {
24445	<	for (i = 0; swig_types_initial[i]; i++) {
24446	<	swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
24447	<	}
24448	<	typeinit = 1;
24444	>	#ifdef SWIGRUNTIME_DEBUG
24445	>	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
24446	>	#endif
24447	>
24448	>	/* if there is another module already loaded */
24449	>	if (swig_module.next != &swig_module) {
24450	>	type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
24451	>	}
24452	>	if (type) {
24453	>	/* Overwrite clientdata field */
24454	>	#ifdef SWIGRUNTIME_DEBUG
24455	>	printf("SWIG_InitializeModule: found type %s\n", type->name);
24456	>	#endif
24457	>	if (swig_module.type_initial[i]->clientdata) {
24458	>	type->clientdata = swig_module.type_initial[i]->clientdata;
24459	>	#ifdef SWIGRUNTIME_DEBUG
24460	>	printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
24461	>	#endif
24462	>	}
24463	>	} else {
24464	>	type = swig_module.type_initial[i];
24465		}
5409	–	SWIG_InstallConstants(d,swig_const_table);
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	+	}
24820	+	}
24821	+	}
24822	+	}
24823	+	}
24824	+
24825	+	#ifdef __cplusplus
24826	+	}
24827	+	#endif
24828	+
24829	+	/* -----------------------------------------------------------------------------*
24830	+	*  Partial Init method
24831	+	* -----------------------------------------------------------------------------*/
24832	+
24833	+	#ifdef __cplusplus
24834	+	extern "C"
24835	+	#endif
24836	+	SWIGEXPORT void SWIG_init(void) {
24837	+	PyObject *m, *d;
24838	+
24839	+	/* Fix SwigMethods to carry the callback ptrs when needed */
24840	+	SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
24841	+
24842	+	m = Py_InitModule((char *) SWIG_name, SwigMethods);
24843	+	d = PyModule_GetDict(m);
24844	+
24845	+	SWIG_InitializeModule(0);
24846	+	SWIG_InstallConstants(d,swig_const_table);
24847	+
24848	+
24849	+	SWIG_Python_SetConstant(d, "RUNNING",SWIG_From_int(static_cast< int >(RUNNING)));
24850	+	SWIG_Python_SetConstant(d, "SCHEDULED",SWIG_From_int(static_cast< int >(SCHEDULED)));
24851	+	SWIG_Python_SetConstant(d, "SUBMITTED",SWIG_From_int(static_cast< int >(SUBMITTED)));
24852	+	SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(ALL)));
24853	+	SWIG_Python_SetConstant(d, "STATUS_ONLY",SWIG_From_int(static_cast< int >(STATUS_ONLY)));
24854	+	SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(NORMAL)));
24855	+	SWIG_Python_SetConstant(d, "SPECIFIC",SWIG_From_int(static_cast< int >(SPECIFIC)));
24856	+	SWIG_Python_SetConstant(d, "PROGRAMS",SWIG_From_int(static_cast< int >(PROGRAMS)));
24857	+	SWIG_Python_SetConstant(d, "FULL",SWIG_From_int(static_cast< int >(FULL)));
24858		}
24859

Diff Legend

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