ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing COMP/BOSS/BossPython/BossSession_wrap.cxx (file contents):
Revision 1.9 by gcodispo, Mon Oct 30 10:44:38 2006 UTC vs.
Revision 1.11 by gcodispo, Mon Oct 30 14:00:27 2006 UTC

#	Line 1 | Line 1
1		/* ----------------------------------------------------------------------------
2		* This file was automatically generated by SWIG (http://www.swig.org).
3	<	* Version 1.3.29
3	>	* Version 1.3.19
4		*
5		* This file is not intended to be easily readable and contains a number of
6		* coding conventions designed to improve portability and efficiency. Do not make
#	Line 9 | Line 9
9		* ----------------------------------------------------------------------------- */
10
11		#define SWIGPYTHON
12	–	#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
12
13		#ifdef __cplusplus
14		template<class T> class SwigValueWrapper {
15		T *tt;
16		public:
17	<	SwigValueWrapper() : tt(0) { }
18	<	SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19	<	SwigValueWrapper(const T& t) : tt(new T(t)) { }
20	<	~SwigValueWrapper() { delete tt; }
21	<	SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22	<	operator T&() const { return *tt; }
24	<	T *operator&() { return tt; }
25	<	private:
26	<	SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27	<	};
28	<	#endif
29	<
30	<	/* -----------------------------------------------------------------------------
31	<	*  This section contains generic SWIG labels for method/variable
32	<	*  declarations/attributes, and other compiler dependent labels.
33	<	* ----------------------------------------------------------------------------- */
34	<
35	<	/* template workaround for compilers that cannot correctly implement the C++ standard */
36	<	#ifndef SWIGTEMPLATEDISAMBIGUATOR
37	<	# if defined(__SUNPRO_CC)
38	<	#   if (__SUNPRO_CC <= 0x560)
39	<	#     define SWIGTEMPLATEDISAMBIGUATOR template
40	<	#   else
41	<	#     define SWIGTEMPLATEDISAMBIGUATOR
42	<	#   endif
43	<	# else
44	<	#   define SWIGTEMPLATEDISAMBIGUATOR
45	<	# endif
46	<	#endif
47	<
48	<	/* inline attribute */
49	<	#ifndef SWIGINLINE
50	<	# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51	<	#   define SWIGINLINE inline
52	<	# else
53	<	#   define SWIGINLINE
54	<	# endif
55	<	#endif
56	<
57	<	/* attribute recognised by some compilers to avoid 'unused' warnings */
58	<	#ifndef SWIGUNUSED
59	<	# if defined(__GNUC__)
60	<	#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61	<	#     define SWIGUNUSED __attribute__ ((__unused__))
62	<	#   else
63	<	#     define SWIGUNUSED
64	<	#   endif
65	<	# elif defined(__ICC)
66	<	#   define SWIGUNUSED __attribute__ ((__unused__))
67	<	# else
68	<	#   define SWIGUNUSED
69	<	# endif
70	<	#endif
71	<
72	<	#ifndef SWIGUNUSEDPARM
73	<	# ifdef __cplusplus
74	<	#   define SWIGUNUSEDPARM(p)
75	<	# else
76	<	#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
77	<	# endif
78	<	#endif
79	<
80	<	/* internal SWIG method */
81	<	#ifndef SWIGINTERN
82	<	# define SWIGINTERN static SWIGUNUSED
17	>	inline SwigValueWrapper() : tt(0) { }
18	>	inline ~SwigValueWrapper() { if (tt) delete tt; }
19	>	inline SwigValueWrapper& operator=(const T& t) { tt = new T(t); return *this; }
20	>	inline operator T&() const { return *tt; }
21	>	inline T *operator&() { return tt; }
22	>	};
23		#endif
24
85	–	/* internal inline SWIG method */
86	–	#ifndef SWIGINTERNINLINE
87	–	# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88	–	#endif
89	–
90	–	/* exporting methods */
91	–	#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92	–	#  ifndef GCC_HASCLASSVISIBILITY
93	–	#    define GCC_HASCLASSVISIBILITY
94	–	#  endif
95	–	#endif
96	–
97	–	#ifndef SWIGEXPORT
98	–	# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99	–	#   if defined(STATIC_LINKED)
100	–	#     define SWIGEXPORT
101	–	#   else
102	–	#     define SWIGEXPORT __declspec(dllexport)
103	–	#   endif
104	–	# else
105	–	#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106	–	#     define SWIGEXPORT __attribute__ ((visibility("default")))
107	–	#   else
108	–	#     define SWIGEXPORT
109	–	#   endif
110	–	# endif
111	–	#endif
112	–
113	–	/* calling conventions for Windows */
114	–	#ifndef SWIGSTDCALL
115	–	# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116	–	#   define SWIGSTDCALL __stdcall
117	–	# else
118	–	#   define SWIGSTDCALL
119	–	# endif
120	–	#endif
121	–
122	–	/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123	–	#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124	–	# define _CRT_SECURE_NO_DEPRECATE
125	–	#endif
25
26	+	#include "Python.h"
27
28	<	/* Python.h has to appear first */
29	<	#include <Python.h>
130	<
131	<	/* -----------------------------------------------------------------------------
132	<	* swigrun.swg
28	>	/***********************************************************************
29	>	* common.swg
30		*
31	<	* This file contains generic CAPI SWIG runtime support for pointer
32	<	* type checking.
33	<	* ----------------------------------------------------------------------------- */
34	<
35	<	/* This should only be incremented when either the layout of swig_type_info changes,
36	<	or for whatever reason, the runtime changes incompatibly */
37	<	#define SWIG_RUNTIME_VERSION "2"
38	<
39	<	/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
40	<	#ifdef SWIG_TYPE_TABLE
41	<	# define SWIG_QUOTE_STRING(x) #x
145	<	# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146	<	# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147	<	#else
148	<	# define SWIG_TYPE_TABLE_NAME
149	<	#endif
150	<
151	<	/*
152	<	You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153	<	creating a static or dynamic library from the swig runtime code.
154	<	In 99.9% of the cases, swig just needs to declare them as 'static'.
155	<
156	<	But only do this if is strictly necessary, ie, if you have problems
157	<	with your compiler or so.
158	<	*/
159	<
160	<	#ifndef SWIGRUNTIME
161	<	# define SWIGRUNTIME SWIGINTERN
162	<	#endif
31	>	*     This file contains generic SWIG runtime support for pointer
32	>	*     type checking as well as a few commonly used macros to control
33	>	*     external linkage.
34	>	*
35	>	* Author : David Beazley (beazley@cs.uchicago.edu)
36	>	*
37	>	* Copyright (c) 1999-2000, The University of Chicago
38	>	*
39	>	* This file may be freely redistributed without license or fee provided
40	>	* this copyright message remains intact.
41	>	************************************************************************/
42
43	<	#ifndef SWIGRUNTIMEINLINE
165	<	# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166	<	#endif
43	>	#include <string.h>
44
45	<	/*  Generic buffer size */
46	<	#ifndef SWIG_BUFFER_SIZE
47	<	# define SWIG_BUFFER_SIZE 1024
45	>	#if defined(_WIN32) || defined(__WIN32__)
46	>	#       if defined(_MSC_VER)
47	>	#               if defined(STATIC_LINKED)
48	>	#                       define SWIGEXPORT(a) a
49	>	#                       define SWIGIMPORT(a) extern a
50	>	#               else
51	>	#                       define SWIGEXPORT(a) __declspec(dllexport) a
52	>	#                       define SWIGIMPORT(a) extern a
53	>	#               endif
54	>	#       else
55	>	#               if defined(__BORLANDC__)
56	>	#                       define SWIGEXPORT(a) a _export
57	>	#                       define SWIGIMPORT(a) a _export
58	>	#               else
59	>	#                       define SWIGEXPORT(a) a
60	>	#                       define SWIGIMPORT(a) a
61	>	#               endif
62	>	#       endif
63	>	#else
64	>	#       define SWIGEXPORT(a) a
65	>	#       define SWIGIMPORT(a) a
66		#endif
67
68	<	/* Flags for pointer conversions */
69	<	#define SWIG_POINTER_DISOWN        0x1
70	<
71	<	/* Flags for new pointer objects */
177	<	#define SWIG_POINTER_OWN           0x1
178	<
179	<
180	<	/*
181	<	Flags/methods for returning states.
182	<
183	<	The swig conversion methods, as ConvertPtr, return and integer
184	<	that tells if the conversion was successful or not. And if not,
185	<	an error code can be returned (see swigerrors.swg for the codes).
186	<
187	<	Use the following macros/flags to set or process the returning
188	<	states.
189	<
190	<	In old swig versions, you usually write code as:
191	<
192	<	if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193	<	// success code
194	<	} else {
195	<	//fail code
196	<	}
197	<
198	<	Now you can be more explicit as:
199	<
200	<	int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201	<	if (SWIG_IsOK(res)) {
202	<	// success code
203	<	} else {
204	<	// fail code
205	<	}
206	<
207	<	that seems to be the same, but now you can also do
208	<
209	<	Type *ptr;
210	<	int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211	<	if (SWIG_IsOK(res)) {
212	<	// success code
213	<	if (SWIG_IsNewObj(res) {
214	<	...
215	<	delete *ptr;
216	<	} else {
217	<	...
218	<	}
219	<	} else {
220	<	// fail code
221	<	}
222	<
223	<	I.e., now SWIG_ConvertPtr can return new objects and you can
224	<	identify the case and take care of the deallocation. Of course that
225	<	requires also to SWIG_ConvertPtr to return new result values, as
226	<
227	<	int SWIG_ConvertPtr(obj, ptr,...) {
228	<	if (<obj is ok>) {
229	<	if (<need new object>) {
230	<	*ptr = <ptr to new allocated object>;
231	<	return SWIG_NEWOBJ;
232	<	} else {
233	<	*ptr = <ptr to old object>;
234	<	return SWIG_OLDOBJ;
235	<	}
236	<	} else {
237	<	return SWIG_BADOBJ;
238	<	}
239	<	}
240	<
241	<	Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242	<	more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243	<	swig errors code.
244	<
245	<	Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246	<	allows to return the 'cast rank', for example, if you have this
247	<
248	<	int food(double)
249	<	int fooi(int);
250	<
251	<	and you call
252	<
253	<	food(1)   // cast rank '1'  (1 -> 1.0)
254	<	fooi(1)   // cast rank '0'
255	<
256	<	just use the SWIG_AddCast()/SWIG_CheckState()
257	<
258	<
259	<	*/
260	<	#define SWIG_OK                    (0)
261	<	#define SWIG_ERROR                 (-1)
262	<	#define SWIG_IsOK(r)               (r >= 0)
263	<	#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264	<
265	<	/* The CastRankLimit says how many bits are used for the cast rank */
266	<	#define SWIG_CASTRANKLIMIT         (1 << 8)
267	<	/* The NewMask denotes the object was created (using new/malloc) */
268	<	#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
269	<	/* The TmpMask is for in/out typemaps that use temporal objects */
270	<	#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
271	<	/* Simple returning values */
272	<	#define SWIG_BADOBJ                (SWIG_ERROR)
273	<	#define SWIG_OLDOBJ                (SWIG_OK)
274	<	#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
275	<	#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
276	<	/* Check, add and del mask methods */
277	<	#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278	<	#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279	<	#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280	<	#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281	<	#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282	<	#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283	<
284	<
285	<	/* Cast-Rank Mode */
286	<	#if defined(SWIG_CASTRANK_MODE)
287	<	#  ifndef SWIG_TypeRank
288	<	#    define SWIG_TypeRank             unsigned long
289	<	#  endif
290	<	#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
291	<	#    define SWIG_MAXCASTRANK          (2)
292	<	#  endif
293	<	#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
294	<	#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
295	<	SWIGINTERNINLINE int SWIG_AddCast(int r) {
296	<	return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297	<	}
298	<	SWIGINTERNINLINE int SWIG_CheckState(int r) {
299	<	return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300	<	}
301	<	#else /* no cast-rank mode */
302	<	#  define SWIG_AddCast
303	<	#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
68	>	#ifdef SWIG_GLOBAL
69	>	#define SWIGRUNTIME(a) SWIGEXPORT(a)
70	>	#else
71	>	#define SWIGRUNTIME(a) static a
72		#endif
73
306	–
307	–
308	–
309	–	#include <string.h>
310	–
74		#ifdef __cplusplus
75		extern "C" {
76		#endif
#	Line 315 | Line 78 | extern "C" {
78		typedef void *(*swig_converter_func)(void *);
79		typedef struct swig_type_info *(*swig_dycast_func)(void **);
80
318	–	/* Structure to store inforomation on one type */
81		typedef struct swig_type_info {
82	<	const char             *name;                 /* mangled name of this type */
83	<	const char             *str;                  /* human readable name of this type */
84	<	swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
85	<	struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
86	<	void                   *clientdata;           /* language specific type data */
87	<	int                    owndata;               /* flag if the structure owns the clientdata */
82	>	const char             *name;
83	>	swig_converter_func     converter;
84	>	const char             *str;
85	>	void                   *clientdata;
86	>	swig_dycast_func        dcast;
87	>	struct swig_type_info  *next;
88	>	struct swig_type_info  *prev;
89		} swig_type_info;
90
91	<	/* Structure to store a type and conversion function used for casting */
329	<	typedef struct swig_cast_info {
330	<	swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
331	<	swig_converter_func     converter;            /* function to cast the void pointers */
332	<	struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
333	<	struct swig_cast_info  *prev;                 /* pointer to the previous cast */
334	<	} swig_cast_info;
335	<
336	<	/* Structure used to store module information
337	<	* Each module generates one structure like this, and the runtime collects
338	<	* all of these structures and stores them in a circularly linked list.*/
339	<	typedef struct swig_module_info {
340	<	swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
341	<	size_t                 size;                  /* Number of types in this module */
342	<	struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
343	<	swig_type_info         **type_initial;        /* Array of initially generated type structures */
344	<	swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
345	<	void                    *clientdata;          /* Language specific module data */
346	<	} swig_module_info;
347	<
348	<	/*
349	<	Compare two type names skipping the space characters, therefore
350	<	"char*" == "char *" and "Class<int>" == "Class<int >", etc.
351	<
352	<	Return 0 when the two name types are equivalent, as in
353	<	strncmp, but skipping ' '.
354	<	*/
355	<	SWIGRUNTIME int
356	<	SWIG_TypeNameComp(const char *f1, const char *l1,
357	<	const char *f2, const char *l2) {
358	<	for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359	<	while ((*f1 == ' ') && (f1 != l1)) ++f1;
360	<	while ((*f2 == ' ') && (f2 != l2)) ++f2;
361	<	if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362	<	}
363	<	return (l1 - f1) - (l2 - f2);
364	<	}
91	>	#ifdef SWIG_NOINCLUDE
92
93	<	/*
94	<	Check type equivalence in a name list like <name1>|<name2>|...
95	<	Return 0 if not equal, 1 if equal
96	<	*/
97	<	SWIGRUNTIME int
98	<	SWIG_TypeEquiv(const char *nb, const char *tb) {
99	<	int equiv = 0;
100	<	const char* te = tb + strlen(tb);
101	<	const char* ne = nb;
102	<	while (!equiv && *ne) {
103	<	for (nb = ne; *ne; ++ne) {
377	<	if (*ne == '|') break;
378	<	}
379	<	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380	<	if (*ne) ++ne;
381	<	}
382	<	return equiv;
383	<	}
93	>	SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
94	>	SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
95	>	SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
96	>	SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
97	>	SWIGIMPORT(const char *)     SWIG_TypeName(const swig_type_info *);
98	>	SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
99	>	SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);
100	>
101	>	#else
102	>
103	>	static swig_type_info *swig_type_list = 0;
104
105	<	/*
106	<	Check type equivalence in a name list like <name1>|<name2>|...
107	<	Return 0 if equal, -1 if nb < tb, 1 if nb > tb
108	<	*/
109	<	SWIGRUNTIME int
110	<	SWIG_TypeCompare(const char *nb, const char *tb) {
111	<	int equiv = 0;
112	<	const char* te = tb + strlen(tb);
113	<	const char* ne = nb;
114	<	while (!equiv && *ne) {
115	<	for (nb = ne; *ne; ++ne) {
116	<	if (*ne == '|') break;
105	>	/* Register a type mapping with the type-checking */
106	>	SWIGRUNTIME(swig_type_info *)
107	>	SWIG_TypeRegister(swig_type_info *ti)
108	>	{
109	>	swig_type_info *tc, *head, *ret, *next;
110	>	/* Check to see if this type has already been registered */
111	>	tc = swig_type_list;
112	>	while (tc) {
113	>	if (strcmp(tc->name, ti->name) == 0) {
114	>	/* Already exists in the table.  Just add additional types to the list */
115	>	if (tc->clientdata) ti->clientdata = tc->clientdata;
116	>	head = tc;
117	>	next = tc->next;
118	>	goto l1;
119	>	}
120	>	tc = tc->prev;
121	>	}
122	>	head = ti;
123	>	next = 0;
124	>
125	>	/* Place in list */
126	>	ti->prev = swig_type_list;
127	>	swig_type_list = ti;
128	>
129	>	/* Build linked lists */
130	>	l1:
131	>	ret = head;
132	>	tc = ti + 1;
133	>	/* Patch up the rest of the links */
134	>	while (tc->name) {
135	>	head->next = tc;
136	>	tc->prev = head;
137	>	head = tc;
138	>	tc++;
139	>	}
140	>	if (next) next->prev = head;  /**/
141	>	head->next = next;
142	>	return ret;
143	>	}
144	>
145	>	/* Check the typename */
146	>	SWIGRUNTIME(swig_type_info *)
147	>	SWIG_TypeCheck(char *c, swig_type_info *ty)
148	>	{
149	>	swig_type_info *s;
150	>	if (!ty) return 0;        /* Void pointer */
151	>	s = ty->next;             /* First element always just a name */
152	>	do {
153	>	if (strcmp(s->name,c) == 0) {
154	>	if (s == ty->next) return s;
155	>	/* Move s to the top of the linked list */
156	>	s->prev->next = s->next;
157	>	if (s->next) {
158	>	s->next->prev = s->prev;
159	>	}
160	>	/* Insert s as second element in the list */
161	>	s->next = ty->next;
162	>	if (ty->next) ty->next->prev = s;
163	>	ty->next = s;
164	>	s->prev = ty;  /**/
165	>	return s;
166		}
167	<	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
168	<	if (*ne) ++ne;
169	<	}
401	<	return equiv;
167	>	s = s->next;
168	>	} while (s && (s != ty->next));
169	>	return 0;
170		}
171
172	+	/* Cast a pointer up an inheritance hierarchy */
173	+	SWIGRUNTIME(void *)
174	+	SWIG_TypeCast(swig_type_info *ty, void *ptr)
175	+	{
176	+	if ((!ty) || (!ty->converter)) return ptr;
177	+	return (*ty->converter)(ptr);
178	+	}
179
180	<	/* think of this as a c++ template<> or a scheme macro */
181	<	#define SWIG_TypeCheck_Template(comparison, ty)         \
182	<	if (ty) {                                             \
183	<	swig_cast_info *iter = ty->cast;                    \
409	<	while (iter) {                                      \
410	<	if (comparison) {                                 \
411	<	if (iter == ty->cast) return iter;              \
412	<	/* Move iter to the top of the linked list */   \
413	<	iter->prev->next = iter->next;                  \
414	<	if (iter->next)                                 \
415	<	iter->next->prev = iter->prev;                \
416	<	iter->next = ty->cast;                          \
417	<	iter->prev = 0;                                 \
418	<	if (ty->cast) ty->cast->prev = iter;            \
419	<	ty->cast = iter;                                \
420	<	return iter;                                    \
421	<	}                                                 \
422	<	iter = iter->next;                                \
423	<	}                                                   \
424	<	}                                                     \
425	<	return 0
426	<
427	<	/*
428	<	Check the typename
429	<	*/
430	<	SWIGRUNTIME swig_cast_info *
431	<	SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432	<	SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433	<	}
434	<
435	<	/* Same as previous function, except strcmp is replaced with a pointer comparison */
436	<	SWIGRUNTIME swig_cast_info *
437	<	SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438	<	SWIG_TypeCheck_Template(iter->type == from, into);
439	<	}
440	<
441	<	/*
442	<	Cast a pointer up an inheritance hierarchy
443	<	*/
444	<	SWIGRUNTIMEINLINE void *
445	<	SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446	<	return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447	<	}
448	<
449	<	/*
450	<	Dynamic pointer casting. Down an inheritance hierarchy
451	<	*/
452	<	SWIGRUNTIME swig_type_info *
453	<	SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
180	>	/* Dynamic pointer casting. Down an inheritance hierarchy */
181	>	SWIGRUNTIME(swig_type_info *)
182	>	SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
183	>	{
184		swig_type_info *lastty = ty;
185		if (!ty || !ty->dcast) return ty;
186		while (ty && (ty->dcast)) {
187	<	ty = (*ty->dcast)(ptr);
188	<	if (ty) lastty = ty;
187	>	ty = (*ty->dcast)(ptr);
188	>	if (ty) lastty = ty;
189		}
190		return lastty;
191		}
192
193	<	/*
194	<	Return the name associated with this type
465	<	*/
466	<	SWIGRUNTIMEINLINE const char *
193	>	/* Return the name associated with this type */
194	>	SWIGRUNTIME(const char *)
195		SWIG_TypeName(const swig_type_info *ty) {
196		return ty->name;
197		}
198
199	<	/*
200	<	Return the pretty name associated with this type,
201	<	that is an unmangled type name in a form presentable to the user.
202	<	*/
203	<	SWIGRUNTIME const char *
204	<	SWIG_TypePrettyName(const swig_type_info *type) {
205	<	/* The "str" field contains the equivalent pretty names of the
206	<	type, separated by vertical-bar characters.  We choose
479	<	to print the last name, as it is often (?) the most
480	<	specific. */
481	<	if (!type) return NULL;
482	<	if (type->str != NULL) {
483	<	const char *last_name = type->str;
484	<	const char *s;
485	<	for (s = type->str; *s; s++)
486	<	if (*s == '|') last_name = s+1;
487	<	return last_name;
199	>	/* Search for a swig_type_info structure */
200	>	SWIGRUNTIME(swig_type_info *)
201	>	SWIG_TypeQuery(const char *name) {
202	>	swig_type_info *ty = swig_type_list;
203	>	while (ty) {
204	>	if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
205	>	if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
206	>	ty = ty->prev;
207		}
208	<	else
490	<	return type->name;
208	>	return 0;
209		}
210
211	<	/*
212	<	Set the clientdata field for a type
495	<	*/
496	<	SWIGRUNTIME void
211	>	/* Set the clientdata field for a type */
212	>	SWIGRUNTIME(void)
213		SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
214	<	swig_cast_info *cast = ti->cast;
215	<	/* if (ti->clientdata == clientdata) return; */
214	>	swig_type_info *tc, *equiv;
215	>	if (ti->clientdata == clientdata) return;
216		ti->clientdata = clientdata;
217	<
218	<	while (cast) {
219	<	if (!cast->converter) {
220	<	swig_type_info *tc = cast->type;
221	<	if (!tc->clientdata) {
222	<	SWIG_TypeClientData(tc, clientdata);
223	<	}
224	<	}
509	<	cast = cast->next;
510	<	}
511	<	}
512	<	SWIGRUNTIME void
513	<	SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514	<	SWIG_TypeClientData(ti, clientdata);
515	<	ti->owndata = 1;
516	<	}
517	<
518	<	/*
519	<	Search for a swig_type_info structure only by mangled name
520	<	Search is a O(log #types)
521	<
522	<	We start searching at module start, and finish searching when start == end.
523	<	Note: if start == end at the beginning of the function, we go all the way around
524	<	the circular list.
525	<	*/
526	<	SWIGRUNTIME swig_type_info *
527	<	SWIG_MangledTypeQueryModule(swig_module_info *start,
528	<	swig_module_info *end,
529	<	const char *name) {
530	<	swig_module_info *iter = start;
531	<	do {
532	<	if (iter->size) {
533	<	register size_t l = 0;
534	<	register size_t r = iter->size - 1;
535	<	do {
536	<	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
537	<	register size_t i = (l + r) >> 1;
538	<	const char *iname = iter->types[i]->name;
539	<	if (iname) {
540	<	register int compare = strcmp(name, iname);
541	<	if (compare == 0) {
542	<	return iter->types[i];
543	<	} else if (compare < 0) {
544	<	if (i) {
545	<	r = i - 1;
546	<	} else {
547	<	break;
548	<	}
549	<	} else if (compare > 0) {
550	<	l = i + 1;
551	<	}
552	<	} else {
553	<	break; /* should never happen */
554	<	}
555	<	} while (l <= r);
556	<	}
557	<	iter = iter->next;
558	<	} while (iter != end);
559	<	return 0;
560	<	}
561	<
562	<	/*
563	<	Search for a swig_type_info structure for either a mangled name or a human readable name.
564	<	It first searches the mangled names of the types, which is a O(log #types)
565	<	If a type is not found it then searches the human readable names, which is O(#types).
566	<
567	<	We start searching at module start, and finish searching when start == end.
568	<	Note: if start == end at the beginning of the function, we go all the way around
569	<	the circular list.
570	<	*/
571	<	SWIGRUNTIME swig_type_info *
572	<	SWIG_TypeQueryModule(swig_module_info *start,
573	<	swig_module_info *end,
574	<	const char *name) {
575	<	/* STEP 1: Search the name field using binary search */
576	<	swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577	<	if (ret) {
578	<	return ret;
579	<	} else {
580	<	/* STEP 2: If the type hasn't been found, do a complete search
581	<	of the str field (the human readable name) */
582	<	swig_module_info *iter = start;
583	<	do {
584	<	register size_t i = 0;
585	<	for (; i < iter->size; ++i) {
586	<	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587	<	return iter->types[i];
217	>	equiv = ti->next;
218	>	while (equiv) {
219	>	if (!equiv->converter) {
220	>	tc = swig_type_list;
221	>	while (tc) {
222	>	if ((strcmp(tc->name, equiv->name) == 0))
223	>	SWIG_TypeClientData(tc,clientdata);
224	>	tc = tc->prev;
225		}
589	–	iter = iter->next;
590	–	} while (iter != end);
591	–	}
592	–
593	–	/* neither found a match */
594	–	return 0;
595	–	}
596	–
597	–	/*
598	–	Pack binary data into a string
599	–	*/
600	–	SWIGRUNTIME char *
601	–	SWIG_PackData(char *c, void *ptr, size_t sz) {
602	–	static const char hex[17] = "0123456789abcdef";
603	–	register const unsigned char *u = (unsigned char *) ptr;
604	–	register const unsigned char *eu =  u + sz;
605	–	for (; u != eu; ++u) {
606	–	register unsigned char uu = *u;
607	–	*(c++) = hex[(uu & 0xf0) >> 4];
608	–	*(c++) = hex[uu & 0xf];
609	–	}
610	–	return c;
611	–	}
612	–
613	–	/*
614	–	Unpack binary data from a string
615	–	*/
616	–	SWIGRUNTIME const char *
617	–	SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618	–	register unsigned char *u = (unsigned char *) ptr;
619	–	register const unsigned char *eu = u + sz;
620	–	for (; u != eu; ++u) {
621	–	register char d = *(c++);
622	–	register unsigned char uu;
623	–	if ((d >= '0') && (d <= '9'))
624	–	uu = ((d - '0') << 4);
625	–	else if ((d >= 'a') && (d <= 'f'))
626	–	uu = ((d - ('a'-10)) << 4);
627	–	else
628	–	return (char *) 0;
629	–	d = *(c++);
630	–	if ((d >= '0') && (d <= '9'))
631	–	uu |= (d - '0');
632	–	else if ((d >= 'a') && (d <= 'f'))
633	–	uu |= (d - ('a'-10));
634	–	else
635	–	return (char *) 0;
636	–	*u = uu;
637	–	}
638	–	return c;
639	–	}
640	–
641	–	/*
642	–	Pack 'void *' into a string buffer.
643	–	*/
644	–	SWIGRUNTIME char *
645	–	SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646	–	char *r = buff;
647	–	if ((2*sizeof(void *) + 2) > bsz) return 0;
648	–	*(r++) = '_';
649	–	r = SWIG_PackData(r,&ptr,sizeof(void *));
650	–	if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651	–	strcpy(r,name);
652	–	return buff;
653	–	}
654	–
655	–	SWIGRUNTIME const char *
656	–	SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657	–	if (*c != '_') {
658	–	if (strcmp(c,"NULL") == 0) {
659	–	*ptr = (void *) 0;
660	–	return name;
661	–	} else {
662	–	return 0;
663	–	}
664	–	}
665	–	return SWIG_UnpackData(++c,ptr,sizeof(void *));
666	–	}
667	–
668	–	SWIGRUNTIME char *
669	–	SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670	–	char *r = buff;
671	–	size_t lname = (name ? strlen(name) : 0);
672	–	if ((2*sz + 2 + lname) > bsz) return 0;
673	–	*(r++) = '_';
674	–	r = SWIG_PackData(r,ptr,sz);
675	–	if (lname) {
676	–	strncpy(r,name,lname+1);
677	–	} else {
678	–	*r = 0;
679	–	}
680	–	return buff;
681	–	}
682	–
683	–	SWIGRUNTIME const char *
684	–	SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685	–	if (*c != '_') {
686	–	if (strcmp(c,"NULL") == 0) {
687	–	memset(ptr,0,sz);
688	–	return name;
689	–	} else {
690	–	return 0;
226		}
227	+	equiv = equiv->next;
228		}
693	–	return SWIG_UnpackData(++c,ptr,sz);
694	–	}
695	–
696	–	#ifdef __cplusplus
229		}
230		#endif
231
232	<	/*  Errors in SWIG */
701	<	#define  SWIG_UnknownError         -1
702	<	#define  SWIG_IOError              -2
703	<	#define  SWIG_RuntimeError         -3
704	<	#define  SWIG_IndexError           -4
705	<	#define  SWIG_TypeError            -5
706	<	#define  SWIG_DivisionByZero       -6
707	<	#define  SWIG_OverflowError        -7
708	<	#define  SWIG_SyntaxError          -8
709	<	#define  SWIG_ValueError           -9
710	<	#define  SWIG_SystemError          -10
711	<	#define  SWIG_AttributeError       -11
712	<	#define  SWIG_MemoryError          -12
713	<	#define  SWIG_NullReferenceError   -13
714	<
715	<
716	<
717	<	/* Python.h has to appear first */
718	<	#include <Python.h>
719	<
720	<	/* Add PyOS_snprintf for old Pythons */
721	<	#if PY_VERSION_HEX < 0x02020000
722	<	# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723	<	#  define PyOS_snprintf _snprintf
724	<	# else
725	<	#  define PyOS_snprintf snprintf
726	<	# endif
727	<	#endif
728	<
729	<	/* A crude PyString_FromFormat implementation for old Pythons */
730	<	#if PY_VERSION_HEX < 0x02020000
731	<
732	<	#ifndef SWIG_PYBUFFER_SIZE
733	<	# define SWIG_PYBUFFER_SIZE 1024
734	<	#endif
735	<
736	<	static PyObject *
737	<	PyString_FromFormat(const char *fmt, ...) {
738	<	va_list ap;
739	<	char buf[SWIG_PYBUFFER_SIZE * 2];
740	<	int res;
741	<	va_start(ap, fmt);
742	<	res = vsnprintf(buf, sizeof(buf), fmt, ap);
743	<	va_end(ap);
744	<	return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
232	>	#ifdef __cplusplus
233		}
746	–	#endif
234
748	–	/* Add PyObject_Del for old Pythons */
749	–	#if PY_VERSION_HEX < 0x01060000
750	–	# define PyObject_Del(op) PyMem_DEL((op))
751	–	#endif
752	–	#ifndef PyObject_DEL
753	–	# define PyObject_DEL PyObject_Del
235		#endif
236
237	<	/* A crude PyExc_StopIteration exception for old Pythons */
238	<	#if PY_VERSION_HEX < 0x02020000
239	<	# ifndef PyExc_StopIteration
240	<	#  define PyExc_StopIteration PyExc_RuntimeError
241	<	# endif
242	<	# ifndef PyObject_GenericGetAttr
243	<	#  define PyObject_GenericGetAttr 0
244	<	# endif
245	<	#endif
765	<	/* Py_NotImplemented is defined in 2.1 and up. */
766	<	#if PY_VERSION_HEX < 0x02010000
767	<	# ifndef Py_NotImplemented
768	<	#  define Py_NotImplemented PyExc_RuntimeError
769	<	# endif
770	<	#endif
771	<
772	<
773	<	/* A crude PyString_AsStringAndSize implementation for old Pythons */
774	<	#if PY_VERSION_HEX < 0x02010000
775	<	# ifndef PyString_AsStringAndSize
776	<	#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777	<	# endif
778	<	#endif
779	<
780	<	/* PySequence_Size for old Pythons */
781	<	#if PY_VERSION_HEX < 0x02000000
782	<	# ifndef PySequence_Size
783	<	#  define PySequence_Size PySequence_Length
784	<	# endif
785	<	#endif
786	<
787	<
788	<	/* PyBool_FromLong for old Pythons */
789	<	#if PY_VERSION_HEX < 0x02030000
790	<	static
791	<	PyObject *PyBool_FromLong(long ok)
792	<	{
793	<	PyObject *result = ok ? Py_True : Py_False;
794	<	Py_INCREF(result);
795	<	return result;
796	<	}
797	<	#endif
798	<
799	<
800	<	/* -----------------------------------------------------------------------------
801	<	* error manipulation
802	<	* ----------------------------------------------------------------------------- */
803	<
804	<	SWIGRUNTIME PyObject*
805	<	SWIG_Python_ErrorType(int code) {
806	<	PyObject* type = 0;
807	<	switch(code) {
808	<	case SWIG_MemoryError:
809	<	type = PyExc_MemoryError;
810	<	break;
811	<	case SWIG_IOError:
812	<	type = PyExc_IOError;
813	<	break;
814	<	case SWIG_RuntimeError:
815	<	type = PyExc_RuntimeError;
816	<	break;
817	<	case SWIG_IndexError:
818	<	type = PyExc_IndexError;
819	<	break;
820	<	case SWIG_TypeError:
821	<	type = PyExc_TypeError;
822	<	break;
823	<	case SWIG_DivisionByZero:
824	<	type = PyExc_ZeroDivisionError;
825	<	break;
826	<	case SWIG_OverflowError:
827	<	type = PyExc_OverflowError;
828	<	break;
829	<	case SWIG_SyntaxError:
830	<	type = PyExc_SyntaxError;
831	<	break;
832	<	case SWIG_ValueError:
833	<	type = PyExc_ValueError;
834	<	break;
835	<	case SWIG_SystemError:
836	<	type = PyExc_SystemError;
837	<	break;
838	<	case SWIG_AttributeError:
839	<	type = PyExc_AttributeError;
840	<	break;
841	<	default:
842	<	type = PyExc_RuntimeError;
843	<	}
844	<	return type;
845	<	}
846	<
847	<
848	<	SWIGRUNTIME void
849	<	SWIG_Python_AddErrorMsg(const char* mesg)
850	<	{
851	<	PyObject *type = 0;
852	<	PyObject *value = 0;
853	<	PyObject *traceback = 0;
854	<
855	<	if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856	<	if (value) {
857	<	PyObject *old_str = PyObject_Str(value);
858	<	PyErr_Clear();
859	<	Py_XINCREF(type);
860	<	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861	<	Py_DECREF(old_str);
862	<	Py_DECREF(value);
863	<	} else {
864	<	PyErr_Format(PyExc_RuntimeError, mesg);
865	<	}
866	<	}
867	<
868	<
869	<
870	<	#if defined(SWIG_PYTHON_NO_THREADS)
871	<	#  if defined(SWIG_PYTHON_THREADS)
872	<	#    undef SWIG_PYTHON_THREADS
873	<	#  endif
874	<	#endif
875	<	#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876	<	#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877	<	#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878	<	#      define SWIG_PYTHON_USE_GIL
879	<	#    endif
880	<	#  endif
881	<	#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882	<	#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
883	<	#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
884	<	#    endif
885	<	#    ifdef __cplusplus /* C++ code */
886	<	class SWIG_Python_Thread_Block {
887	<	bool status;
888	<	PyGILState_STATE state;
889	<	public:
890	<	void end() { if (status) { PyGILState_Release(state); status = false;} }
891	<	SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892	<	~SWIG_Python_Thread_Block() { end(); }
893	<	};
894	<	class SWIG_Python_Thread_Allow {
895	<	bool status;
896	<	PyThreadState *save;
897	<	public:
898	<	void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899	<	SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900	<	~SWIG_Python_Thread_Allow() { end(); }
901	<	};
902	<	#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
903	<	#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
904	<	#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
905	<	#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
906	<	#    else /* C code */
907	<	#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908	<	#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
909	<	#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910	<	#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
911	<	#    endif
912	<	#  else /* Old thread way, not implemented, user must provide it */
913	<	#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914	<	#      define SWIG_PYTHON_INITIALIZE_THREADS
915	<	#    endif
916	<	#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917	<	#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918	<	#    endif
919	<	#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920	<	#      define SWIG_PYTHON_THREAD_END_BLOCK
921	<	#    endif
922	<	#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923	<	#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924	<	#    endif
925	<	#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926	<	#      define SWIG_PYTHON_THREAD_END_ALLOW
927	<	#    endif
928	<	#  endif
929	<	#else /* No thread support */
930	<	#  define SWIG_PYTHON_INITIALIZE_THREADS
931	<	#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932	<	#  define SWIG_PYTHON_THREAD_END_BLOCK
933	<	#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934	<	#  define SWIG_PYTHON_THREAD_END_ALLOW
935	<	#endif
237	>	/***********************************************************************
238	>	* python.swg
239	>	*
240	>	*     This file contains the runtime support for Python modules
241	>	*     and includes code for managing global variables and pointer
242	>	*     type checking.
243	>	*
244	>	* Author : David Beazley (beazley@cs.uchicago.edu)
245	>	************************************************************************/
246
247	<	/* -----------------------------------------------------------------------------
938	<	* Python API portion that goes into the runtime
939	<	* ----------------------------------------------------------------------------- */
247	>	#include "Python.h"
248
249		#ifdef __cplusplus
250		extern "C" {
943	–	#if 0
944	–	} /* cc-mode */
251		#endif
946	–	#endif
947	–
948	–	/* -----------------------------------------------------------------------------
949	–	* Constant declarations
950	–	* ----------------------------------------------------------------------------- */
252
253	<	/* Constant Types */
253	>	#define SWIG_PY_INT     1
254	>	#define SWIG_PY_FLOAT   2
255	>	#define SWIG_PY_STRING  3
256		#define SWIG_PY_POINTER 4
257		#define SWIG_PY_BINARY  5
258
259	<	/* Constant information structure */
957	<	typedef struct swig_const_info {
958	<	int type;
959	<	char *name;
960	<	long lvalue;
961	<	double dvalue;
962	<	void   *pvalue;
963	<	swig_type_info **ptype;
964	<	} swig_const_info;
965	<
966	<	#ifdef __cplusplus
967	<	#if 0
968	<	{ /* cc-mode */
969	<	#endif
970	<	}
971	<	#endif
972	<
259	>	/* Flags for pointer conversion */
260
261	<	/* -----------------------------------------------------------------------------
262	<	* See the LICENSE file for information on copyright, usage and redistribution
976	<	* of SWIG, and the README file for authors - http://www.swig.org/release.html.
977	<	*
978	<	* pyrun.swg
979	<	*
980	<	* This file contains the runtime support for Python modules
981	<	* and includes code for managing global variables and pointer
982	<	* type checking.
983	<	*
984	<	* ----------------------------------------------------------------------------- */
985	<
986	<	/* Common SWIG API */
987	<
988	<	/* for raw pointers */
989	<	#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990	<	#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991	<	#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992	<	#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
993	<	#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
994	<	#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
995	<	#define swig_owntype                                    int
996	<
997	<	/* for raw packed data */
998	<	#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999	<	#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1000	<
1001	<	/* for class or struct pointers */
1002	<	#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
1003	<	#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1004	<
1005	<	/* for C or C++ function pointers */
1006	<	#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007	<	#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
1008	<
1009	<	/* for C++ member pointers, ie, member methods */
1010	<	#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011	<	#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1012	<
1013	<
1014	<	/* Runtime API */
1015	<
1016	<	#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1017	<	#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1018	<	#define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
261	>	#define SWIG_POINTER_EXCEPTION     0x1
262	>	#define SWIG_POINTER_DISOWN        0x2
263
264	<	#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
265	<	#define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg
1022	<	#define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)
1023	<	#define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024	<	#define SWIG_fail                                       goto fail
264	>	/* Exception handling in wrappers */
265	>	#define SWIG_fail   goto fail
266
267	+	/* Constant information structure */
268	+	typedef struct swig_const_info {
269	+	int type;
270	+	char *name;
271	+	long lvalue;
272	+	double dvalue;
273	+	void   *pvalue;
274	+	swig_type_info **ptype;
275	+	} swig_const_info;
276
277	<	/* Runtime API implementation */
1028	<
1029	<	/* Error manipulation */
1030	<
1031	<	SWIGINTERN void
1032	<	SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033	<	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034	<	PyErr_SetObject(errtype, obj);
1035	<	Py_DECREF(obj);
1036	<	SWIG_PYTHON_THREAD_END_BLOCK;
1037	<	}
1038	<
1039	<	SWIGINTERN void
1040	<	SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041	<	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042	<	PyErr_SetString(errtype, (char *) msg);
1043	<	SWIG_PYTHON_THREAD_END_BLOCK;
1044	<	}
1045	<
1046	<	#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047	<
1048	<	/* Set a constant value */
1049	<
1050	<	SWIGINTERN void
1051	<	SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052	<	PyDict_SetItemString(d, (char*) name, obj);
1053	<	Py_DECREF(obj);
1054	<	}
1055	<
1056	<	/* Append a value to the result obj */
1057	<
1058	<	SWIGINTERN PyObject*
1059	<	SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060	<	#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061	<	if (!result) {
1062	<	result = obj;
1063	<	} else if (result == Py_None) {
1064	<	Py_DECREF(result);
1065	<	result = obj;
1066	<	} else {
1067	<	if (!PyList_Check(result)) {
1068	<	PyObject *o2 = result;
1069	<	result = PyList_New(1);
1070	<	PyList_SetItem(result, 0, o2);
1071	<	}
1072	<	PyList_Append(result,obj);
1073	<	Py_DECREF(obj);
1074	<	}
1075	<	return result;
1076	<	#else
1077	<	PyObject*   o2;
1078	<	PyObject*   o3;
1079	<	if (!result) {
1080	<	result = obj;
1081	<	} else if (result == Py_None) {
1082	<	Py_DECREF(result);
1083	<	result = obj;
1084	<	} else {
1085	<	if (!PyTuple_Check(result)) {
1086	<	o2 = result;
1087	<	result = PyTuple_New(1);
1088	<	PyTuple_SET_ITEM(result, 0, o2);
1089	<	}
1090	<	o3 = PyTuple_New(1);
1091	<	PyTuple_SET_ITEM(o3, 0, obj);
1092	<	o2 = result;
1093	<	result = PySequence_Concat(o2, o3);
1094	<	Py_DECREF(o2);
1095	<	Py_DECREF(o3);
1096	<	}
1097	<	return result;
1098	<	#endif
1099	<	}
1100	<
1101	<	/* Unpack the argument tuple */
1102	<
1103	<	SWIGINTERN int
1104	<	SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105	<	{
1106	<	if (!args) {
1107	<	if (!min && !max) {
1108	<	return 1;
1109	<	} else {
1110	<	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111	<	name, (min == max ? "" : "at least "), min);
1112	<	return 0;
1113	<	}
1114	<	}
1115	<	if (!PyTuple_Check(args)) {
1116	<	PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117	<	return 0;
1118	<	} else {
1119	<	register int l = PyTuple_GET_SIZE(args);
1120	<	if (l < min) {
1121	<	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122	<	name, (min == max ? "" : "at least "), min, l);
1123	<	return 0;
1124	<	} else if (l > max) {
1125	<	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126	<	name, (min == max ? "" : "at most "), max, l);
1127	<	return 0;
1128	<	} else {
1129	<	register int i;
1130	<	for (i = 0; i < l; ++i) {
1131	<	objs[i] = PyTuple_GET_ITEM(args, i);
1132	<	}
1133	<	for (; l < max; ++l) {
1134	<	objs[l] = 0;
1135	<	}
1136	<	return i + 1;
1137	<	}
1138	<	}
1139	<	}
1140	<
1141	<	/* A functor is a function object with one single object argument */
1142	<	#if PY_VERSION_HEX >= 0x02020000
1143	<	#define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144	<	#else
1145	<	#define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1146	<	#endif
277	>	#ifdef SWIG_NOINCLUDE
278
279	<	/*
280	<	Helper for static pointer initialization for both C and C++ code, for example
281	<	static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
282	<	*/
283	<	#ifdef __cplusplus
284	<	#define SWIG_STATIC_POINTER(var)  var
279	>	SWIGEXPORT(PyObject *)        SWIG_newvarlink(void);
280	>	SWIGEXPORT(void)              SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
281	>	SWIGEXPORT(int)               SWIG_ConvertPtr(PyObject *, void **, swig_type_info *, int);
282	>	SWIGEXPORT(int)               SWIG_ConvertPacked(PyObject *, void *, int sz, swig_type_info *, int);
283	>	SWIGEXPORT(char *)            SWIG_PackData(char *c, void *, int);
284	>	SWIGEXPORT(char *)            SWIG_UnpackData(char *c, void *, int);
285	>	SWIGEXPORT(PyObject *)        SWIG_NewPointerObj(void *, swig_type_info *,int own);
286	>	SWIGEXPORT(PyObject *)        SWIG_NewPackedObj(void *, int sz, swig_type_info *);
287	>	SWIGEXPORT(void)              SWIG_InstallConstants(PyObject *d, swig_const_info constants[]);
288		#else
1155	–	#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1156	–	#endif
289
290		/* -----------------------------------------------------------------------------
291	<	* Pointer declarations
291	>	* global variable support code.
292		* ----------------------------------------------------------------------------- */
293
294	<	/* Flags for new pointer objects */
295	<	#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
296	<	#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
297	<
298	<	#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
294	>	typedef struct swig_globalvar {
295	>	char       *name;                  /* Name of global variable */
296	>	PyObject *(*get_attr)(void);       /* Return the current value */
297	>	int       (*set_attr)(PyObject *); /* Set the value */
298	>	struct swig_globalvar *next;
299	>	} swig_globalvar;
300
301	<	#ifdef __cplusplus
1169	<	extern "C" {
1170	<	#if 0
1171	<	} /* cc-mode */
1172	<	#endif
1173	<	#endif
1174	<
1175	<	/*  How to access Py_None */
1176	<	#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177	<	#  ifndef SWIG_PYTHON_NO_BUILD_NONE
1178	<	#    ifndef SWIG_PYTHON_BUILD_NONE
1179	<	#      define SWIG_PYTHON_BUILD_NONE
1180	<	#    endif
1181	<	#  endif
1182	<	#endif
1183	<
1184	<	#ifdef SWIG_PYTHON_BUILD_NONE
1185	<	#  ifdef Py_None
1186	<	#   undef Py_None
1187	<	#   define Py_None SWIG_Py_None()
1188	<	#  endif
1189	<	SWIGRUNTIMEINLINE PyObject *
1190	<	_SWIG_Py_None(void)
1191	<	{
1192	<	PyObject *none = Py_BuildValue("");
1193	<	Py_DECREF(none);
1194	<	return none;
1195	<	}
1196	<	SWIGRUNTIME PyObject *
1197	<	SWIG_Py_None(void)
1198	<	{
1199	<	static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200	<	return none;
1201	<	}
1202	<	#endif
1203	<
1204	<	/* The python void return value */
1205	<
1206	<	SWIGRUNTIMEINLINE PyObject *
1207	<	SWIG_Py_Void(void)
1208	<	{
1209	<	PyObject *none = Py_None;
1210	<	Py_INCREF(none);
1211	<	return none;
1212	<	}
1213	<
1214	<	/* PySwigClientData */
1215	<
1216	<	typedef struct {
1217	<	PyObject *klass;
1218	<	PyObject *newraw;
1219	<	PyObject *newargs;
1220	<	PyObject *destroy;
1221	<	int delargs;
1222	<	int implicitconv;
1223	<	} PySwigClientData;
1224	<
1225	<	SWIGRUNTIMEINLINE int
1226	<	SWIG_Python_CheckImplicit(swig_type_info *ty)
1227	<	{
1228	<	PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229	<	return data ? data->implicitconv : 0;
1230	<	}
1231	<
1232	<	SWIGRUNTIMEINLINE PyObject *
1233	<	SWIG_Python_ExceptionType(swig_type_info *desc) {
1234	<	PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235	<	PyObject *klass = data ? data->klass : 0;
1236	<	return (klass ? klass : PyExc_RuntimeError);
1237	<	}
1238	<
1239	<
1240	<	SWIGRUNTIME PySwigClientData *
1241	<	PySwigClientData_New(PyObject* obj)
1242	<	{
1243	<	if (!obj) {
1244	<	return 0;
1245	<	} else {
1246	<	PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247	<	/* the klass element */
1248	<	data->klass = obj;
1249	<	Py_INCREF(data->klass);
1250	<	/* the newraw method and newargs arguments used to create a new raw instance */
1251	<	if (PyClass_Check(obj)) {
1252	<	data->newraw = 0;
1253	<	data->newargs = obj;
1254	<	Py_INCREF(obj);
1255	<	} else {
1256	<	#if (PY_VERSION_HEX < 0x02020000)
1257	<	data->newraw = 0;
1258	<	#else
1259	<	data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260	<	#endif
1261	<	if (data->newraw) {
1262	<	Py_INCREF(data->newraw);
1263	<	data->newargs = PyTuple_New(1);
1264	<	PyTuple_SetItem(data->newargs, 0, obj);
1265	<	} else {
1266	<	data->newargs = obj;
1267	<	}
1268	<	Py_INCREF(data->newargs);
1269	<	}
1270	<	/* the destroy method, aka as the C++ delete method */
1271	<	data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272	<	if (PyErr_Occurred()) {
1273	<	PyErr_Clear();
1274	<	data->destroy = 0;
1275	<	}
1276	<	if (data->destroy) {
1277	<	int flags;
1278	<	Py_INCREF(data->destroy);
1279	<	flags = PyCFunction_GET_FLAGS(data->destroy);
1280	<	#ifdef METH_O
1281	<	data->delargs = !(flags & (METH_O));
1282	<	#else
1283	<	data->delargs = 0;
1284	<	#endif
1285	<	} else {
1286	<	data->delargs = 0;
1287	<	}
1288	<	data->implicitconv = 0;
1289	<	return data;
1290	<	}
1291	<	}
1292	<
1293	<	SWIGRUNTIME void
1294	<	PySwigClientData_Del(PySwigClientData* data)
1295	<	{
1296	<	Py_XDECREF(data->newraw);
1297	<	Py_XDECREF(data->newargs);
1298	<	Py_XDECREF(data->destroy);
1299	<	}
1300	<
1301	<	/* =============== PySwigObject =====================*/
1302	<
1303	<	typedef struct {
301	>	typedef struct swig_varlinkobject {
302		PyObject_HEAD
303	<	void *ptr;
304	<	swig_type_info *ty;
1307	<	int own;
1308	<	PyObject *next;
1309	<	} PySwigObject;
1310	<
1311	<	SWIGRUNTIME PyObject *
1312	<	PySwigObject_long(PySwigObject *v)
1313	<	{
1314	<	return PyLong_FromVoidPtr(v->ptr);
1315	<	}
1316	<
1317	<	SWIGRUNTIME PyObject *
1318	<	PySwigObject_format(const char* fmt, PySwigObject *v)
1319	<	{
1320	<	PyObject *res = NULL;
1321	<	PyObject *args = PyTuple_New(1);
1322	<	if (args) {
1323	<	if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324	<	PyObject *ofmt = PyString_FromString(fmt);
1325	<	if (ofmt) {
1326	<	res = PyString_Format(ofmt,args);
1327	<	Py_DECREF(ofmt);
1328	<	}
1329	<	Py_DECREF(args);
1330	<	}
1331	<	}
1332	<	return res;
1333	<	}
1334	<
1335	<	SWIGRUNTIME PyObject *
1336	<	PySwigObject_oct(PySwigObject *v)
1337	<	{
1338	<	return PySwigObject_format("%o",v);
1339	<	}
1340	<
1341	<	SWIGRUNTIME PyObject *
1342	<	PySwigObject_hex(PySwigObject *v)
1343	<	{
1344	<	return PySwigObject_format("%x",v);
1345	<	}
1346	<
1347	<	SWIGRUNTIME PyObject *
1348	<	#ifdef METH_NOARGS
1349	<	PySwigObject_repr(PySwigObject *v)
1350	<	#else
1351	<	PySwigObject_repr(PySwigObject *v, PyObject *args)
1352	<	#endif
1353	<	{
1354	<	const char *name = SWIG_TypePrettyName(v->ty);
1355	<	PyObject *hex = PySwigObject_hex(v);
1356	<	PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357	<	Py_DECREF(hex);
1358	<	if (v->next) {
1359	<	#ifdef METH_NOARGS
1360	<	PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361	<	#else
1362	<	PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363	<	#endif
1364	<	PyString_ConcatAndDel(&repr,nrep);
1365	<	}
1366	<	return repr;
1367	<	}
1368	<
1369	<	SWIGRUNTIME int
1370	<	PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371	<	{
1372	<	#ifdef METH_NOARGS
1373	<	PyObject *repr = PySwigObject_repr(v);
1374	<	#else
1375	<	PyObject *repr = PySwigObject_repr(v, NULL);
1376	<	#endif
1377	<	if (repr) {
1378	<	fputs(PyString_AsString(repr), fp);
1379	<	Py_DECREF(repr);
1380	<	return 0;
1381	<	} else {
1382	<	return 1;
1383	<	}
1384	<	}
1385	<
1386	<	SWIGRUNTIME PyObject *
1387	<	PySwigObject_str(PySwigObject *v)
1388	<	{
1389	<	char result[SWIG_BUFFER_SIZE];
1390	<	return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391	<	PyString_FromString(result) : 0;
1392	<	}
1393	<
1394	<	SWIGRUNTIME int
1395	<	PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396	<	{
1397	<	void *i = v->ptr;
1398	<	void *j = w->ptr;
1399	<	return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400	<	}
303	>	swig_globalvar *vars;
304	>	} swig_varlinkobject;
305
306	<	SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
307	<
308	<	SWIGRUNTIME PyTypeObject*
309	<	PySwigObject_type(void) {
1406	<	static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407	<	return type;
1408	<	}
1409	<
1410	<	SWIGRUNTIMEINLINE int
1411	<	PySwigObject_Check(PyObject *op) {
1412	<	return ((op)->ob_type == PySwigObject_type())
1413	<	|| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414	<	}
1415	<
1416	<	SWIGRUNTIME PyObject *
1417	<	PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418	<
1419	<	SWIGRUNTIME void
1420	<	PySwigObject_dealloc(PyObject *v)
1421	<	{
1422	<	PySwigObject *sobj = (PySwigObject *) v;
1423	<	PyObject *next = sobj->next;
1424	<	if (sobj->own) {
1425	<	swig_type_info *ty = sobj->ty;
1426	<	PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427	<	PyObject *destroy = data ? data->destroy : 0;
1428	<	if (destroy) {
1429	<	/* destroy is always a VARARGS method */
1430	<	PyObject *res;
1431	<	if (data->delargs) {
1432	<	/* we need to create a temporal object to carry the destroy operation */
1433	<	PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434	<	res = SWIG_Python_CallFunctor(destroy, tmp);
1435	<	Py_DECREF(tmp);
1436	<	} else {
1437	<	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438	<	PyObject *mself = PyCFunction_GET_SELF(destroy);
1439	<	res = ((*meth)(mself, v));
1440	<	}
1441	<	Py_XDECREF(res);
1442	<	} else {
1443	<	const char *name = SWIG_TypePrettyName(ty);
1444	<	#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445	<	printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446	<	#endif
1447	<	}
1448	<	}
1449	<	Py_XDECREF(next);
1450	<	PyObject_DEL(v);
306	>	static PyObject *
307	>	swig_varlink_repr(swig_varlinkobject *v) {
308	>	v = v;
309	>	return PyString_FromString("<Global variables>");
310		}
311
312	<	SWIGRUNTIME PyObject*
313	<	PySwigObject_append(PyObject* v, PyObject* next)
314	<	{
315	<	PySwigObject *sobj = (PySwigObject *) v;
316	<	#ifndef METH_O
317	<	PyObject *tmp = 0;
318	<	if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
319	<	next = tmp;
1461	<	#endif
1462	<	if (!PySwigObject_Check(next)) {
1463	<	return NULL;
312	>	static int
313	>	swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
314	>	swig_globalvar  *var;
315	>	flags = flags;
316	>	fprintf(fp,"Global variables { ");
317	>	for (var = v->vars; var; var=var->next) {
318	>	fprintf(fp,"%s", var->name);
319	>	if (var->next) fprintf(fp,", ");
320		}
321	<	sobj->next = next;
322	<	Py_INCREF(next);
1467	<	return SWIG_Py_Void();
1468	<	}
1469	<
1470	<	SWIGRUNTIME PyObject*
1471	<	#ifdef METH_NOARGS
1472	<	PySwigObject_next(PyObject* v)
1473	<	#else
1474	<	PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475	<	#endif
1476	<	{
1477	<	PySwigObject *sobj = (PySwigObject *) v;
1478	<	if (sobj->next) {
1479	<	Py_INCREF(sobj->next);
1480	<	return sobj->next;
1481	<	} else {
1482	<	return SWIG_Py_Void();
1483	<	}
1484	<	}
1485	<
1486	<	SWIGINTERN PyObject*
1487	<	#ifdef METH_NOARGS
1488	<	PySwigObject_disown(PyObject *v)
1489	<	#else
1490	<	PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491	<	#endif
1492	<	{
1493	<	PySwigObject *sobj = (PySwigObject *)v;
1494	<	sobj->own = 0;
1495	<	return SWIG_Py_Void();
1496	<	}
1497	<
1498	<	SWIGINTERN PyObject*
1499	<	#ifdef METH_NOARGS
1500	<	PySwigObject_acquire(PyObject *v)
1501	<	#else
1502	<	PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503	<	#endif
1504	<	{
1505	<	PySwigObject *sobj = (PySwigObject *)v;
1506	<	sobj->own = SWIG_POINTER_OWN;
1507	<	return SWIG_Py_Void();
321	>	fprintf(fp," }\n");
322	>	return 0;
323		}
324
325	<	SWIGINTERN PyObject*
326	<	PySwigObject_own(PyObject *v, PyObject *args)
327	<	{
328	<	PyObject *val = 0;
329	<	#if (PY_VERSION_HEX < 0x02020000)
330	<	if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
331	<	#else
332	<	if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
333	<	#endif
334	<	{
335	<	return NULL;
1521	<	}
1522	<	else
1523	<	{
1524	<	PySwigObject *sobj = (PySwigObject *)v;
1525	<	PyObject *obj = PyBool_FromLong(sobj->own);
1526	<	if (val) {
1527	<	#ifdef METH_NOARGS
1528	<	if (PyObject_IsTrue(val)) {
1529	<	PySwigObject_acquire(v);
1530	<	} else {
1531	<	PySwigObject_disown(v);
1532	<	}
1533	<	#else
1534	<	if (PyObject_IsTrue(val)) {
1535	<	PySwigObject_acquire(v,args);
1536	<	} else {
1537	<	PySwigObject_disown(v,args);
1538	<	}
1539	<	#endif
1540	<	}
1541	<	return obj;
1542	<	}
325	>	static PyObject *
326	>	swig_varlink_getattr(swig_varlinkobject *v, char *n) {
327	>	swig_globalvar *var = v->vars;
328	>	while (var) {
329	>	if (strcmp(var->name,n) == 0) {
330	>	return (*var->get_attr)();
331	>	}
332	>	var = var->next;
333	>	}
334	>	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
335	>	return NULL;
336		}
337
338	<	#ifdef METH_O
339	<	static PyMethodDef
340	<	swigobject_methods[] = {
341	<	{(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
342	<	{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
343	<	{(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
344	<	{(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
345	<	{(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
346	<	{(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
347	<	{0, 0, 0, 0}
348	<	};
349	<	#else
350	<	static PyMethodDef
351	<	swigobject_methods[] = {
352	<	{(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
353	<	{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
354	<	{(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
355	<	{(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
356	<	{(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
357	<	{(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
358	<	{0, 0, 0, 0}
338	>	static int
339	>	swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
340	>	swig_globalvar *var = v->vars;
341	>	while (var) {
342	>	if (strcmp(var->name,n) == 0) {
343	>	return (*var->set_attr)(p);
344	>	}
345	>	var = var->next;
346	>	}
347	>	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
348	>	return 1;
349	>	}
350	>
351	>	statichere PyTypeObject varlinktype = {
352	>	PyObject_HEAD_INIT(0)
353	>	0,
354	>	(char *)"swigvarlink",                      /* Type name    */
355	>	sizeof(swig_varlinkobject),         /* Basic size   */
356	>	0,                                  /* Itemsize     */
357	>	0,                                  /* Deallocator  */
358	>	(printfunc) swig_varlink_print,     /* Print        */
359	>	(getattrfunc) swig_varlink_getattr, /* get attr     */
360	>	(setattrfunc) swig_varlink_setattr, /* Set attr     */
361	>	0,                                  /* tp_compare   */
362	>	(reprfunc) swig_varlink_repr,       /* tp_repr      */
363	>	0,                                  /* tp_as_number */
364	>	0,                                  /* tp_as_mapping*/
365	>	0,                                  /* tp_hash      */
366		};
1567	–	#endif
1568	–
1569	–	#if PY_VERSION_HEX < 0x02020000
1570	–	SWIGINTERN PyObject *
1571	–	PySwigObject_getattr(PySwigObject *sobj,char *name)
1572	–	{
1573	–	return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574	–	}
1575	–	#endif
1576	–
1577	–	SWIGRUNTIME PyTypeObject*
1578	–	_PySwigObject_type(void) {
1579	–	static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580	–
1581	–	static PyNumberMethods PySwigObject_as_number = {
1582	–	(binaryfunc)0, /*nb_add*/
1583	–	(binaryfunc)0, /*nb_subtract*/
1584	–	(binaryfunc)0, /*nb_multiply*/
1585	–	(binaryfunc)0, /*nb_divide*/
1586	–	(binaryfunc)0, /*nb_remainder*/
1587	–	(binaryfunc)0, /*nb_divmod*/
1588	–	(ternaryfunc)0,/*nb_power*/
1589	–	(unaryfunc)0,  /*nb_negative*/
1590	–	(unaryfunc)0,  /*nb_positive*/
1591	–	(unaryfunc)0,  /*nb_absolute*/
1592	–	(inquiry)0,    /*nb_nonzero*/
1593	–	0,             /*nb_invert*/
1594	–	0,             /*nb_lshift*/
1595	–	0,             /*nb_rshift*/
1596	–	0,             /*nb_and*/
1597	–	0,             /*nb_xor*/
1598	–	0,             /*nb_or*/
1599	–	(coercion)0,   /*nb_coerce*/
1600	–	(unaryfunc)PySwigObject_long, /*nb_int*/
1601	–	(unaryfunc)PySwigObject_long, /*nb_long*/
1602	–	(unaryfunc)0,                 /*nb_float*/
1603	–	(unaryfunc)PySwigObject_oct,  /*nb_oct*/
1604	–	(unaryfunc)PySwigObject_hex,  /*nb_hex*/
1605	–	#if PY_VERSION_HEX >= 0x02020000
1606	–	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607	–	#elif PY_VERSION_HEX >= 0x02000000
1608	–	0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609	–	#endif
1610	–	};
1611	–
1612	–	static PyTypeObject pyswigobject_type;
1613	–	static int type_init = 0;
1614	–	if (!type_init) {
1615	–	const PyTypeObject tmp
1616	–	= {
1617	–	PyObject_HEAD_INIT(NULL)
1618	–	0,                                  /* ob_size */
1619	–	(char *)"PySwigObject",             /* tp_name */
1620	–	sizeof(PySwigObject),               /* tp_basicsize */
1621	–	0,                                  /* tp_itemsize */
1622	–	(destructor)PySwigObject_dealloc,   /* tp_dealloc */
1623	–	(printfunc)PySwigObject_print,      /* tp_print */
1624	–	#if PY_VERSION_HEX < 0x02020000
1625	–	(getattrfunc)PySwigObject_getattr,  /* tp_getattr */
1626	–	#else
1627	–	(getattrfunc)0,                     /* tp_getattr */
1628	–	#endif
1629	–	(setattrfunc)0,                     /* tp_setattr */
1630	–	(cmpfunc)PySwigObject_compare,      /* tp_compare */
1631	–	(reprfunc)PySwigObject_repr,        /* tp_repr */
1632	–	&PySwigObject_as_number,            /* tp_as_number */
1633	–	0,                                  /* tp_as_sequence */
1634	–	0,                                  /* tp_as_mapping */
1635	–	(hashfunc)0,                        /* tp_hash */
1636	–	(ternaryfunc)0,                     /* tp_call */
1637	–	(reprfunc)PySwigObject_str,         /* tp_str */
1638	–	PyObject_GenericGetAttr,            /* tp_getattro */
1639	–	0,                                  /* tp_setattro */
1640	–	0,                                  /* tp_as_buffer */
1641	–	Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1642	–	swigobject_doc,                     /* tp_doc */
1643	–	0,                                  /* tp_traverse */
1644	–	0,                                  /* tp_clear */
1645	–	0,                                  /* tp_richcompare */
1646	–	0,                                  /* tp_weaklistoffset */
1647	–	#if PY_VERSION_HEX >= 0x02020000
1648	–	0,                                  /* tp_iter */
1649	–	0,                                  /* tp_iternext */
1650	–	swigobject_methods,                 /* tp_methods */
1651	–	0,                                  /* tp_members */
1652	–	0,                                  /* tp_getset */
1653	–	0,                                  /* tp_base */
1654	–	0,                                  /* tp_dict */
1655	–	0,                                  /* tp_descr_get */
1656	–	0,                                  /* tp_descr_set */
1657	–	0,                                  /* tp_dictoffset */
1658	–	0,                                  /* tp_init */
1659	–	0,                                  /* tp_alloc */
1660	–	0,                                  /* tp_new */
1661	–	0,                                  /* tp_free */
1662	–	0,                                  /* tp_is_gc */
1663	–	0,                                  /* tp_bases */
1664	–	0,                                  /* tp_mro */
1665	–	0,                                  /* tp_cache */
1666	–	0,                                  /* tp_subclasses */
1667	–	0,                                  /* tp_weaklist */
1668	–	#endif
1669	–	#if PY_VERSION_HEX >= 0x02030000
1670	–	0,                                  /* tp_del */
1671	–	#endif
1672	–	#ifdef COUNT_ALLOCS
1673	–	0,0,0,0                             /* tp_alloc -> tp_next */
1674	–	#endif
1675	–	};
1676	–	pyswigobject_type = tmp;
1677	–	pyswigobject_type.ob_type = &PyType_Type;
1678	–	type_init = 1;
1679	–	}
1680	–	return &pyswigobject_type;
1681	–	}
1682	–
1683	–	SWIGRUNTIME PyObject *
1684	–	PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685	–	{
1686	–	PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687	–	if (sobj) {
1688	–	sobj->ptr  = ptr;
1689	–	sobj->ty   = ty;
1690	–	sobj->own  = own;
1691	–	sobj->next = 0;
1692	–	}
1693	–	return (PyObject *)sobj;
1694	–	}
1695	–
1696	–	/* -----------------------------------------------------------------------------
1697	–	* Implements a simple Swig Packed type, and use it instead of string
1698	–	* ----------------------------------------------------------------------------- */
1699	–
1700	–	typedef struct {
1701	–	PyObject_HEAD
1702	–	void *pack;
1703	–	swig_type_info *ty;
1704	–	size_t size;
1705	–	} PySwigPacked;
367
368	<	SWIGRUNTIME int
369	<	PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
370	<	{
371	<	char result[SWIG_BUFFER_SIZE];
372	<	fputs("<Swig Packed ", fp);
373	<	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
374	<	fputs("at ", fp);
375	<	fputs(result, fp);
376	<	}
377	<	fputs(v->ty->name,fp);
378	<	fputs(">", fp);
379	<	return 0;
380	<	}
381	<
382	<	SWIGRUNTIME PyObject *
383	<	PySwigPacked_repr(PySwigPacked *v)
384	<	{
385	<	char result[SWIG_BUFFER_SIZE];
386	<	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
387	<	return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
388	<	} else {
389	<	return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
390	<	}
391	<	}
392	<
393	<	SWIGRUNTIME PyObject *
394	<	PySwigPacked_str(PySwigPacked *v)
395	<	{
396	<	char result[SWIG_BUFFER_SIZE];
397	<	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
398	<	return PyString_FromFormat("%s%s", result, v->ty->name);
399	<	} else {
400	<	return PyString_FromString(v->ty->name);
401	<	}
402	<	}
403	<
404	<	SWIGRUNTIME int
405	<	PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
406	<	{
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);
368	>	/* Create a variable linking object for use later */
369	>	SWIGRUNTIME(PyObject *)
370	>	SWIG_newvarlink(void) {
371	>	swig_varlinkobject *result = 0;
372	>	result = PyMem_NEW(swig_varlinkobject,1);
373	>	varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
374	>	result->ob_type = &varlinktype;
375	>	result->vars = 0;
376	>	result->ob_refcnt = 0;
377	>	Py_XINCREF((PyObject *) result);
378	>	return ((PyObject*) result);
379	>	}
380	>
381	>	SWIGRUNTIME(void)
382	>	SWIG_addvarlink(PyObject *p, char *name,
383	>	PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
384	>	swig_varlinkobject *v;
385	>	swig_globalvar *gv;
386	>	v= (swig_varlinkobject *) p;
387	>	gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
388	>	gv->name = (char *) malloc(strlen(name)+1);
389	>	strcpy(gv->name,name);
390	>	gv->get_attr = get_attr;
391	>	gv->set_attr = set_attr;
392	>	gv->next = v->vars;
393	>	v->vars = gv;
394	>	}
395	>
396	>	/* Pack binary data into a string */
397	>	SWIGRUNTIME(char *)
398	>	SWIG_PackData(char *c, void *ptr, int sz) {
399	>	static char hex[17] = "0123456789abcdef";
400	>	int i;
401	>	unsigned char *u = (unsigned char *) ptr;
402	>	register unsigned char uu;
403	>	for (i = 0; i < sz; i++,u++) {
404	>	uu = *u;
405	>	*(c++) = hex[(uu & 0xf0) >> 4];
406	>	*(c++) = hex[uu & 0xf];
407		}
408	<	PyObject_DEL(v);
408	>	return c;
409		}
410
411	<	SWIGRUNTIME PyTypeObject*
412	<	_PySwigPacked_type(void) {
413	<	static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
414	<	static PyTypeObject pyswigpacked_type;
415	<	static int type_init = 0;
416	<	if (!type_init) {
417	<	const PyTypeObject tmp
418	<	= {
419	<	PyObject_HEAD_INIT(NULL)
420	<	0,                                  /* ob_size */
421	<	(char *)"PySwigPacked",             /* tp_name */
422	<	sizeof(PySwigPacked),               /* tp_basicsize */
423	<	0,                                  /* tp_itemsize */
424	<	(destructor)PySwigPacked_dealloc,   /* tp_dealloc */
425	<	(printfunc)PySwigPacked_print,      /* tp_print */
426	<	(getattrfunc)0,                     /* tp_getattr */
427	<	(setattrfunc)0,                     /* tp_setattr */
428	<	(cmpfunc)PySwigPacked_compare,      /* tp_compare */
429	<	(reprfunc)PySwigPacked_repr,        /* tp_repr */
1795	<	0,                                  /* tp_as_number */
1796	<	0,                                  /* tp_as_sequence */
1797	<	0,                                  /* tp_as_mapping */
1798	<	(hashfunc)0,                        /* tp_hash */
1799	<	(ternaryfunc)0,                     /* tp_call */
1800	<	(reprfunc)PySwigPacked_str,         /* tp_str */
1801	<	PyObject_GenericGetAttr,            /* tp_getattro */
1802	<	0,                                  /* tp_setattro */
1803	<	0,                                  /* tp_as_buffer */
1804	<	Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1805	<	swigpacked_doc,                     /* tp_doc */
1806	<	0,                                  /* tp_traverse */
1807	<	0,                                  /* tp_clear */
1808	<	0,                                  /* tp_richcompare */
1809	<	0,                                  /* tp_weaklistoffset */
1810	<	#if PY_VERSION_HEX >= 0x02020000
1811	<	0,                                  /* tp_iter */
1812	<	0,                                  /* tp_iternext */
1813	<	0,                                  /* tp_methods */
1814	<	0,                                  /* tp_members */
1815	<	0,                                  /* tp_getset */
1816	<	0,                                  /* tp_base */
1817	<	0,                                  /* tp_dict */
1818	<	0,                                  /* tp_descr_get */
1819	<	0,                                  /* tp_descr_set */
1820	<	0,                                  /* tp_dictoffset */
1821	<	0,                                  /* tp_init */
1822	<	0,                                  /* tp_alloc */
1823	<	0,                                  /* tp_new */
1824	<	0,                                  /* tp_free */
1825	<	0,                                  /* tp_is_gc */
1826	<	0,                                  /* tp_bases */
1827	<	0,                                  /* tp_mro */
1828	<	0,                                  /* tp_cache */
1829	<	0,                                  /* tp_subclasses */
1830	<	0,                                  /* tp_weaklist */
1831	<	#endif
1832	<	#if PY_VERSION_HEX >= 0x02030000
1833	<	0,                                  /* tp_del */
1834	<	#endif
1835	<	#ifdef COUNT_ALLOCS
1836	<	0,0,0,0                             /* tp_alloc -> tp_next */
1837	<	#endif
1838	<	};
1839	<	pyswigpacked_type = tmp;
1840	<	pyswigpacked_type.ob_type = &PyType_Type;
1841	<	type_init = 1;
411	>	/* Unpack binary data from a string */
412	>	SWIGRUNTIME(char *)
413	>	SWIG_UnpackData(char *c, void *ptr, int sz) {
414	>	register unsigned char uu = 0;
415	>	register int d;
416	>	unsigned char *u = (unsigned char *) ptr;
417	>	int i;
418	>	for (i = 0; i < sz; i++, u++) {
419	>	d = *(c++);
420	>	if ((d >= '0') && (d <= '9'))
421	>	uu = ((d - '0') << 4);
422	>	else if ((d >= 'a') && (d <= 'f'))
423	>	uu = ((d - ('a'-10)) << 4);
424	>	d = *(c++);
425	>	if ((d >= '0') && (d <= '9'))
426	>	uu |= (d - '0');
427	>	else if ((d >= 'a') && (d <= 'f'))
428	>	uu |= (d - ('a'-10));
429	>	*u = uu;
430		}
431	<	return &pyswigpacked_type;
431	>	return c;
432		}
433
434	<	SWIGRUNTIME PyObject *
435	<	PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
436	<	{
437	<	PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
438	<	if (sobj) {
439	<	void *pack = malloc(size);
440	<	if (pack) {
441	<	memcpy(pack, ptr, size);
1854	<	sobj->pack = pack;
1855	<	sobj->ty   = ty;
1856	<	sobj->size = size;
1857	<	} else {
1858	<	PyObject_DEL((PyObject *) sobj);
1859	<	sobj = 0;
1860	<	}
1861	<	}
1862	<	return (PyObject *) sobj;
1863	<	}
434	>	/* Convert a pointer value */
435	>	SWIGRUNTIME(int)
436	>	SWIG_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
437	>	swig_type_info *tc;
438	>	char  *c;
439	>	static PyObject *SWIG_this = 0;
440	>	int    newref = 0;
441	>	PyObject  *pyobj = 0;
442
443	<	SWIGRUNTIME swig_type_info *
444	<	PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
445	<	{
1868	<	if (PySwigPacked_Check(obj)) {
1869	<	PySwigPacked *sobj = (PySwigPacked *)obj;
1870	<	if (sobj->size != size) return 0;
1871	<	memcpy(ptr, sobj->pack, size);
1872	<	return sobj->ty;
1873	<	} else {
443	>	if (!obj) return 0;
444	>	if (obj == Py_None) {
445	>	*ptr = 0;
446		return 0;
447		}
448	<	}
449	<
450	<	/* -----------------------------------------------------------------------------
451	<	* pointers/data manipulation
452	<	* ----------------------------------------------------------------------------- */
453	<
454	<	SWIGRUNTIMEINLINE PyObject *
455	<	_SWIG_This(void)
456	<	{
457	<	return PyString_FromString("this");
458	<	}
1887	<
1888	<	SWIGRUNTIME PyObject *
1889	<	SWIG_This(void)
1890	<	{
1891	<	static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892	<	return swig_this;
1893	<	}
1894	<
1895	<	/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896	<
1897	<	SWIGRUNTIME PySwigObject *
1898	<	SWIG_Python_GetSwigThis(PyObject *pyobj)
1899	<	{
1900	<	if (PySwigObject_Check(pyobj)) {
1901	<	return (PySwigObject *) pyobj;
1902	<	} else {
1903	<	PyObject *obj = 0;
1904	<	#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905	<	if (PyInstance_Check(pyobj)) {
1906	<	obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907	<	} else {
1908	<	PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909	<	if (dictptr != NULL) {
1910	<	PyObject *dict = *dictptr;
1911	<	obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912	<	} else {
1913	<	#ifdef PyWeakref_CheckProxy
1914	<	if (PyWeakref_CheckProxy(pyobj)) {
1915	<	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916	<	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917	<	}
1918	<	#endif
1919	<	obj = PyObject_GetAttr(pyobj,SWIG_This());
1920	<	if (obj) {
1921	<	Py_DECREF(obj);
1922	<	} else {
1923	<	if (PyErr_Occurred()) PyErr_Clear();
1924	<	return 0;
1925	<	}
1926	<	}
448	>	#ifdef SWIG_COBJECT_TYPES
449	>	if (!(PyCObject_Check(obj))) {
450	>	if (!SWIG_this)
451	>	SWIG_this = PyString_FromString("this");
452	>	pyobj = obj;
453	>	obj = PyObject_GetAttr(obj,SWIG_this);
454	>	newref = 1;
455	>	if (!obj) goto type_error;
456	>	if (!PyCObject_Check(obj)) {
457	>	Py_DECREF(obj);
458	>	goto type_error;
459		}
460	+	}
461	+	*ptr = PyCObject_AsVoidPtr(obj);
462	+	c = (char *) PyCObject_GetDesc(obj);
463	+	if (newref) Py_DECREF(obj);
464	+	goto cobject;
465		#else
466	<	obj = PyObject_GetAttr(pyobj,SWIG_This());
467	<	if (obj) {
466	>	if (!(PyString_Check(obj))) {
467	>	if (!SWIG_this)
468	>	SWIG_this = PyString_FromString("this");
469	>	pyobj = obj;
470	>	obj = PyObject_GetAttr(obj,SWIG_this);
471	>	newref = 1;
472	>	if (!obj) goto type_error;
473	>	if (!PyString_Check(obj)) {
474		Py_DECREF(obj);
475	<	} else {
1933	<	if (PyErr_Occurred()) PyErr_Clear();
1934	<	return 0;
475	>	goto type_error;
476		}
477	<	#endif
478	<	if (obj && !PySwigObject_Check(obj)) {
479	<	/* a PyObject is called 'this', try to get the 'real this'
480	<	PySwigObject from it */
481	<	return SWIG_Python_GetSwigThis(obj);
477	>	}
478	>	c = PyString_AsString(obj);
479	>	/* Pointer values must start with leading underscore */
480	>	if (*c != '_') {
481	>	*ptr = (void *) 0;
482	>	if (strcmp(c,"NULL") == 0) {
483	>	if (newref) { Py_DECREF(obj); }
484	>	return 0;
485	>	} else {
486	>	if (newref) { Py_DECREF(obj); }
487	>	goto type_error;
488		}
1942	–	return (PySwigObject *)obj;
489		}
490	<	}
490	>	c++;
491	>	c = SWIG_UnpackData(c,ptr,sizeof(void *));
492	>	if (newref) { Py_DECREF(obj); }
493	>	#endif
494
495	<	/* Acquire a pointer value */
495	>	#ifdef SWIG_COBJECT_TYPES
496	>	cobject:
497	>	#endif
498
499	<	SWIGRUNTIME int
500	<	SWIG_Python_AcquirePtr(PyObject *obj, int own) {
501	<	if (own) {
502	<	PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952	<	if (sobj) {
1953	<	int oldown = sobj->own;
1954	<	sobj->own = own;
1955	<	return oldown;
1956	<	}
499	>	if (ty) {
500	>	tc = SWIG_TypeCheck(c,ty);
501	>	if (!tc) goto type_error;
502	>	*ptr = SWIG_TypeCast(tc,(void*) *ptr);
503		}
1958	–	return 0;
1959	–	}
504
505	<	/* Convert a pointer value */
506	<
507	<	SWIGRUNTIME int
508	<	SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965	<	if (!obj) return SWIG_ERROR;
1966	<	if (obj == Py_None) {
1967	<	if (ptr) *ptr = 0;
1968	<	return SWIG_OK;
1969	<	} else {
1970	<	PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971	<	while (sobj) {
1972	<	void *vptr = sobj->ptr;
1973	<	if (ty) {
1974	<	swig_type_info *to = sobj->ty;
1975	<	if (to == ty) {
1976	<	/* no type cast needed */
1977	<	if (ptr) *ptr = vptr;
1978	<	break;
1979	<	} else {
1980	<	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981	<	if (!tc) {
1982	<	sobj = (PySwigObject *)sobj->next;
1983	<	} else {
1984	<	if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985	<	break;
1986	<	}
1987	<	}
1988	<	} else {
1989	<	if (ptr) *ptr = vptr;
1990	<	break;
1991	<	}
1992	<	}
1993	<	if (sobj) {
1994	<	if (own) *own = sobj->own;
1995	<	if (flags & SWIG_POINTER_DISOWN) {
1996	<	sobj->own = 0;
1997	<	}
1998	<	return SWIG_OK;
1999	<	} else {
2000	<	int res = SWIG_ERROR;
2001	<	if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002	<	PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003	<	if (data && !data->implicitconv) {
2004	<	PyObject *klass = data->klass;
2005	<	if (klass) {
2006	<	PyObject *impconv;
2007	<	data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008	<	impconv = SWIG_Python_CallFunctor(klass, obj);
2009	<	data->implicitconv = 0;
2010	<	if (PyErr_Occurred()) {
2011	<	PyErr_Clear();
2012	<	impconv = 0;
2013	<	}
2014	<	if (impconv) {
2015	<	PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016	<	if (iobj) {
2017	<	void *vptr;
2018	<	res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019	<	if (SWIG_IsOK(res)) {
2020	<	if (ptr) {
2021	<	*ptr = vptr;
2022	<	/* transfer the ownership to 'ptr' */
2023	<	iobj->own = 0;
2024	<	res = SWIG_AddCast(res);
2025	<	res = SWIG_AddNewMask(res);
2026	<	} else {
2027	<	res = SWIG_AddCast(res);
2028	<	}
2029	<	}
2030	<	}
2031	<	Py_DECREF(impconv);
2032	<	}
2033	<	}
2034	<	}
2035	<	}
2036	<	return res;
2037	<	}
505	>	if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
506	>	PyObject *zero = PyInt_FromLong(0);
507	>	PyObject_SetAttrString(pyobj,(char*)"thisown",zero);
508	>	Py_DECREF(zero);
509		}
510	<	}
2040	<
2041	<	/* Convert a function ptr value */
510	>	return 0;
511
512	<	SWIGRUNTIME int
513	<	SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045	<	if (!PyCFunction_Check(obj)) {
2046	<	return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047	<	} else {
2048	<	void *vptr = 0;
2049	<
2050	<	/* here we get the method pointer for callbacks */
2051	<	char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052	<	const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053	<	if (desc) {
2054	<	desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055	<	if (!desc) return SWIG_ERROR;
2056	<	}
512	>	type_error:
513	>	if (flags & SWIG_POINTER_EXCEPTION) {
514		if (ty) {
515	<	swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
516	<	if (!tc) return SWIG_ERROR;
517	<	*ptr = SWIG_TypeCast(tc,vptr);
515	>	char *temp = (char *) malloc(64+strlen(ty->name));
516	>	sprintf(temp,"Type error. Expected %s", ty->name);
517	>	PyErr_SetString(PyExc_TypeError, temp);
518	>	free((char *) temp);
519		} else {
520	<	*ptr = vptr;
520	>	PyErr_SetString(PyExc_TypeError,"Expected a pointer");
521		}
2064	–	return SWIG_OK;
522		}
523	+	return -1;
524		}
525
526		/* Convert a packed value value */
527	<
528	<	SWIGRUNTIME int
529	<	SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
530	<	swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
531	<	if (!to) return SWIG_ERROR;
527	>	SWIGRUNTIME(int)
528	>	SWIG_ConvertPacked(PyObject *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
529	>	swig_type_info *tc;
530	>	char  *c;
531	>
532	>	if ((!obj) || (!PyString_Check(obj))) goto type_error;
533	>	c = PyString_AsString(obj);
534	>	/* Pointer values must start with leading underscore */
535	>	if (*c != '_') goto type_error;
536	>	c++;
537	>	c = SWIG_UnpackData(c,ptr,sz);
538		if (ty) {
539	<	if (to != ty) {
540	<	/* check type cast? */
2077	<	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078	<	if (!tc) return SWIG_ERROR;
2079	<	}
2080	<	}
2081	<	return SWIG_OK;
2082	<	}
2083	<
2084	<	/* -----------------------------------------------------------------------------
2085	<	* Create a new pointer object
2086	<	* ----------------------------------------------------------------------------- */
2087	<
2088	<	/*
2089	<	Create a new instance object, whitout calling __init__, and set the
2090	<	'this' attribute.
2091	<	*/
2092	<
2093	<	SWIGRUNTIME PyObject*
2094	<	SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095	<	{
2096	<	#if (PY_VERSION_HEX >= 0x02020000)
2097	<	PyObject *inst = 0;
2098	<	PyObject *newraw = data->newraw;
2099	<	if (newraw) {
2100	<	inst = PyObject_Call(newraw, data->newargs, NULL);
2101	<	if (inst) {
2102	<	#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103	<	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104	<	if (dictptr != NULL) {
2105	<	PyObject *dict = *dictptr;
2106	<	if (dict == NULL) {
2107	<	dict = PyDict_New();
2108	<	*dictptr = dict;
2109	<	PyDict_SetItem(dict, SWIG_This(), swig_this);
2110	<	}
2111	<	}
2112	<	#else
2113	<	PyObject *key = SWIG_This();
2114	<	PyObject_SetAttr(inst, key, swig_this);
2115	<	#endif
2116	<	}
2117	<	} else {
2118	<	PyObject *dict = PyDict_New();
2119	<	PyDict_SetItem(dict, SWIG_This(), swig_this);
2120	<	inst = PyInstance_NewRaw(data->newargs, dict);
2121	<	Py_DECREF(dict);
539	>	tc = SWIG_TypeCheck(c,ty);
540	>	if (!tc) goto type_error;
541		}
542	<	return inst;
2124	<	#else
2125	<	#if (PY_VERSION_HEX >= 0x02010000)
2126	<	PyObject *inst;
2127	<	PyObject *dict = PyDict_New();
2128	<	PyDict_SetItem(dict, SWIG_This(), swig_this);
2129	<	inst = PyInstance_NewRaw(data->newargs, dict);
2130	<	Py_DECREF(dict);
2131	<	return (PyObject *) inst;
2132	<	#else
2133	<	PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134	<	if (inst == NULL) {
2135	<	return NULL;
2136	<	}
2137	<	inst->in_class = (PyClassObject *)data->newargs;
2138	<	Py_INCREF(inst->in_class);
2139	<	inst->in_dict = PyDict_New();
2140	<	if (inst->in_dict == NULL) {
2141	<	Py_DECREF(inst);
2142	<	return NULL;
2143	<	}
2144	<	#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145	<	inst->in_weakreflist = NULL;
2146	<	#endif
2147	<	#ifdef Py_TPFLAGS_GC
2148	<	PyObject_GC_Init(inst);
2149	<	#endif
2150	<	PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151	<	return (PyObject *) inst;
2152	<	#endif
2153	<	#endif
2154	<	}
2155	<
2156	<	SWIGRUNTIME void
2157	<	SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158	<	{
2159	<	PyObject *dict;
2160	<	#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161	<	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162	<	if (dictptr != NULL) {
2163	<	dict = *dictptr;
2164	<	if (dict == NULL) {
2165	<	dict = PyDict_New();
2166	<	*dictptr = dict;
2167	<	}
2168	<	PyDict_SetItem(dict, SWIG_This(), swig_this);
2169	<	return;
2170	<	}
2171	<	#endif
2172	<	dict = PyObject_GetAttrString(inst, "__dict__");
2173	<	PyDict_SetItem(dict, SWIG_This(), swig_this);
2174	<	Py_DECREF(dict);
2175	<	}
542	>	return 0;
543
544	+	type_error:
545
546	<	SWIGINTERN PyObject *
547	<	SWIG_Python_InitShadowInstance(PyObject *args) {
548	<	PyObject *obj[2];
549	<	if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
550	<	return NULL;
551	<	} else {
2184	<	PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185	<	if (sthis) {
2186	<	PySwigObject_append((PyObject*) sthis, obj[1]);
546	>	if (flags) {
547	>	if (ty) {
548	>	char *temp = (char *) malloc(64+strlen(ty->name));
549	>	sprintf(temp,"Type error. Expected %s", ty->name);
550	>	PyErr_SetString(PyExc_TypeError, temp);
551	>	free((char *) temp);
552		} else {
553	<	SWIG_Python_SetSwigThis(obj[0], obj[1]);
553	>	PyErr_SetString(PyExc_TypeError,"Expected a pointer");
554		}
2190	–	return SWIG_Py_Void();
555		}
556	+	return -1;
557		}
558
559		/* Create a new pointer object */
560	<
561	<	SWIGRUNTIME PyObject *
562	<	SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
560	>	SWIGRUNTIME(PyObject *)
561	>	SWIG_NewPointerObj(void *ptr, swig_type_info *type, int own) {
562	>	PyObject *robj;
563		if (!ptr) {
564	<	return SWIG_Py_Void();
565	<	} else {
2201	<	int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202	<	PyObject *robj = PySwigObject_New(ptr, type, own);
2203	<	PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204	<	if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205	<	PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206	<	if (inst) {
2207	<	Py_DECREF(robj);
2208	<	robj = inst;
2209	<	}
2210	<	}
2211	<	return robj;
564	>	Py_INCREF(Py_None);
565	>	return Py_None;
566		}
567	<	}
568	<
2215	<	/* Create a new packed object */
2216	<
2217	<	SWIGRUNTIMEINLINE PyObject *
2218	<	SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219	<	return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220	<	}
2221	<
2222	<	/* -----------------------------------------------------------------------------*
2223	<	*  Get type list
2224	<	* -----------------------------------------------------------------------------*/
2225	<
2226	<	#ifdef SWIG_LINK_RUNTIME
2227	<	void *SWIG_ReturnGlobalTypeList(void *);
2228	<	#endif
2229	<
2230	<	SWIGRUNTIME swig_module_info *
2231	<	SWIG_Python_GetModule(void) {
2232	<	static void *type_pointer = (void *)0;
2233	<	/* first check if module already created */
2234	<	if (!type_pointer) {
2235	<	#ifdef SWIG_LINK_RUNTIME
2236	<	type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
567	>	#ifdef SWIG_COBJECT_TYPES
568	>	robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL);
569		#else
570	<	type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
571	<	(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
572	<	if (PyErr_Occurred()) {
573	<	PyErr_Clear();
574	<	type_pointer = (void *)0;
575	<	}
576	<	#endif
2245	<	}
2246	<	return (swig_module_info *) type_pointer;
2247	<	}
2248	<
2249	<	#if PY_MAJOR_VERSION < 2
2250	<	/* PyModule_AddObject function was introduced in Python 2.0.  The following function
2251	<	is copied out of Python/modsupport.c in python version 2.3.4 */
2252	<	SWIGINTERN int
2253	<	PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254	<	{
2255	<	PyObject *dict;
2256	<	if (!PyModule_Check(m)) {
2257	<	PyErr_SetString(PyExc_TypeError,
2258	<	"PyModule_AddObject() needs module as first arg");
2259	<	return SWIG_ERROR;
2260	<	}
2261	<	if (!o) {
2262	<	PyErr_SetString(PyExc_TypeError,
2263	<	"PyModule_AddObject() needs non-NULL value");
2264	<	return SWIG_ERROR;
2265	<	}
2266	<
2267	<	dict = PyModule_GetDict(m);
2268	<	if (dict == NULL) {
2269	<	/* Internal error -- modules must have a dict! */
2270	<	PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271	<	PyModule_GetName(m));
2272	<	return SWIG_ERROR;
570	>	{
571	>	char result[1024];
572	>	char *r = result;
573	>	*(r++) = '_';
574	>	r = SWIG_PackData(r,&ptr,sizeof(void *));
575	>	strcpy(r,type->name);
576	>	robj = PyString_FromString(result);
577		}
2274	–	if (PyDict_SetItemString(dict, name, o))
2275	–	return SWIG_ERROR;
2276	–	Py_DECREF(o);
2277	–	return SWIG_OK;
2278	–	}
578		#endif
579	<
580	<	SWIGRUNTIME void
581	<	SWIG_Python_DestroyModule(void *vptr)
582	<	{
583	<	swig_module_info *swig_module = (swig_module_info *) vptr;
584	<	swig_type_info **types = swig_module->types;
585	<	size_t i;
586	<	for (i =0; i < swig_module->size; ++i) {
587	<	swig_type_info *ty = types[i];
588	<	if (ty->owndata) {
589	<	PySwigClientData *data = (PySwigClientData *) ty->clientdata;
590	<	if (data) PySwigClientData_Del(data);
2292	<	}
2293	<	}
2294	<	Py_DECREF(SWIG_This());
2295	<	}
2296	<
2297	<	SWIGRUNTIME void
2298	<	SWIG_Python_SetModule(swig_module_info *swig_module) {
2299	<	static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300	<
2301	<	PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302	<	swig_empty_runtime_method_table);
2303	<	PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304	<	if (pointer && module) {
2305	<	PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306	<	} else {
2307	<	Py_XDECREF(pointer);
2308	<	}
2309	<	}
2310	<
2311	<	/* The python cached type query */
2312	<	SWIGRUNTIME PyObject *
2313	<	SWIG_Python_TypeCache() {
2314	<	static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315	<	return cache;
2316	<	}
2317	<
2318	<	SWIGRUNTIME swig_type_info *
2319	<	SWIG_Python_TypeQuery(const char *type)
2320	<	{
2321	<	PyObject *cache = SWIG_Python_TypeCache();
2322	<	PyObject *key = PyString_FromString(type);
2323	<	PyObject *obj = PyDict_GetItem(cache, key);
2324	<	swig_type_info *descriptor;
2325	<	if (obj) {
2326	<	descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327	<	} else {
2328	<	swig_module_info *swig_module = SWIG_Python_GetModule();
2329	<	descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330	<	if (descriptor) {
2331	<	obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332	<	PyDict_SetItem(cache, key, obj);
2333	<	Py_DECREF(obj);
2334	<	}
2335	<	}
2336	<	Py_DECREF(key);
2337	<	return descriptor;
2338	<	}
2339	<
2340	<	/*
2341	<	For backward compatibility only
2342	<	*/
2343	<	#define SWIG_POINTER_EXCEPTION  0
2344	<	#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2345	<	#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346	<
2347	<	SWIGRUNTIME int
2348	<	SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349	<	{
2350	<	if (PyErr_Occurred()) {
2351	<	PyObject *type = 0;
2352	<	PyObject *value = 0;
2353	<	PyObject *traceback = 0;
2354	<	PyErr_Fetch(&type, &value, &traceback);
2355	<	if (value) {
2356	<	PyObject *old_str = PyObject_Str(value);
2357	<	Py_XINCREF(type);
2358	<	PyErr_Clear();
2359	<	if (infront) {
2360	<	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361	<	} else {
2362	<	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
579	>	if (!robj || (robj == Py_None)) return robj;
580	>	if (type->clientdata) {
581	>	PyObject *inst;
582	>	PyObject *args = Py_BuildValue((char*)"(O)", robj);
583	>	Py_DECREF(robj);
584	>	inst = PyObject_CallObject((PyObject *) type->clientdata, args);
585	>	Py_DECREF(args);
586	>	if (inst) {
587	>	if (own) {
588	>	PyObject *n = PyInt_FromLong(1);
589	>	PyObject_SetAttrString(inst,(char*)"thisown",n);
590	>	Py_DECREF(n);
591		}
592	<	Py_DECREF(old_str);
592	>	robj = inst;
593		}
2366	–	return 1;
2367	–	} else {
2368	–	return 0;
2369	–	}
2370	–	}
2371	–
2372	–	SWIGRUNTIME int
2373	–	SWIG_Python_ArgFail(int argnum)
2374	–	{
2375	–	if (PyErr_Occurred()) {
2376	–	/* add information about failing argument */
2377	–	char mesg[256];
2378	–	PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379	–	return SWIG_Python_AddErrMesg(mesg, 1);
2380	–	} else {
2381	–	return 0;
594		}
595	+	return robj;
596		}
597
598	<	SWIGRUNTIMEINLINE const char *
599	<	PySwigObject_GetDesc(PyObject *self)
600	<	{
601	<	PySwigObject *v = (PySwigObject *)self;
602	<	swig_type_info *ty = v ? v->ty : 0;
603	<	return ty ? ty->str : (char*)"";
604	<	}
605	<
606	<	SWIGRUNTIME void
2394	<	SWIG_Python_TypeError(const char *type, PyObject *obj)
2395	<	{
2396	<	if (type) {
2397	<	#if defined(SWIG_COBJECT_TYPES)
2398	<	if (obj && PySwigObject_Check(obj)) {
2399	<	const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400	<	if (otype) {
2401	<	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402	<	type, otype);
2403	<	return;
2404	<	}
2405	<	} else
2406	<	#endif
2407	<	{
2408	<	const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409	<	if (otype) {
2410	<	PyObject *str = PyObject_Str(obj);
2411	<	const char *cstr = str ? PyString_AsString(str) : 0;
2412	<	if (cstr) {
2413	<	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414	<	type, otype, cstr);
2415	<	} else {
2416	<	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417	<	type, otype);
2418	<	}
2419	<	Py_XDECREF(str);
2420	<	return;
2421	<	}
2422	<	}
2423	<	PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424	<	} else {
2425	<	PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426	<	}
598	>	SWIGRUNTIME(PyObject *)
599	>	SWIG_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
600	>	char result[1024];
601	>	char *r = result;
602	>	if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
603	>	*(r++) = '_';
604	>	r = SWIG_PackData(r,ptr,sz);
605	>	strcpy(r,type->name);
606	>	return PyString_FromString(result);
607		}
608
609	<
610	<	/* Convert a pointer value, signal an exception on a type mismatch */
611	<	SWIGRUNTIME void *
612	<	SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
613	<	void *result;
614	<	if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
615	<	PyErr_Clear();
616	<	if (flags & SWIG_POINTER_EXCEPTION) {
617	<	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
618	<	SWIG_Python_ArgFail(argnum);
609	>	/* Install Constants */
610	>	SWIGRUNTIME(void)
611	>	SWIG_InstallConstants(PyObject *d, swig_const_info constants[]) {
612	>	int i;
613	>	PyObject *obj;
614	>	for (i = 0; constants[i].type; i++) {
615	>	switch(constants[i].type) {
616	>	case SWIG_PY_INT:
617	>	obj = PyInt_FromLong(constants[i].lvalue);
618	>	break;
619	>	case SWIG_PY_FLOAT:
620	>	obj = PyFloat_FromDouble(constants[i].dvalue);
621	>	break;
622	>	case SWIG_PY_STRING:
623	>	obj = PyString_FromString((char *) constants[i].pvalue);
624	>	break;
625	>	case SWIG_PY_POINTER:
626	>	obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
627	>	break;
628	>	case SWIG_PY_BINARY:
629	>	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
630	>	break;
631	>	default:
632	>	obj = 0;
633	>	break;
634	>	}
635	>	if (obj) {
636	>	PyDict_SetItemString(d,constants[i].name,obj);
637	>	Py_DECREF(obj);
638		}
639		}
2441	–	return result;
640		}
641
642	+	#endif
643
644		#ifdef __cplusplus
2446	–	#if 0
2447	–	{ /* cc-mode */
2448	–	#endif
645		}
646		#endif
647
648
649
2454	–	#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455	–
2456	–	#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
650
651
652
2460	–	#define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
653
654
655		/* -------- TYPES TABLE (BEGIN) -------- */
656
657	<	#define SWIGTYPE_p_BossAdministratorSession swig_types[0]
658	<	#define SWIGTYPE_p_BossAttributeContainer swig_types[1]
659	<	#define SWIGTYPE_p_BossDatabase swig_types[2]
660	<	#define SWIGTYPE_p_BossJob swig_types[3]
661	<	#define SWIGTYPE_p_BossSession swig_types[4]
662	<	#define SWIGTYPE_p_BossTask swig_types[5]
663	<	#define SWIGTYPE_p_BossTaskException swig_types[6]
664	<	#define SWIGTYPE_p_XMLDoc swig_types[7]
665	<	#define SWIGTYPE_p_allocator_type swig_types[8]
666	<	#define SWIGTYPE_p_char swig_types[9]
667	<	#define SWIGTYPE_p_difference_type swig_types[10]
668	<	#define SWIGTYPE_p_job_iterator swig_types[11]
669	<	#define SWIGTYPE_p_key_type swig_types[12]
670	<	#define SWIGTYPE_p_mapped_type swig_types[13]
671	<	#define SWIGTYPE_p_p_PyObject swig_types[14]
672	<	#define SWIGTYPE_p_size_type swig_types[15]
673	<	#define SWIGTYPE_p_std__exception swig_types[16]
674	<	#define SWIGTYPE_p_std__invalid_argument swig_types[17]
675	<	#define SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t_t_t_t swig_types[18]
676	<	#define SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t swig_types[19]
2485	<	#define SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t__allocator_type swig_types[20]
2486	<	#define SWIGTYPE_p_std__ostream swig_types[21]
2487	<	#define SWIGTYPE_p_std__vectorTBossJob_p_std__allocatorTBossJob_p_t_t__const_iterator swig_types[22]
2488	<	#define SWIGTYPE_p_std__vectorTBossTask_p_std__allocatorTBossTask_p_t_t swig_types[23]
2489	<	#define SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t swig_types[24]
2490	<	#define SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_std__allocatorTstd__pairTBossProgram_BossProgramExec_t_t_t__const_iterator swig_types[25]
2491	<	#define SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t swig_types[26]
2492	<	#define SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t__allocator_type swig_types[27]
2493	<	#define SWIGTYPE_p_swig__PySwigIterator swig_types[28]
2494	<	#define SWIGTYPE_p_value_type swig_types[29]
2495	<	static swig_type_info *swig_types[31];
2496	<	static swig_module_info swig_module = {swig_types, 30, 0, 0, 0, 0};
2497	<	#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2498	<	#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
657	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t swig_types[0]
658	>	#define  SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator swig_types[1]
659	>	#define  SWIGTYPE_p_XMLDoc swig_types[2]
660	>	#define  SWIGTYPE_p_std__vectorTBossTask_p_t swig_types[3]
661	>	#define  SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t swig_types[4]
662	>	#define  SWIGTYPE_p_BossTask swig_types[5]
663	>	#define  SWIGTYPE_p_BossTaskException swig_types[6]
664	>	#define  SWIGTYPE_p_std__ostream swig_types[7]
665	>	#define  SWIGTYPE_p_BossAttributeContainer swig_types[8]
666	>	#define  SWIGTYPE_p_printOption swig_types[9]
667	>	#define  SWIGTYPE_p_BossJob swig_types[10]
668	>	#define  SWIGTYPE_p_BossDatabase swig_types[11]
669	>	#define  SWIGTYPE_p_BossSession swig_types[12]
670	>	#define  SWIGTYPE_p_std__vectorTstd__string_t swig_types[13]
671	>	#define  SWIGTYPE_p_std__mapTstd__string_std__string_t swig_types[14]
672	>	#define  SWIGTYPE_p_BossAdministratorSession swig_types[15]
673	>	#define  SWIGTYPE_p_BossTask__job_iterator swig_types[16]
674	>	#define  SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator swig_types[17]
675	>	#define  SWIGTYPE_p_jobStates swig_types[18]
676	>	static swig_type_info *swig_types[20];
677
678		/* -------- TYPES TABLE (END) -------- */
679
2502	–	#if (PY_VERSION_HEX <= 0x02000000)
2503	–	# if !defined(SWIG_PYTHON_CLASSIC)
2504	–	#  error "This python version requires to use swig with the '-classic' option"
2505	–	# endif
2506	–	#endif
680
681		/*-----------------------------------------------
682		@(target):= _BossSession.so
#	Line 2512 | Line 685 | static swig_module_info swig_module = {s
685
686		#define SWIG_name    "_BossSession"
687
688	<	#define SWIGVERSION 0x010329
689	<
690	<
691	<	#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
692	<	#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
693	<
694	<
695	<	#include <stdexcept>
696	<
697	<
698	<	namespace swig {
2526	<	class PyObject_ptr {
2527	<	protected:
2528	<	PyObject *_obj;
2529	<
2530	<	public:
2531	<	PyObject_ptr() :_obj(0)
2532	<	{
2533	<	}
2534	<
2535	<	PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2536	<	{
2537	<	Py_XINCREF(_obj);
2538	<	}
2539	<
2540	<	PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2541	<	{
2542	<	if (initial_ref) Py_XINCREF(_obj);
2543	<	}
2544	<
2545	<	PyObject_ptr & operator=(const PyObject_ptr& item)
2546	<	{
2547	<	Py_XINCREF(item._obj);
2548	<	Py_XDECREF(_obj);
2549	<	_obj = item._obj;
2550	<	return *this;
2551	<	}
2552	<
2553	<	~PyObject_ptr()
2554	<	{
2555	<	Py_XDECREF(_obj);
2556	<	}
2557	<
2558	<	operator PyObject *() const
2559	<	{
2560	<	return _obj;
2561	<	}
2562	<
2563	<	PyObject *operator->() const
2564	<	{
2565	<	return _obj;
2566	<	}
2567	<	};
2568	<	}
688	>	#define  SWIG_MemoryError    1
689	>	#define  SWIG_IOError        2
690	>	#define  SWIG_RuntimeError   3
691	>	#define  SWIG_IndexError     4
692	>	#define  SWIG_TypeError      5
693	>	#define  SWIG_DivisionByZero 6
694	>	#define  SWIG_OverflowError  7
695	>	#define  SWIG_SyntaxError    8
696	>	#define  SWIG_ValueError     9
697	>	#define  SWIG_SystemError   10
698	>	#define  SWIG_UnknownError  99
699
700
701	<	namespace swig {
702	<	struct PyObject_var : PyObject_ptr {
703	<	PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
704	<
705	<	PyObject_var & operator = (PyObject* obj)
706	<	{
707	<	Py_XDECREF(_obj);
708	<	_obj = obj;
709	<	return *this;
710	<	}
711	<	};
701	>	static void _SWIG_exception(int code, const char *msg) {
702	>	switch(code) {
703	>	case SWIG_MemoryError:
704	>	PyErr_SetString(PyExc_MemoryError,msg);
705	>	break;
706	>	case SWIG_IOError:
707	>	PyErr_SetString(PyExc_IOError,msg);
708	>	break;
709	>	case SWIG_RuntimeError:
710	>	PyErr_SetString(PyExc_RuntimeError,msg);
711	>	break;
712	>	case SWIG_IndexError:
713	>	PyErr_SetString(PyExc_IndexError,msg);
714	>	break;
715	>	case SWIG_TypeError:
716	>	PyErr_SetString(PyExc_TypeError,msg);
717	>	break;
718	>	case SWIG_DivisionByZero:
719	>	PyErr_SetString(PyExc_ZeroDivisionError,msg);
720	>	break;
721	>	case SWIG_OverflowError:
722	>	PyErr_SetString(PyExc_OverflowError,msg);
723	>	break;
724	>	case SWIG_SyntaxError:
725	>	PyErr_SetString(PyExc_SyntaxError,msg);
726	>	break;
727	>	case SWIG_ValueError:
728	>	PyErr_SetString(PyExc_ValueError,msg);
729	>	break;
730	>	case SWIG_SystemError:
731	>	PyErr_SetString(PyExc_SystemError,msg);
732	>	break;
733	>	default:
734	>	PyErr_SetString(PyExc_RuntimeError,msg);
735	>	break;
736	>	}
737		}
738
739	<
2585	<	#include <stdexcept>
2586	<
2587	<
2588	<
2589	<	#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
2590	<	#  define SWIG_STD_NOASSIGN_STL
2591	<	#  define SWIG_STD_NOINSERT_TEMPLATE_STL
2592	<	#  define SWIG_STD_NOITERATOR_TRAITS_STL
2593	<	#endif
2594	<
2595	<	#if defined(__GNUC__)
2596	<	#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
2597	<	#     define SWIG_STD_NOMODERN_STL
2598	<	#  endif
2599	<	#endif
2600	<
2601	<
739	>	#define SWIG_exception(a,b) { _SWIG_exception(a,b); SWIG_fail; }
740
741
742		#include <string>
2605	–	#include <stdexcept>
743
744
745		#include <string>
746
747	<
748	<	#include <iostream>
2612	<
2613	<
2614	<	namespace swig {
2615	<	struct stop_iteration {
2616	<	};
2617	<
2618	<	struct PySwigIterator {
2619	<	private:
2620	<	PyObject_ptr _seq;
2621	<
2622	<	protected:
2623	<	PySwigIterator(PyObject *seq) : _seq(seq)
2624	<	{
2625	<	}
2626	<
2627	<	public:
2628	<	virtual ~PySwigIterator() {}
2629	<
2630	<	// Access iterator method, required by Python
2631	<	virtual PyObject *value() const = 0;
2632	<
2633	<	// Forward iterator method, required by Python
2634	<	virtual PySwigIterator *incr(size_t n = 1) = 0;
2635	<
2636	<	// Backward iterator method, very common in C++, but not required in Python
2637	<	virtual PySwigIterator *decr(size_t n = 1)
2638	<	{
2639	<	throw stop_iteration();
2640	<	}
2641	<
2642	<	// Random access iterator methods, but not required in Python
2643	<	virtual ptrdiff_t distance(const PySwigIterator &x) const
2644	<	{
2645	<	throw std::invalid_argument("operation not supported");
2646	<	}
2647	<
2648	<	virtual bool equal (const PySwigIterator &x) const
2649	<	{
2650	<	throw std::invalid_argument("operation not supported");
2651	<	}
2652	<
2653	<	// C++ common/needed methods
2654	<	virtual PySwigIterator *copy() const = 0;
2655	<
2656	<	PyObject *next()
2657	<	{
2658	<	PyObject *obj = value();
2659	<	incr();
2660	<	return obj;
2661	<	}
2662	<
2663	<	PyObject *previous()
2664	<	{
2665	<	decr();
2666	<	return value();
2667	<	}
2668	<
2669	<	PySwigIterator *advance(ptrdiff_t n)
2670	<	{
2671	<	return  (n > 0) ?  incr(n) : decr(-n);
2672	<	}
2673	<
2674	<	bool operator == (const PySwigIterator& x)  const
2675	<	{
2676	<	return equal(x);
2677	<	}
2678	<
2679	<	bool operator != (const PySwigIterator& x) const
2680	<	{
2681	<	return ! operator==(x);
2682	<	}
2683	<
2684	<	PySwigIterator& operator += (ptrdiff_t n)
2685	<	{
2686	<	return *advance(n);
2687	<	}
2688	<
2689	<	PySwigIterator& operator -= (ptrdiff_t n)
2690	<	{
2691	<	return *advance(-n);
2692	<	}
2693	<
2694	<	PySwigIterator* operator + (ptrdiff_t n) const
2695	<	{
2696	<	return copy()->advance(n);
2697	<	}
2698	<
2699	<	PySwigIterator* operator - (ptrdiff_t n) const
2700	<	{
2701	<	return copy()->advance(-n);
2702	<	}
2703	<
2704	<	ptrdiff_t operator - (const PySwigIterator& x) const
2705	<	{
2706	<	return x.distance(*this);
2707	<	}
2708	<
2709	<	static swig_type_info* descriptor() {
2710	<	static int init = 0;
2711	<	static swig_type_info* desc = 0;
2712	<	if (!init) {
2713	<	desc = SWIG_TypeQuery("swig::PySwigIterator *");
2714	<	init = 1;
2715	<	}
2716	<	return desc;
2717	<	}
2718	<	};
747	>	PyObject* SwigInt_FromBool(bool b) {
748	>	return PyInt_FromLong(b ? 1L : 0L);
749		}
750	<
751	<
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;
750	>	double SwigNumber_Check(PyObject* o) {
751	>	return PyFloat_Check(o) || PyInt_Check(o) || PyLong_Check(o);
752		}
753	<
754	<
755	<	#include <float.h>
756	<
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;
753	>	double SwigNumber_AsDouble(PyObject* o) {
754	>	return PyFloat_Check(o) ? PyFloat_AsDouble(o)
755	>	: (PyInt_Check(o) ?   double(PyInt_AsLong(o))
756	>	: double(PyLong_AsLong(o)));
757		}
758	<
759	<
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;
758	>	PyObject* SwigString_FromString(const std::string& s) {
759	>	return PyString_FromStringAndSize(s.data(),s.size());
760		}
761	<
762	<
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;
761	>	std::string SwigString_AsString(PyObject* o) {
762	>	return std::string(PyString_AsString(o));
763		}
764
765
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	–
2922	–	#include <stdexcept>
2923	–
2924	–
2925	–	#include <algorithm>
2926	–
2927	–
766		#include <vector>
767	<
768	<
2931	<	#include <utility>
767	>	#include <algorithm>
768	>	#include <stdexcept>
769
770
771		#include <map>
772		#include <algorithm>
773		#include <stdexcept>
774
775	<
776	<	namespace swig {
777	<	template <class Type>
778	<	struct noconst_traits {
779	<	typedef Type noconst_type;
780	<	};
781	<
782	<	template <class Type>
783	<	struct noconst_traits<const Type> {
784	<	typedef Type noconst_type;
785	<	};
786	<
787	<	/*
788	<	type categories
789	<	*/
790	<	struct pointer_category { };
791	<	struct value_category { };
792	<
793	<	/*
794	<	General traits that provides type_name and type_info
795	<	*/
796	<	template <class Type> struct traits { };
797	<
798	<	template <class Type>
799	<	inline const char* type_name() {
800	<	return traits<typename noconst_traits<Type >::noconst_type >::type_name();
801	<	}
802	<
803	<	template <class Type>
804	<	struct traits_info {
805	<	static swig_type_info *type_query(std::string name) {
806	<	name += " *";
807	<	return SWIG_TypeQuery(name.c_str());
808	<	}
809	<	static swig_type_info *type_info() {
810	<	static swig_type_info *info = type_query(type_name<Type>());
811	<	return info;
812	<	}
813	<	};
814	<
815	<	template <class Type>
816	<	inline swig_type_info *type_info() {
817	<	return traits_info<Type>::type_info();
818	<	}
819	<
820	<	/*
821	<	Partial specialization for pointers
822	<	*/
823	<	template <class Type> struct traits <Type *> {
824	<	typedef pointer_category category;
825	<	static std::string make_ptr_name(const char* name) {
826	<	std::string ptrname = name;
827	<	ptrname += " *";
828	<	return ptrname;
829	<	}
830	<	static const char* type_name() {
831	<	static std::string name = make_ptr_name(swig::type_name<Type>());
832	<	return name.c_str();
833	<	}
834	<	};
835	<
836	<	template <class Type, class Category>
837	<	struct traits_as { };
838	<
839	<	template <class Type, class Category>
840	<	struct traits_check { };
841	<
842	<	}
843	<
844	<
845	<	namespace swig {
846	<	/*
847	<	Traits that provides the from method
848	<	*/
849	<	template <class Type> struct traits_from_ptr {
850	<	static PyObject *from(Type *val, int owner = 0) {
851	<	return SWIG_NewPointerObj(val, type_info<Type>(), owner);
852	<	}
853	<	};
854	<
855	<	template <class Type> struct traits_from {
856	<	static PyObject *from(const Type& val) {
857	<	return traits_from_ptr<Type>::from(new Type(val), 1);
858	<	}
859	<	};
860	<
861	<	template <class Type> struct traits_from<Type *> {
862	<	static PyObject *from(Type* val) {
863	<	return traits_from_ptr<Type>::from(val, 0);
864	<	}
865	<	};
866	<
867	<	template <class Type>
868	<	inline PyObject *from(const Type& val) {
869	<	return traits_from<Type>::from(val);
870	<	}
871	<
872	<	template <class Type>
873	<	inline PyObject *from_ptr(Type* val, int owner) {
874	<	return traits_from_ptr<Type>::from(val, owner);
875	<	}
876	<
877	<	/*
878	<	Traits that provides the asval/as/check method
879	<	*/
880	<	template <class Type>
881	<	struct traits_asptr {
882	<	static int asptr(PyObject *obj, Type **val) {
883	<	Type *p;
884	<	int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
885	<	if (SWIG_IsOK(res)) {
886	<	if (val) *val = p;
887	<	}
888	<	return res;
889	<	}
890	<	};
891	<
892	<	template <class Type>
893	<	inline int asptr(PyObject *obj, Type **vptr) {
894	<	return traits_asptr<Type>::asptr(obj, vptr);
895	<	}
896	<
897	<	template <class Type>
898	<	struct traits_asval {
899	<	static int asval(PyObject *obj, Type *val) {
900	<	if (val) {
901	<	Type *p = 0;
902	<	int res = traits_asptr<Type>::asptr(obj, &p);
903	<	if (!SWIG_IsOK(res)) return res;
904	<	if (p) {
905	<	typedef typename noconst_traits<Type>::noconst_type noconst_type;
906	<	*(const_cast<noconst_type*>(val)) = *p;
907	<	if (SWIG_IsNewObj(res)){
908	<	delete p;
909	<	res = SWIG_DelNewMask(res);
910	<	}
911	<	return res;
912	<	} else {
913	<	return SWIG_ERROR;
914	<	}
915	<	} else {
916	<	return traits_asptr<Type>::asptr(obj, (Type **)(0));
917	<	}
918	<	}
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	<	}
775	>	bool std_maplstd_stringcstd_string_g___nonzero_____(std::map<std::string,std::string > *self){
776	>	return !(self->empty());
777	>	}
778	>	std::string std_maplstd_stringcstd_string_g___getitem_____(std::map<std::string,std::string > *self,std::string key){
779	>	std::map<std::string,std::string >::iterator i = self->find(key);
780	>	if (i != self->end())
781	>	return i->second;
782	>	else
783	>	throw std::out_of_range("key not found");
784	>	}
785	>	void std_maplstd_stringcstd_string_g___setitem_____(std::map<std::string,std::string > *self,std::string key,std::string x){
786	>	(*self)[key] = x;
787	>	}
788	>	void std_maplstd_stringcstd_string_g___delitem_____(std::map<std::string,std::string > *self,std::string key){
789	>	std::map<std::string,std::string >::iterator i = self->find(key);
790	>	if (i != self->end())
791	>	self->erase(i);
792	>	else
793	>	throw std::out_of_range("key not found");
794	>	}
795	>	bool std_maplstd_stringcstd_string_g_has_key___(std::map<std::string,std::string > *self,std::string key){
796	>	std::map<std::string,std::string >::iterator i = self->find(key);
797	>	return i != self->end();
798	>	}
799	>	PyObject *std_maplstd_stringcstd_string_g_keys___(std::map<std::string,std::string > *self){
800	>	PyObject* keyList = PyList_New(self->size());
801	>	std::map<std::string,std::string >::iterator i;
802	>	unsigned int j;
803	>	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
804	>	PyList_SetItem(keyList,j,
805	>	SwigString_FromString(i->first));
806	>	}
807	>	return keyList;
808	>	}
809	>	PyObject *std_maplstd_stringcstd_string_g_values___(std::map<std::string,std::string > *self){
810	>	PyObject* valueList = PyList_New(self->size());
811	>	std::map<std::string,std::string >::iterator i;
812	>	unsigned int j;
813	>	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
814	>	PyList_SetItem(valueList,j,
815	>	SwigString_FromString(i->second));
816	>	}
817	>	return valueList;
818	>	}
819	>	PyObject *std_maplstd_stringcstd_string_g_items___(std::map<std::string,std::string > *self){
820	>	PyObject* itemList = PyList_New(self->size());
821	>	std::map<std::string,std::string >::iterator i;
822	>	unsigned int j;
823	>	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
824	>	PyObject* item = PyTuple_New(2);
825	>	PyTuple_SetItem(item,0,
826	>	SwigString_FromString(i->first));
827	>	PyTuple_SetItem(item,1,
828	>	SwigString_FromString(i->second));
829	>	PyList_SetItem(itemList,j,item);
830	>	}
831	>	return itemList;
832	>	}
833	>	bool std_maplstd_stringcstd_string_g___contains_____(std::map<std::string,std::string > *self,std::string key){
834	>	std::map<std::string,std::string >::iterator i = self->find(key);
835	>	return i != self->end();
836	>	}
837	>	PyObject *std_maplstd_stringcstd_string_g___iter_____(std::map<std::string,std::string > *self){
838	>	#if PY_VERSION_HEX >= 0x02020000
839	>	PyObject* keyList = PyList_New(self->size());
840	>	std::map<std::string,std::string >::iterator i;
841	>	unsigned int j;
842	>	for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
843	>	PyList_SetItem(keyList,j,
844	>	SwigString_FromString(i->first));
845	>	}
846	>	PyObject* iter = PyObject_GetIter(keyList);
847	>	Py_DECREF(keyList);
848	>	return iter;
849	>	#else
850	>	throw std::runtime_error("Python 2.2 or later is needed"
851	>	" for iterator support");
852	>	#endif
853	>	}
854	>	std::string std_vectorlstd_string_g_pop___(std::vector<std::string > *self){
855	>	if (self->size() == 0)
856	>	throw std::out_of_range("pop from empty vector");
857	>	std::string x = self->back();
858	>	self->pop_back();
859	>	return x;
860	>	}
861	>	std::string std_vectorlstd_string_g___getitem_____(std::vector<std::string > *self,int i){
862	>	int size = int(self->size());
863	>	if (i<0) i += size;
864	>	if (i>=0 && i<size)
865	>	return (*self)[i];
866	>	else
867	>	throw std::out_of_range("vector index out of range");
868	>	}
869	>	std::vector<std::string > std_vectorlstd_string_g___getslice_____(std::vector<std::string > *self,int i,int j){
870	>	int size = int(self->size());
871	>	if (i<0) i = size+i;
872	>	if (j<0) j = size+j;
873	>	if (i<0) i = 0;
874	>	if (j>size) j = size;
875	>	std::vector<std::string > tmp(j-i);
876	>	std::copy(self->begin()+i,self->begin()+j,tmp.begin());
877	>	return tmp;
878	>	}
879	>	void std_vectorlstd_string_g___setitem_____(std::vector<std::string > *self,int i,std::string x){
880	>	int size = int(self->size());
881	>	if (i<0) i+= size;
882	>	if (i>=0 && i<size)
883	>	(*self)[i] = x;
884	>	else
885	>	throw std::out_of_range("vector index out of range");
886	>	}
887	>	void std_vectorlstd_string_g___setslice_____(std::vector<std::string > *self,int i,int j,std::vector<std::string > const &v){
888	>	int size = int(self->size());
889	>	if (i<0) i = size+i;
890	>	if (j<0) j = size+j;
891	>	if (i<0) i = 0;
892	>	if (j>size) j = size;
893	>	if (int(v.size()) == j-i) {
894	>	std::copy(v.begin(),v.end(),self->begin()+i);
895	>	} else {
896	>	self->erase(self->begin()+i,self->begin()+j);
897	>	if (i+1 <= int(self->size()))
898	>	self->insert(self->begin()+i,v.begin(),v.end());
899	>	else
900	>	self->insert(self->end(),v.begin(),v.end());
901	>	}
902	>	}
903	>	void std_vectorlstd_string_g___delitem_____(std::vector<std::string > *self,int i){
904	>	int size = int(self->size());
905	>	if (i<0) i+= size;
906	>	if (i>=0 && i<size)
907	>	self->erase(self->begin()+i);
908	>	else
909	>	throw std::out_of_range("vector index out of range");
910	>	}
911	>	void std_vectorlstd_string_g___delslice_____(std::vector<std::string > *self,int i,int j){
912	>	int size = int(self->size());
913	>	if (i<0) i = size+i;
914	>	if (j<0) j = size+j;
915	>	if (i<0) i = 0;
916	>	if (j>size) j = size;
917	>	self->erase(self->begin()+i,self->begin()+j);
918	>	}
919
920		#include "BossSession.h"
921		#include "BossAdministratorSession.h"
#	Line 4488 | Line 928 | SWIGINTERN void std_vector_Sl_std_string
928		#include "BossProgramExec.h"
929		#include "BossDatabase.h"
930
931	<
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){
931	>	PyObject *BossSession_show(BossSession *self,std::vector<std::string > &my_vec){
932		PyObject *  my_list = PyList_New( my_vec.size());
933		unsigned int index = 0;
934		for ( std::vector<std::string>::const_iterator it = my_vec.begin ();
#	Line 4550 | Line 937 | SWIGINTERN PyObject *BossSession_show(Bo
937		}
938		return my_list;
939		}
940	<	SWIGINTERN PyObject *BossSession_CHTools(BossSession *self){
940	>	PyObject *BossSession_CHTools(BossSession *self){
941		std::vector<std::string> my_vec = self->showCHTools();
942		return BossSession_show( self, my_vec );
943		}
944	<	SWIGINTERN PyObject *BossSession_ProgramTypes(BossSession *self){
944	>	PyObject *BossSession_ProgramTypes(BossSession *self){
945		std::vector<std::string> my_vec = self->showProgramTypes();
946		return BossSession_show( self, my_vec );
947		}
948	<	SWIGINTERN PyObject *BossSession_RTMons(BossSession *self){
948	>	PyObject *BossSession_RTMons(BossSession *self){
949		std::vector<std::string> my_vec = self->showRTMon();
950		return BossSession_show( self, my_vec );
951		}
952	<	SWIGINTERN PyObject *BossSession_schedulers(BossSession *self){
952	>	PyObject *BossSession_schedulers(BossSession *self){
953		std::vector<std::string> my_vec = self->showSchedulers();
954		return BossSession_show( self, my_vec );
955		}
956	<	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){
956	>	PyObject *BossSession_schedListMatch(BossSession *self,std::string const &scheduler,std::string const &schclassad,std::string const &taskid,std::string const &jobid,bool keepfile){
957		std::vector<std::string> my_vec = self->listMatch( scheduler,
958		schclassad,
959		keepfile,
#	Line 4574 | Line 961 | SWIGINTERN PyObject *BossSession_schedLi
961		jobid);
962		return BossSession_show( self, my_vec );
963		}
964	<	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){
964	>	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){
965		if ( !avoidCheck ) {
966		self->schedulerQuery ( filter_opt, taskRange, jobRange, subn,
967		type, user, after, before);
#	Line 4595 | Line 982 | SWIGINTERN PyObject *BossSession_queryTa
982		//       }
983		return  job_dict;
984		}
985	<
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){
985	>	PyObject *BossTask_appendToPyDict(BossTask const *self,PyObject *dict,BossAttributeContainer const &obj){
986		std::string tmp;
987		BossAttributeContainer::const_iterator it_end = obj.end ();
988		for (BossAttributeContainer::const_iterator it = obj.begin ();
#	Line 4636 | Line 997 | SWIGINTERN PyObject *BossTask_appendToPy
997		}
998		return dict;
999		}
1000	<	SWIGINTERN PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob *,std::allocator<BossJob * > >::const_iterator &jit){
1000	>	PyObject *BossTask_jobDict(BossTask const *self,std::vector<BossJob * >::const_iterator &jit){
1001
1002		PyObject * job_dict = PyDict_New();
1003		std::string tmp;
#	Line 4658 | Line 1019 | SWIGINTERN PyObject *BossTask_jobDict(Bo
1019		}
1020		return job_dict;
1021		}
1022	<	SWIGINTERN PyObject *BossTask_jobsDict(BossTask const *self){
1022	>	PyObject *BossTask_jobsDict(BossTask const *self){
1023
1024		PyObject * job_dict = PyDict_New();
1025		for (BossTask::job_iterator jit = self->job_begin ();
#	Line 4670 | Line 1031 | SWIGINTERN PyObject *BossTask_jobsDict(B
1031		}
1032		return job_dict;
1033		}
1034	<	SWIGINTERN PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec >,std::allocator<std::pair<BossProgram,BossProgramExec > > >::const_iterator &programs_it){
1034	>	PyObject *BossTask_progDict(BossTask const *self,std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator &programs_it){
1035
1036		PyObject * job_dict = PyDict_New();
1037
#	Line 4694 | Line 1055 | SWIGINTERN PyObject *BossTask_progDict(B
1055		}
1056		return job_dict;
1057		}
1058	<	SWIGINTERN PyObject *BossTask_jobPrograms(BossTask const *self,std::string const &jobid){
1058	>	PyObject *BossTask_jobPrograms(BossTask const *self,std::string const &jobid){
1059
1060		const BossJob * jH = &((*self)[atoi( jobid.c_str() )]);
1061		std::map< std::string, std::map< std::string, std::string > > ret_val;
#	Line 4720 | Line 1081 | SWIGINTERN PyObject *BossTask_jobProgram
1081		#ifdef __cplusplus
1082		extern "C" {
1083		#endif
1084	<	SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1085	<	PyObject *resultobj = 0;
1086	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1087	<	void *argp1 = 0 ;
1088	<	int res1 = 0 ;
1089	<	PyObject * obj0 = 0 ;
1090	<
1091	<	if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
1092	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
1093	<	if (!SWIG_IsOK(res1)) {
1094	<	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;
1084	>	static PyObject *_wrap_new_objectMap__SWIG_0(PyObject *self, PyObject *args) {
1085	>	PyObject *resultobj;
1086	>	std::map<std::string,std::string > *result;
1087	>
1088	>	if(!PyArg_ParseTuple(args,(char *)":new_objectMap")) goto fail;
1089	>	{
1090	>	try {
1091	>	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
1092	>
1093	>	}catch (const std::exception& e) {
1094	>	SWIG_exception(SWIG_RuntimeError, e.what());
1095		}
4776	–	}
4777	–
4778	–	} catch (const std::exception& e) {
4779	–	SWIG_exception(SWIG_RuntimeError, e.what());
1096		}
1097	<	}
1098	<	resultobj = result;
1099	<	return resultobj;
1100	<	fail:
4785	<	return NULL;
1097	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
1098	>	return resultobj;
1099	>	fail:
1100	>	return NULL;
1101		}
1102
1103
1104	<	SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1105	<	PyObject *resultobj = 0;
1106	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1107	<	size_t arg2 ;
1108	<	swig::PySwigIterator *result = 0 ;
1109	<	void *argp1 = 0 ;
1110	<	int res1 = 0 ;
1111	<	size_t val2 ;
1112	<	int ecode2 = 0 ;
1113	<	PyObject * obj0 = 0 ;
1114	<	PyObject * obj1 = 0 ;
1115	<
1116	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
1117	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1118	<	if (!SWIG_IsOK(res1)) {
1119	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1120	<	}
1121	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
1122	<	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
1123	<	if (!SWIG_IsOK(ecode2)) {
1124	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
1125	<	}
1126	<	arg2 = static_cast< size_t >(val2);
1127	<	{
1128	<	try {
1129	<	try {
1130	<	result = (swig::PySwigIterator *)(arg1)->incr(arg2);
1131	<	}
1132	<	catch(swig::stop_iteration &_e) {
1133	<	{
1134	<	(void)_e;
1135	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
1136	<	SWIG_fail;
1104	>	static PyObject *_wrap_new_objectMap__SWIG_1(PyObject *self, PyObject *args) {
1105	>	PyObject *resultobj;
1106	>	std::map<std::string,std::string > *arg1 = 0 ;
1107	>	std::map<std::string,std::string > *result;
1108	>	std::map<std::string,std::string > temp1 ;
1109	>	std::map<std::string,std::string > *m1 ;
1110	>	PyObject * obj0 = 0 ;
1111	>
1112	>	if(!PyArg_ParseTuple(args,(char *)"O:new_objectMap",&obj0)) goto fail;
1113	>	{
1114	>	if (PyDict_Check(obj0)) {
1115	>	PyObject* items = PyMapping_Items(obj0);
1116	>	unsigned int size = PyList_Size(items);
1117	>	temp1 = std::map<std::string,std::string >();
1118	>	arg1 = &temp1;
1119	>	for (unsigned int i=0; i<size; i++) {
1120	>	PyObject* pair = PySequence_GetItem(items,i);
1121	>	PyObject* key = PySequence_GetItem(pair,0);
1122	>	PyObject* o = PySequence_GetItem(pair,1);
1123	>	if (PyString_Check(key) && PyString_Check(o)) {
1124	>	temp1[SwigString_AsString(key)] = SwigString_AsString(o);
1125	>	Py_DECREF(key);
1126	>	Py_DECREF(o);
1127	>	Py_DECREF(pair);
1128	>	}else {
1129	>	Py_DECREF(key);
1130	>	Py_DECREF(o);
1131	>	Py_DECREF(pair);
1132	>	Py_DECREF(items);
1133	>	PyErr_SetString(PyExc_TypeError,
1134	>	"map<""std::string"",""std::string""> expected");
1135	>	SWIG_fail;
1136	>	}
1137	>	}
1138	>	Py_DECREF(items);
1139	>	}else if (SWIG_ConvertPtr(obj0,(void **) &m1,
1140	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
1141	>	arg1 = m1;
1142	>	}else {
1143	>	PyErr_SetString(PyExc_TypeError,
1144	>	"map<""std::string"",""std::string""> expected");
1145	>	SWIG_fail;
1146		}
4823	–	}
4824	–
4825	–	} catch (const std::exception& e) {
4826	–	SWIG_exception(SWIG_RuntimeError, e.what());
1147		}
1148	<	}
1149	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1150	<	return resultobj;
1151	<	fail:
1152	<	return NULL;
1153	<	}
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;
1148	>	{
1149	>	try {
1150	>	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
1151	>
1152	>	}catch (const std::exception& e) {
1153	>	SWIG_exception(SWIG_RuntimeError, e.what());
1154		}
4861	–	}
4862	–
4863	–	} catch (const std::exception& e) {
4864	–	SWIG_exception(SWIG_RuntimeError, e.what());
1155		}
1156	<	}
1157	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1158	<	return resultobj;
1159	<	fail:
4870	<	return NULL;
1156	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__mapTstd__string_std__string_t, 1);
1157	>	return resultobj;
1158	>	fail:
1159	>	return NULL;
1160		}
1161
1162
1163	<	SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
1164	<	int argc;
1165	<	PyObject *argv[3];
1166	<	int ii;
1167	<
1168	<	if (!PyTuple_Check(args)) SWIG_fail;
1169	<	argc = PyObject_Length(args);
1170	<	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);
1163	>	static PyObject *_wrap_new_objectMap(PyObject *self, PyObject *args) {
1164	>	int argc;
1165	>	PyObject *argv[2];
1166	>	int ii;
1167	>
1168	>	argc = PyObject_Length(args);
1169	>	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1170	>	argv[ii] = PyTuple_GetItem(args,ii);
1171		}
1172	<	}
1173	<	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	<	}
1172	>	if (argc == 0) {
1173	>	return _wrap_new_objectMap__SWIG_0(self,args);
1174		}
1175	<	}
1176	<
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) {
1175	>	if (argc == 1) {
1176	>	int _v;
1177		{
1178	<	(void)_e;
1179	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
1180	<	SWIG_fail;
1181	<	}
1182	<	}
1183	<
1184	<	} catch (const std::exception& e) {
1185	<	SWIG_exception(SWIG_RuntimeError, e.what());
1186	<	}
1187	<	}
1188	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1189	<	return resultobj;
1190	<	fail:
1191	<	return NULL;
1192	<	}
1193	<
1194	<
1195	<	SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1196	<	PyObject *resultobj = 0;
1197	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1198	<	swig::PySwigIterator *result = 0 ;
1199	<	void *argp1 = 0 ;
1200	<	int res1 = 0 ;
1201	<	PyObject * obj0 = 0 ;
1202	<
1203	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
1204	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1205	<	if (!SWIG_IsOK(res1)) {
1206	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1207	<	}
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;
1178	>	/* native sequence? */
1179	>	if (PyDict_Check(argv[0])) {
1180	>	PyObject* items = PyMapping_Items(argv[0]);
1181	>	unsigned int size = PyList_Size(items);
1182	>	if (size == 0) {
1183	>	/* an empty dictionary can be of any type */
1184	>	_v = 1;
1185	>	}else {
1186	>	/* check the first element only */
1187	>	PyObject* pair = PySequence_GetItem(items,0);
1188	>	PyObject* key = PySequence_GetItem(pair,0);
1189	>	PyObject* o = PySequence_GetItem(pair,1);
1190	>	if (PyString_Check(key) && PyString_Check(o))
1191	>	_v = 1;
1192	>	else
1193	>	_v = 0;
1194	>	Py_DECREF(key);
1195	>	Py_DECREF(o);
1196	>	Py_DECREF(pair);
1197	>	}
1198	>	Py_DECREF(items);
1199	>	}else {
1200	>	/* wrapped map? */
1201	>	std::map<std::string,std::string >* m;
1202	>	if (SWIG_ConvertPtr(argv[0],(void **) &m,
1203	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1)
1204	>	_v = 1;
1205	>	else
1206	>	_v = 0;
1207	>	}
1208		}
1209	<	}
1210	<
4989	<	} catch (const std::exception& e) {
4990	<	SWIG_exception(SWIG_RuntimeError, e.what());
4991	<	}
4992	<	}
4993	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4994	<	return resultobj;
4995	<	fail:
4996	<	return NULL;
4997	<	}
4998	<
4999	<
5000	<	SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
5001	<	int argc;
5002	<	PyObject *argv[3];
5003	<	int ii;
5004	<
5005	<	if (!PyTuple_Check(args)) SWIG_fail;
5006	<	argc = PyObject_Length(args);
5007	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5008	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5009	<	}
5010	<	if (argc == 1) {
5011	<	int _v;
5012	<	void *vptr = 0;
5013	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5014	<	_v = SWIG_CheckState(res);
5015	<	if (_v) {
5016	<	return _wrap_PySwigIterator_decr__SWIG_1(self, args);
5017	<	}
5018	<	}
5019	<	if (argc == 2) {
5020	<	int _v;
5021	<	void *vptr = 0;
5022	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5023	<	_v = SWIG_CheckState(res);
5024	<	if (_v) {
5025	<	{
5026	<	int res = SWIG_AsVal_size_t(argv[1], NULL);
5027	<	_v = SWIG_CheckState(res);
5028	<	}
5029	<	if (_v) {
5030	<	return _wrap_PySwigIterator_decr__SWIG_0(self, args);
5031	<	}
5032	<	}
5033	<	}
5034	<
5035	<	fail:
5036	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'PySwigIterator_decr'");
5037	<	return NULL;
5038	<	}
5039	<
5040	<
5041	<	SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5042	<	PyObject *resultobj = 0;
5043	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5044	<	swig::PySwigIterator *arg2 = 0 ;
5045	<	ptrdiff_t result;
5046	<	void *argp1 = 0 ;
5047	<	int res1 = 0 ;
5048	<	void *argp2 = 0 ;
5049	<	int res2 = 0 ;
5050	<	PyObject * obj0 = 0 ;
5051	<	PyObject * obj1 = 0 ;
5052	<
5053	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
5054	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5055	<	if (!SWIG_IsOK(res1)) {
5056	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5057	<	}
5058	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5059	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5060	<	if (!SWIG_IsOK(res2)) {
5061	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5062	<	}
5063	<	if (!argp2) {
5064	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5065	<	}
5066	<	arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5067	<	{
5068	<	try {
5069	<	try {
5070	<	result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
5071	<	}
5072	<	catch(std::invalid_argument &_e) {
5073	<	SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
5074	<	}
5075	<
5076	<	} catch (const std::exception& e) {
5077	<	SWIG_exception(SWIG_RuntimeError, e.what());
5078	<	}
5079	<	}
5080	<	resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5081	<	return resultobj;
5082	<	fail:
5083	<	return NULL;
5084	<	}
5085	<
5086	<
5087	<	SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5088	<	PyObject *resultobj = 0;
5089	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5090	<	swig::PySwigIterator *arg2 = 0 ;
5091	<	bool result;
5092	<	void *argp1 = 0 ;
5093	<	int res1 = 0 ;
5094	<	void *argp2 = 0 ;
5095	<	int res2 = 0 ;
5096	<	PyObject * obj0 = 0 ;
5097	<	PyObject * obj1 = 0 ;
5098	<
5099	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
5100	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5101	<	if (!SWIG_IsOK(res1)) {
5102	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5103	<	}
5104	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5105	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5106	<	if (!SWIG_IsOK(res2)) {
5107	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5108	<	}
5109	<	if (!argp2) {
5110	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5111	<	}
5112	<	arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5113	<	{
5114	<	try {
5115	<	try {
5116	<	result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
5117	<	}
5118	<	catch(std::invalid_argument &_e) {
5119	<	SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
5120	<	}
5121	<
5122	<	} catch (const std::exception& e) {
5123	<	SWIG_exception(SWIG_RuntimeError, e.what());
5124	<	}
5125	<	}
5126	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
5127	<	return resultobj;
5128	<	fail:
5129	<	return NULL;
5130	<	}
5131	<
5132	<
5133	<	SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5134	<	PyObject *resultobj = 0;
5135	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5136	<	swig::PySwigIterator *result = 0 ;
5137	<	void *argp1 = 0 ;
5138	<	int res1 = 0 ;
5139	<	PyObject * obj0 = 0 ;
5140	<
5141	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
5142	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5143	<	if (!SWIG_IsOK(res1)) {
5144	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5145	<	}
5146	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5147	<	{
5148	<	try {
5149	<	result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
5150	<	} catch (const std::exception& e) {
5151	<	SWIG_exception(SWIG_RuntimeError, e.what());
5152	<	}
5153	<	}
5154	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5155	<	return resultobj;
5156	<	fail:
5157	<	return NULL;
5158	<	}
5159	<
5160	<
5161	<	SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162	<	PyObject *resultobj = 0;
5163	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5164	<	PyObject *result = 0 ;
5165	<	void *argp1 = 0 ;
5166	<	int res1 = 0 ;
5167	<	PyObject * obj0 = 0 ;
5168	<
5169	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
5170	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5171	<	if (!SWIG_IsOK(res1)) {
5172	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
5173	<	}
5174	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5175	<	{
5176	<	try {
5177	<	try {
5178	<	result = (PyObject *)(arg1)->next();
5179	<	}
5180	<	catch(swig::stop_iteration &_e) {
5181	<	{
5182	<	(void)_e;
5183	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5184	<	SWIG_fail;
1209	>	if (_v) {
1210	>	return _wrap_new_objectMap__SWIG_1(self,args);
1211		}
5186	–	}
5187	–
5188	–	} catch (const std::exception& e) {
5189	–	SWIG_exception(SWIG_RuntimeError, e.what());
1212		}
1213	<	}
1214	<	resultobj = result;
1215	<	return resultobj;
5194	<	fail:
5195	<	return NULL;
1213	>
1214	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_objectMap'");
1215	>	return NULL;
1216		}
1217
1218
1219	<	SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1220	<	PyObject *resultobj = 0;
1221	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1222	<	PyObject *result = 0 ;
1223	<	void *argp1 = 0 ;
1224	<	int res1 = 0 ;
1225	<	PyObject * obj0 = 0 ;
1226	<
1227	<	if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
1228	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1229	<	if (!SWIG_IsOK(res1)) {
1230	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
1231	<	}
1232	<	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
1233	<	{
1234	<	try {
1235	<	try {
1236	<	result = (PyObject *)(arg1)->previous();
1237	<	}
1238	<	catch(swig::stop_iteration &_e) {
1239	<	{
1240	<	(void)_e;
1241	<	SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
1242	<	SWIG_fail;
1219	>	static PyObject *_wrap_objectMap___len__(PyObject *self, PyObject *args) {
1220	>	PyObject *resultobj;
1221	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1222	>	unsigned int result;
1223	>	std::map<std::string,std::string > temp1 ;
1224	>	std::map<std::string,std::string > *m1 ;
1225	>	PyObject * obj0 = 0 ;
1226	>
1227	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___len__",&obj0)) goto fail;
1228	>	{
1229	>	if (PyDict_Check(obj0)) {
1230	>	PyObject* items = PyMapping_Items(obj0);
1231	>	unsigned int size = PyList_Size(items);
1232	>	temp1 = std::map<std::string,std::string >();
1233	>	arg1 = &temp1;
1234	>	for (unsigned int i=0; i<size; i++) {
1235	>	PyObject* pair = PySequence_GetItem(items,i);
1236	>	PyObject* key = PySequence_GetItem(pair,0);
1237	>	PyObject* o = PySequence_GetItem(pair,1);
1238	>	if (PyString_Check(key) && PyString_Check(o)) {
1239	>	temp1[SwigString_AsString(key)] = SwigString_AsString(o);
1240	>	Py_DECREF(key);
1241	>	Py_DECREF(o);
1242	>	Py_DECREF(pair);
1243	>	}else {
1244	>	Py_DECREF(key);
1245	>	Py_DECREF(o);
1246	>	Py_DECREF(pair);
1247	>	Py_DECREF(items);
1248	>	PyErr_SetString(PyExc_TypeError,
1249	>	"map<""std::string"",""std::string""> expected");
1250	>	SWIG_fail;
1251	>	}
1252	>	}
1253	>	Py_DECREF(items);
1254	>	}else if (SWIG_ConvertPtr(obj0,(void **) &m1,
1255	>	SWIGTYPE_p_std__mapTstd__string_std__string_t,0) != -1) {
1256	>	arg1 = m1;
1257	>	}else {
1258	>	PyErr_SetString(PyExc_TypeError,
1259	>	"map<""std::string"",""std::string""> expected");
1260	>	SWIG_fail;
1261		}
5224	–	}
5225	–
5226	–	} catch (const std::exception& e) {
5227	–	SWIG_exception(SWIG_RuntimeError, e.what());
1262		}
1263	<	}
1264	<	resultobj = result;
1265	<	return resultobj;
1266	<	fail:
1267	<	return NULL;
1268	<	}
5235	<
5236	<
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;
1263	>	{
1264	>	try {
1265	>	result = (unsigned int)((std::map<std::string,std::string > const *)arg1)->size();
1266	>
1267	>	}catch (const std::exception& e) {
1268	>	SWIG_exception(SWIG_RuntimeError, e.what());
1269		}
5271	–	}
5272	–
5273	–	} catch (const std::exception& e) {
5274	–	SWIG_exception(SWIG_RuntimeError, e.what());
5275	–	}
5276	–	}
5277	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5278	–	return resultobj;
5279	–	fail:
5280	–	return NULL;
5281	–	}
5282	–
5283	–
5284	–	SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285	–	PyObject *resultobj = 0;
5286	–	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5287	–	swig::PySwigIterator *arg2 = 0 ;
5288	–	bool result;
5289	–	void *argp1 = 0 ;
5290	–	int res1 = 0 ;
5291	–	void *argp2 = 0 ;
5292	–	int res2 = 0 ;
5293	–	PyObject * obj0 = 0 ;
5294	–	PyObject * obj1 = 0 ;
5295	–
5296	–	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
5297	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5298	–	if (!SWIG_IsOK(res1)) {
5299	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5300	–	}
5301	–	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5302	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5303	–	if (!SWIG_IsOK(res2)) {
5304	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5305	–	}
5306	–	if (!argp2) {
5307	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5308	–	}
5309	–	arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5310	–	{
5311	–	try {
5312	–	result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
5313	–	} catch (const std::exception& e) {
5314	–	SWIG_exception(SWIG_RuntimeError, e.what());
5315	–	}
5316	–	}
5317	–	resultobj = SWIG_From_bool(static_cast< bool >(result));
5318	–	return resultobj;
5319	–	fail:
5320	–	return NULL;
5321	–	}
5322	–
5323	–
5324	–	SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5325	–	PyObject *resultobj = 0;
5326	–	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5327	–	swig::PySwigIterator *arg2 = 0 ;
5328	–	bool result;
5329	–	void *argp1 = 0 ;
5330	–	int res1 = 0 ;
5331	–	void *argp2 = 0 ;
5332	–	int res2 = 0 ;
5333	–	PyObject * obj0 = 0 ;
5334	–	PyObject * obj1 = 0 ;
5335	–
5336	–	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
5337	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5338	–	if (!SWIG_IsOK(res1)) {
5339	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5340	–	}
5341	–	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5342	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5343	–	if (!SWIG_IsOK(res2)) {
5344	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5345	–	}
5346	–	if (!argp2) {
5347	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5348	–	}
5349	–	arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5350	–	{
5351	–	try {
5352	–	result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
5353	–	} catch (const std::exception& e) {
5354	–	SWIG_exception(SWIG_RuntimeError, e.what());
1270		}
1271	<	}
1272	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
1273	<	return resultobj;
1274	<	fail:
5360	<	return NULL;
1271	>	resultobj = PyInt_FromLong((long)result);
1272	>	return resultobj;
1273	>	fail:
1274	>	return NULL;
1275		}
1276
1277
1278	<	SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1279	<	PyObject *resultobj = 0;
1280	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1281	<	ptrdiff_t arg2 ;
1282	<	swig::PySwigIterator *result = 0 ;
1283	<	void *argp1 = 0 ;
1284	<	int res1 = 0 ;
1285	<	ptrdiff_t val2 ;
1286	<	int ecode2 = 0 ;
1287	<	PyObject * obj0 = 0 ;
1288	<	PyObject * obj1 = 0 ;
1289	<
1290	<	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;
1278	>	static PyObject *_wrap_objectMap_clear(PyObject *self, PyObject *args) {
1279	>	PyObject *resultobj;
1280	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1281	>	PyObject * obj0 = 0 ;
1282	>
1283	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_clear",&obj0)) goto fail;
1284	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1285	>	{
1286	>	try {
1287	>	(arg1)->clear();
1288	>
1289	>	}catch (const std::exception& e) {
1290	>	SWIG_exception(SWIG_RuntimeError, e.what());
1291		}
5401	–	}
5402	–
5403	–	} catch (const std::exception& e) {
5404	–	SWIG_exception(SWIG_RuntimeError, e.what());
1292		}
1293	<	}
1294	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
1295	<	return resultobj;
1296	<	fail:
5410	<	return NULL;
1293	>	Py_INCREF(Py_None); resultobj = Py_None;
1294	>	return resultobj;
1295	>	fail:
1296	>	return NULL;
1297		}
1298
1299
1300	<	SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1301	<	PyObject *resultobj = 0;
1302	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1303	<	ptrdiff_t arg2 ;
1304	<	swig::PySwigIterator *result = 0 ;
1305	<	void *argp1 = 0 ;
1306	<	int res1 = 0 ;
1307	<	ptrdiff_t val2 ;
1308	<	int ecode2 = 0 ;
1309	<	PyObject * obj0 = 0 ;
1310	<	PyObject * obj1 = 0 ;
1311	<
1312	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
1313	<	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;
1300	>	static PyObject *_wrap_objectMap___nonzero__(PyObject *self, PyObject *args) {
1301	>	PyObject *resultobj;
1302	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1303	>	bool result;
1304	>	PyObject * obj0 = 0 ;
1305	>
1306	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___nonzero__",&obj0)) goto fail;
1307	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1308	>	{
1309	>	try {
1310	>	result = (bool)std_maplstd_stringcstd_string_g___nonzero_____(arg1);
1311	>
1312	>	}catch (const std::exception& e) {
1313	>	SWIG_exception(SWIG_RuntimeError, e.what());
1314		}
5451	–	}
5452	–
5453	–	} catch (const std::exception& e) {
5454	–	SWIG_exception(SWIG_RuntimeError, e.what());
1315		}
1316	<	}
1317	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
1318	<	return resultobj;
1319	<	fail:
5460	<	return NULL;
1316	>	resultobj = PyInt_FromLong((long)result);
1317	>	return resultobj;
1318	>	fail:
1319	>	return NULL;
1320		}
1321
1322
1323	<	SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1324	<	PyObject *resultobj = 0;
1325	<	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
1326	<	ptrdiff_t arg2 ;
1327	<	swig::PySwigIterator *result = 0 ;
1328	<	void *argp1 = 0 ;
1329	<	int res1 = 0 ;
1330	<	ptrdiff_t val2 ;
1331	<	int ecode2 = 0 ;
1332	<	PyObject * obj0 = 0 ;
1333	<	PyObject * obj1 = 0 ;
1334	<
1335	<	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
1336	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
1337	<	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());
1323	>	static PyObject *_wrap_objectMap___getitem__(PyObject *self, PyObject *args) {
1324	>	PyObject *resultobj;
1325	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1326	>	std::string arg2 ;
1327	>	std::string result;
1328	>	PyObject * obj0 = 0 ;
1329	>	PyObject * obj1 = 0 ;
1330	>
1331	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___getitem__",&obj0,&obj1)) goto fail;
1332	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1333	>	{
1334	>	if (PyString_Check(obj1))
1335	>	arg2 = std::string(PyString_AsString(obj1));
1336	>	else
1337	>	SWIG_exception(SWIG_TypeError, "string expected");
1338		}
1339	<	}
1340	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
1341	<	return resultobj;
1342	<	fail:
1343	<	return NULL;
1344	<	}
1345	<
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;
1339	>	{
1340	>	try {
1341	>	result = std_maplstd_stringcstd_string_g___getitem_____(arg1,arg2);
1342	>
1343	>	}catch (std::out_of_range& e) {
1344	>	PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
1345	>	SWIG_fail;
1346		}
5545	–	}
5546	–
5547	–	} catch (const std::exception& e) {
5548	–	SWIG_exception(SWIG_RuntimeError, e.what());
5549	–	}
5550	–	}
5551	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5552	–	return resultobj;
5553	–	fail:
5554	–	return NULL;
5555	–	}
5556	–
5557	–
5558	–	SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5559	–	PyObject *resultobj = 0;
5560	–	swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
5561	–	swig::PySwigIterator *arg2 = 0 ;
5562	–	ptrdiff_t result;
5563	–	void *argp1 = 0 ;
5564	–	int res1 = 0 ;
5565	–	void *argp2 = 0 ;
5566	–	int res2 = 0 ;
5567	–	PyObject * obj0 = 0 ;
5568	–	PyObject * obj1 = 0 ;
5569	–
5570	–	if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
5571	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
5572	–	if (!SWIG_IsOK(res1)) {
5573	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
5574	–	}
5575	–	arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
5576	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
5577	–	if (!SWIG_IsOK(res2)) {
5578	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5579	–	}
5580	–	if (!argp2) {
5581	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
5582	–	}
5583	–	arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
5584	–	{
5585	–	try {
5586	–	result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
5587	–	} catch (const std::exception& e) {
5588	–	SWIG_exception(SWIG_RuntimeError, e.what());
5589	–	}
5590	–	}
5591	–	resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5592	–	return resultobj;
5593	–	fail:
5594	–	return NULL;
5595	–	}
5596	–
5597	–
5598	–	SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
5599	–	int argc;
5600	–	PyObject *argv[3];
5601	–	int ii;
5602	–
5603	–	if (!PyTuple_Check(args)) SWIG_fail;
5604	–	argc = PyObject_Length(args);
5605	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
5606	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
5607	–	}
5608	–	if (argc == 2) {
5609	–	int _v;
5610	–	void *vptr = 0;
5611	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5612	–	_v = SWIG_CheckState(res);
5613	–	if (_v) {
5614	–	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
5615	–	_v = SWIG_CheckState(res);
5616	–	if (_v) {
5617	–	return _wrap_PySwigIterator___sub____SWIG_1(self, args);
5618	–	}
5619	–	}
5620	–	}
5621	–	if (argc == 2) {
5622	–	int _v;
5623	–	void *vptr = 0;
5624	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
5625	–	_v = SWIG_CheckState(res);
5626	–	if (_v) {
5627	–	{
5628	–	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
5629	–	_v = SWIG_CheckState(res);
5630	–	}
5631	–	if (_v) {
5632	–	return _wrap_PySwigIterator___sub____SWIG_0(self, args);
5633	–	}
5634	–	}
5635	–	}
5636	–
5637	–	fail:
5638	–	Py_INCREF(Py_NotImplemented);
5639	–	return Py_NotImplemented;
5640	–	}
5641	–
5642	–
5643	–	SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5644	–	PyObject *obj;
5645	–	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
5646	–	SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
5647	–	return SWIG_Py_Void();
5648	–	}
5649	–
5650	–	SWIGINTERN PyObject *_wrap_objectMap_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5651	–	PyObject *resultobj = 0;
5652	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5653	–	PyObject **arg2 = (PyObject **) 0 ;
5654	–	swig::PySwigIterator *result = 0 ;
5655	–	void *argp1 = 0 ;
5656	–	int res1 = 0 ;
5657	–	PyObject * obj0 = 0 ;
5658	–
5659	–	arg2 = &obj0;
5660	–	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_iterator",&obj0)) SWIG_fail;
5661	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5662	–	if (!SWIG_IsOK(res1)) {
5663	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_iterator" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
5664	–	}
5665	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5666	–	{
5667	–	try {
5668	–	result = (swig::PySwigIterator *)std_map_Sl_std_string_Sc_std_string_Sg__iterator(arg1,arg2);
5669	–	} catch (const std::exception& e) {
5670	–	SWIG_exception(SWIG_RuntimeError, e.what());
5671	–	}
5672	–	}
5673	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
5674	–	return resultobj;
5675	–	fail:
5676	–	return NULL;
5677	–	}
5678	–
5679	–
5680	–	SWIGINTERN PyObject *_wrap_objectMap___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5681	–	PyObject *resultobj = 0;
5682	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5683	–	bool result;
5684	–	void *argp1 = 0 ;
5685	–	int res1 = 0 ;
5686	–	PyObject * obj0 = 0 ;
5687	–
5688	–	if (!PyArg_ParseTuple(args,(char *)"O:objectMap___nonzero__",&obj0)) SWIG_fail;
5689	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5690	–	if (!SWIG_IsOK(res1)) {
5691	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___nonzero__" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
5692	–	}
5693	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5694	–	{
5695	–	try {
5696	–	result = (bool)std_map_Sl_std_string_Sc_std_string_Sg____nonzero__((std::map<std::string,std::string > const *)arg1);
5697	–	} catch (const std::exception& e) {
5698	–	SWIG_exception(SWIG_RuntimeError, e.what());
5699	–	}
5700	–	}
5701	–	resultobj = SWIG_From_bool(static_cast< bool >(result));
5702	–	return resultobj;
5703	–	fail:
5704	–	return NULL;
5705	–	}
5706	–
5707	–
5708	–	SWIGINTERN PyObject *_wrap_objectMap___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5709	–	PyObject *resultobj = 0;
5710	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5711	–	std::map<std::string,std::string >::size_type result;
5712	–	void *argp1 = 0 ;
5713	–	int res1 = 0 ;
5714	–	PyObject * obj0 = 0 ;
5715	–
5716	–	if (!PyArg_ParseTuple(args,(char *)"O:objectMap___len__",&obj0)) SWIG_fail;
5717	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5718	–	if (!SWIG_IsOK(res1)) {
5719	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___len__" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
5720	–	}
5721	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5722	–	{
5723	–	try {
5724	–	result = std_map_Sl_std_string_Sc_std_string_Sg____len__((std::map<std::string,std::string > const *)arg1);
5725	–	} catch (const std::exception& e) {
5726	–	SWIG_exception(SWIG_RuntimeError, e.what());
5727	–	}
5728	–	}
5729	–	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
5730	–	return resultobj;
5731	–	fail:
5732	–	return NULL;
5733	–	}
5734	–
5735	–
5736	–	SWIGINTERN PyObject *_wrap_objectMap___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5737	–	PyObject *resultobj = 0;
5738	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5739	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
5740	–	std::map<std::string,std::string >::mapped_type result;
5741	–	void *argp1 = 0 ;
5742	–	int res1 = 0 ;
5743	–	int res2 = SWIG_OLDOBJ ;
5744	–	PyObject * obj0 = 0 ;
5745	–	PyObject * obj1 = 0 ;
5746	–
5747	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap___getitem__",&obj0,&obj1)) SWIG_fail;
5748	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5749	–	if (!SWIG_IsOK(res1)) {
5750	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___getitem__" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
5751	–	}
5752	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5753	–	{
5754	–	std::string *ptr = (std::string *)0;
5755	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5756	–	if (!SWIG_IsOK(res2)) {
5757	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap___getitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5758	–	}
5759	–	if (!ptr) {
5760	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap___getitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5761	–	}
5762	–	arg2 = ptr;
5763	–	}
5764	–	{
5765	–	try {
5766	–	try {
5767	–	result = std_map_Sl_std_string_Sc_std_string_Sg____getitem__((std::map<std::string,std::string > const *)arg1,(std::string const &)*arg2);
5768	–	}
5769	–	catch(std::out_of_range &_e) {
5770	–	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5771	–	}
5772	–
5773	–	} catch (const std::exception& e) {
5774	–	SWIG_exception(SWIG_RuntimeError, e.what());
5775	–	}
5776	–	}
5777	–	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
5778	–	if (SWIG_IsNewObj(res2)) delete arg2;
5779	–	return resultobj;
5780	–	fail:
5781	–	if (SWIG_IsNewObj(res2)) delete arg2;
5782	–	return NULL;
5783	–	}
5784	–
5785	–
5786	–	SWIGINTERN PyObject *_wrap_objectMap___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5787	–	PyObject *resultobj = 0;
5788	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5789	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
5790	–	std::map<std::string,std::string >::mapped_type *arg3 = 0 ;
5791	–	void *argp1 = 0 ;
5792	–	int res1 = 0 ;
5793	–	int res2 = SWIG_OLDOBJ ;
5794	–	int res3 = SWIG_OLDOBJ ;
5795	–	PyObject * obj0 = 0 ;
5796	–	PyObject * obj1 = 0 ;
5797	–	PyObject * obj2 = 0 ;
5798	–
5799	–	if (!PyArg_ParseTuple(args,(char *)"OOO:objectMap___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
5800	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5801	–	if (!SWIG_IsOK(res1)) {
5802	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___setitem__" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
5803	–	}
5804	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5805	–	{
5806	–	std::string *ptr = (std::string *)0;
5807	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5808	–	if (!SWIG_IsOK(res2)) {
5809	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap___setitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5810	–	}
5811	–	if (!ptr) {
5812	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap___setitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
1347		}
1348	<	arg2 = ptr;
1349	<	}
5816	<	{
5817	<	std::string *ptr = (std::string *)0;
5818	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
5819	<	if (!SWIG_IsOK(res3)) {
5820	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "objectMap___setitem__" "', argument " "3"" of type '" "std::map<std::string,std::string >::mapped_type const &""'");
5821	<	}
5822	<	if (!ptr) {
5823	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap___setitem__" "', argument " "3"" of type '" "std::map<std::string,std::string >::mapped_type const &""'");
5824	<	}
5825	<	arg3 = ptr;
5826	<	}
5827	<	{
5828	<	try {
5829	<	try {
5830	<	std_map_Sl_std_string_Sc_std_string_Sg____setitem__(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
5831	<	}
5832	<	catch(std::out_of_range &_e) {
5833	<	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5834	<	}
5835	<
5836	<	} catch (const std::exception& e) {
5837	<	SWIG_exception(SWIG_RuntimeError, e.what());
5838	<	}
5839	<	}
5840	<	resultobj = SWIG_Py_Void();
5841	<	if (SWIG_IsNewObj(res2)) delete arg2;
5842	<	if (SWIG_IsNewObj(res3)) delete arg3;
5843	<	return resultobj;
5844	<	fail:
5845	<	if (SWIG_IsNewObj(res2)) delete arg2;
5846	<	if (SWIG_IsNewObj(res3)) delete arg3;
5847	<	return NULL;
5848	<	}
5849	<
5850	<
5851	<	SWIGINTERN PyObject *_wrap_objectMap___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5852	<	PyObject *resultobj = 0;
5853	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5854	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
5855	<	void *argp1 = 0 ;
5856	<	int res1 = 0 ;
5857	<	int res2 = SWIG_OLDOBJ ;
5858	<	PyObject * obj0 = 0 ;
5859	<	PyObject * obj1 = 0 ;
5860	<
5861	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap___delitem__",&obj0,&obj1)) SWIG_fail;
5862	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5863	<	if (!SWIG_IsOK(res1)) {
5864	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___delitem__" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
5865	<	}
5866	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5867	<	{
5868	<	std::string *ptr = (std::string *)0;
5869	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5870	<	if (!SWIG_IsOK(res2)) {
5871	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap___delitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5872	<	}
5873	<	if (!ptr) {
5874	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap___delitem__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5875	<	}
5876	<	arg2 = ptr;
5877	<	}
5878	<	{
5879	<	try {
5880	<	try {
5881	<	std_map_Sl_std_string_Sc_std_string_Sg____delitem__(arg1,(std::string const &)*arg2);
5882	<	}
5883	<	catch(std::out_of_range &_e) {
5884	<	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
5885	<	}
5886	<
5887	<	} catch (const std::exception& e) {
5888	<	SWIG_exception(SWIG_RuntimeError, e.what());
5889	<	}
5890	<	}
5891	<	resultobj = SWIG_Py_Void();
5892	<	if (SWIG_IsNewObj(res2)) delete arg2;
5893	<	return resultobj;
5894	<	fail:
5895	<	if (SWIG_IsNewObj(res2)) delete arg2;
5896	<	return NULL;
5897	<	}
5898	<
5899	<
5900	<	SWIGINTERN PyObject *_wrap_objectMap_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5901	<	PyObject *resultobj = 0;
5902	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5903	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
5904	<	bool result;
5905	<	void *argp1 = 0 ;
5906	<	int res1 = 0 ;
5907	<	int res2 = SWIG_OLDOBJ ;
5908	<	PyObject * obj0 = 0 ;
5909	<	PyObject * obj1 = 0 ;
5910	<
5911	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_has_key",&obj0,&obj1)) SWIG_fail;
5912	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5913	<	if (!SWIG_IsOK(res1)) {
5914	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_has_key" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
5915	<	}
5916	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5917	<	{
5918	<	std::string *ptr = (std::string *)0;
5919	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5920	<	if (!SWIG_IsOK(res2)) {
5921	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_has_key" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5922	<	}
5923	<	if (!ptr) {
5924	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_has_key" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
5925	<	}
5926	<	arg2 = ptr;
5927	<	}
5928	<	{
5929	<	try {
5930	<	result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__has_key((std::map<std::string,std::string > const *)arg1,(std::string const &)*arg2);
5931	<	} catch (const std::exception& e) {
5932	<	SWIG_exception(SWIG_RuntimeError, e.what());
5933	<	}
5934	<	}
5935	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
5936	<	if (SWIG_IsNewObj(res2)) delete arg2;
5937	<	return resultobj;
5938	<	fail:
5939	<	if (SWIG_IsNewObj(res2)) delete arg2;
5940	<	return NULL;
5941	<	}
5942	<
5943	<
5944	<	SWIGINTERN PyObject *_wrap_objectMap_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5945	<	PyObject *resultobj = 0;
5946	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5947	<	PyObject *result = 0 ;
5948	<	void *argp1 = 0 ;
5949	<	int res1 = 0 ;
5950	<	PyObject * obj0 = 0 ;
5951	<
5952	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_keys",&obj0)) SWIG_fail;
5953	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5954	<	if (!SWIG_IsOK(res1)) {
5955	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_keys" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
5956	<	}
5957	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5958	<	{
5959	<	try {
5960	<	result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__keys(arg1);
5961	<	} catch (const std::exception& e) {
5962	<	SWIG_exception(SWIG_RuntimeError, e.what());
5963	<	}
5964	<	}
5965	<	resultobj = result;
5966	<	return resultobj;
5967	<	fail:
5968	<	return NULL;
5969	<	}
5970	<
5971	<
5972	<	SWIGINTERN PyObject *_wrap_objectMap_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5973	<	PyObject *resultobj = 0;
5974	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
5975	<	PyObject *result = 0 ;
5976	<	void *argp1 = 0 ;
5977	<	int res1 = 0 ;
5978	<	PyObject * obj0 = 0 ;
5979	<
5980	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_values",&obj0)) SWIG_fail;
5981	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
5982	<	if (!SWIG_IsOK(res1)) {
5983	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_values" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
5984	<	}
5985	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
5986	<	{
5987	<	try {
5988	<	result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__values(arg1);
5989	<	} catch (const std::exception& e) {
5990	<	SWIG_exception(SWIG_RuntimeError, e.what());
5991	<	}
5992	<	}
5993	<	resultobj = result;
5994	<	return resultobj;
5995	<	fail:
5996	<	return NULL;
5997	<	}
5998	<
5999	<
6000	<	SWIGINTERN PyObject *_wrap_objectMap_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6001	<	PyObject *resultobj = 0;
6002	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6003	<	PyObject *result = 0 ;
6004	<	void *argp1 = 0 ;
6005	<	int res1 = 0 ;
6006	<	PyObject * obj0 = 0 ;
6007	<
6008	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_items",&obj0)) SWIG_fail;
6009	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6010	<	if (!SWIG_IsOK(res1)) {
6011	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_items" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6012	<	}
6013	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6014	<	{
6015	<	try {
6016	<	result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__items(arg1);
6017	<	} catch (const std::exception& e) {
6018	<	SWIG_exception(SWIG_RuntimeError, e.what());
6019	<	}
6020	<	}
6021	<	resultobj = result;
6022	<	return resultobj;
6023	<	fail:
6024	<	return NULL;
6025	<	}
6026	<
6027	<
6028	<	SWIGINTERN PyObject *_wrap_objectMap___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6029	<	PyObject *resultobj = 0;
6030	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6031	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
6032	<	bool result;
6033	<	void *argp1 = 0 ;
6034	<	int res1 = 0 ;
6035	<	int res2 = SWIG_OLDOBJ ;
6036	<	PyObject * obj0 = 0 ;
6037	<	PyObject * obj1 = 0 ;
6038	<
6039	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap___contains__",&obj0,&obj1)) SWIG_fail;
6040	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6041	<	if (!SWIG_IsOK(res1)) {
6042	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap___contains__" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6043	<	}
6044	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6045	<	{
6046	<	std::string *ptr = (std::string *)0;
6047	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
6048	<	if (!SWIG_IsOK(res2)) {
6049	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap___contains__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
6050	<	}
6051	<	if (!ptr) {
6052	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap___contains__" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
6053	<	}
6054	<	arg2 = ptr;
6055	<	}
6056	<	{
6057	<	try {
6058	<	result = (bool)std_map_Sl_std_string_Sc_std_string_Sg____contains__(arg1,(std::string const &)*arg2);
6059	<	} catch (const std::exception& e) {
6060	<	SWIG_exception(SWIG_RuntimeError, e.what());
6061	<	}
6062	<	}
6063	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
6064	<	if (SWIG_IsNewObj(res2)) delete arg2;
6065	<	return resultobj;
6066	<	fail:
6067	<	if (SWIG_IsNewObj(res2)) delete arg2;
6068	<	return NULL;
6069	<	}
6070	<
6071	<
6072	<	SWIGINTERN PyObject *_wrap_objectMap_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6073	<	PyObject *resultobj = 0;
6074	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6075	<	PyObject **arg2 = (PyObject **) 0 ;
6076	<	swig::PySwigIterator *result = 0 ;
6077	<	void *argp1 = 0 ;
6078	<	int res1 = 0 ;
6079	<	PyObject * obj0 = 0 ;
6080	<
6081	<	arg2 = &obj0;
6082	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_key_iterator",&obj0)) SWIG_fail;
6083	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6084	<	if (!SWIG_IsOK(res1)) {
6085	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_key_iterator" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6086	<	}
6087	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6088	<	{
6089	<	try {
6090	<	result = (swig::PySwigIterator *)std_map_Sl_std_string_Sc_std_string_Sg__key_iterator(arg1,arg2);
6091	<	} catch (const std::exception& e) {
6092	<	SWIG_exception(SWIG_RuntimeError, e.what());
6093	<	}
6094	<	}
6095	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
6096	<	return resultobj;
6097	<	fail:
6098	<	return NULL;
6099	<	}
6100	<
6101	<
6102	<	SWIGINTERN PyObject *_wrap_objectMap_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6103	<	PyObject *resultobj = 0;
6104	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6105	<	PyObject **arg2 = (PyObject **) 0 ;
6106	<	swig::PySwigIterator *result = 0 ;
6107	<	void *argp1 = 0 ;
6108	<	int res1 = 0 ;
6109	<	PyObject * obj0 = 0 ;
6110	<
6111	<	arg2 = &obj0;
6112	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_value_iterator",&obj0)) SWIG_fail;
6113	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6114	<	if (!SWIG_IsOK(res1)) {
6115	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_value_iterator" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6116	<	}
6117	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6118	<	{
6119	<	try {
6120	<	result = (swig::PySwigIterator *)std_map_Sl_std_string_Sc_std_string_Sg__value_iterator(arg1,arg2);
6121	<	} catch (const std::exception& e) {
6122	<	SWIG_exception(SWIG_RuntimeError, e.what());
6123	<	}
6124	<	}
6125	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
6126	<	return resultobj;
6127	<	fail:
6128	<	return NULL;
6129	<	}
6130	<
6131	<
6132	<	SWIGINTERN PyObject *_wrap_new_objectMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6133	<	PyObject *resultobj = 0;
6134	<	std::map<std::string,std::string > *result = 0 ;
6135	<
6136	<	if (!PyArg_ParseTuple(args,(char *)":new_objectMap")) SWIG_fail;
6137	<	{
6138	<	try {
6139	<	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >();
6140	<	} catch (const std::exception& e) {
6141	<	SWIG_exception(SWIG_RuntimeError, e.what());
6142	<	}
6143	<	}
6144	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, SWIG_POINTER_NEW |  0 );
6145	<	return resultobj;
6146	<	fail:
6147	<	return NULL;
6148	<	}
6149	<
6150	<
6151	<	SWIGINTERN PyObject *_wrap_new_objectMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6152	<	PyObject *resultobj = 0;
6153	<	std::map<std::string,std::string > *arg1 = 0 ;
6154	<	std::map<std::string,std::string > *result = 0 ;
6155	<	int res1 = SWIG_OLDOBJ ;
6156	<	PyObject * obj0 = 0 ;
6157	<
6158	<	if (!PyArg_ParseTuple(args,(char *)"O:new_objectMap",&obj0)) SWIG_fail;
6159	<	{
6160	<	std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > *ptr = (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > *)0;
6161	<	res1 = swig::asptr(obj0, &ptr);
6162	<	if (!SWIG_IsOK(res1)) {
6163	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_objectMap" "', argument " "1"" of type '" "std::map<std::string,std::string > const &""'");
6164	<	}
6165	<	if (!ptr) {
6166	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_objectMap" "', argument " "1"" of type '" "std::map<std::string,std::string > const &""'");
6167	<	}
6168	<	arg1 = ptr;
6169	<	}
6170	<	{
6171	<	try {
6172	<	result = (std::map<std::string,std::string > *)new std::map<std::string,std::string >((std::map<std::string,std::string > const &)*arg1);
6173	<	} catch (const std::exception& e) {
6174	<	SWIG_exception(SWIG_RuntimeError, e.what());
6175	<	}
6176	<	}
6177	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, SWIG_POINTER_NEW |  0 );
6178	<	if (SWIG_IsNewObj(res1)) delete arg1;
6179	<	return resultobj;
6180	<	fail:
6181	<	if (SWIG_IsNewObj(res1)) delete arg1;
6182	<	return NULL;
6183	<	}
6184	<
6185	<
6186	<	SWIGINTERN PyObject *_wrap_new_objectMap(PyObject *self, PyObject *args) {
6187	<	int argc;
6188	<	PyObject *argv[2];
6189	<	int ii;
6190	<
6191	<	if (!PyTuple_Check(args)) SWIG_fail;
6192	<	argc = PyObject_Length(args);
6193	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
6194	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
6195	<	}
6196	<	if (argc == 0) {
6197	<	return _wrap_new_objectMap__SWIG_0(self, args);
6198	<	}
6199	<	if (argc == 1) {
6200	<	int _v;
6201	<	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
6202	<	_v = SWIG_CheckState(res);
6203	<	if (_v) {
6204	<	return _wrap_new_objectMap__SWIG_1(self, args);
6205	<	}
6206	<	}
6207	<
6208	<	fail:
6209	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_objectMap'");
6210	<	return NULL;
6211	<	}
6212	<
6213	<
6214	<	SWIGINTERN PyObject *_wrap_objectMap_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6215	<	PyObject *resultobj = 0;
6216	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6217	<	bool result;
6218	<	void *argp1 = 0 ;
6219	<	int res1 = 0 ;
6220	<	PyObject * obj0 = 0 ;
6221	<
6222	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_empty",&obj0)) SWIG_fail;
6223	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6224	<	if (!SWIG_IsOK(res1)) {
6225	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_empty" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6226	<	}
6227	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6228	<	{
6229	<	try {
6230	<	result = (bool)((std::map<std::string,std::string > const *)arg1)->empty();
6231	<	} catch (const std::exception& e) {
6232	<	SWIG_exception(SWIG_RuntimeError, e.what());
6233	<	}
6234	<	}
6235	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
6236	<	return resultobj;
6237	<	fail:
6238	<	return NULL;
6239	<	}
6240	<
6241	<
6242	<	SWIGINTERN PyObject *_wrap_objectMap_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6243	<	PyObject *resultobj = 0;
6244	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6245	<	std::map<std::string,std::string >::size_type result;
6246	<	void *argp1 = 0 ;
6247	<	int res1 = 0 ;
6248	<	PyObject * obj0 = 0 ;
6249	<
6250	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_size",&obj0)) SWIG_fail;
6251	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6252	<	if (!SWIG_IsOK(res1)) {
6253	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_size" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6254	<	}
6255	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6256	<	{
6257	<	try {
6258	<	result = ((std::map<std::string,std::string > const *)arg1)->size();
6259	<	} catch (const std::exception& e) {
6260	<	SWIG_exception(SWIG_RuntimeError, e.what());
6261	<	}
6262	<	}
6263	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6264	<	return resultobj;
6265	<	fail:
6266	<	return NULL;
6267	<	}
6268	<
6269	<
6270	<	SWIGINTERN PyObject *_wrap_objectMap_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6271	<	PyObject *resultobj = 0;
6272	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6273	<	void *argp1 = 0 ;
6274	<	int res1 = 0 ;
6275	<	PyObject * obj0 = 0 ;
6276	<
6277	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_clear",&obj0)) SWIG_fail;
6278	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6279	<	if (!SWIG_IsOK(res1)) {
6280	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_clear" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6281	<	}
6282	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6283	<	{
6284	<	try {
6285	<	(arg1)->clear();
6286	<	} catch (const std::exception& e) {
6287	<	SWIG_exception(SWIG_RuntimeError, e.what());
6288	<	}
6289	<	}
6290	<	resultobj = SWIG_Py_Void();
6291	<	return resultobj;
6292	<	fail:
6293	<	return NULL;
6294	<	}
6295	<
6296	<
6297	<	SWIGINTERN PyObject *_wrap_objectMap_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6298	<	PyObject *resultobj = 0;
6299	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6300	<	std::map<std::string,std::string > *arg2 = 0 ;
6301	<	void *argp1 = 0 ;
6302	<	int res1 = 0 ;
6303	<	void *argp2 = 0 ;
6304	<	int res2 = 0 ;
6305	<	PyObject * obj0 = 0 ;
6306	<	PyObject * obj1 = 0 ;
6307	<
6308	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_swap",&obj0,&obj1)) SWIG_fail;
6309	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6310	<	if (!SWIG_IsOK(res1)) {
6311	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_swap" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6312	<	}
6313	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6314	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t,  0 );
6315	<	if (!SWIG_IsOK(res2)) {
6316	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_swap" "', argument " "2"" of type '" "std::map<std::string,std::string > &""'");
6317	<	}
6318	<	if (!argp2) {
6319	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_swap" "', argument " "2"" of type '" "std::map<std::string,std::string > &""'");
6320	<	}
6321	<	arg2 = reinterpret_cast< std::map<std::string,std::string > * >(argp2);
6322	<	{
6323	<	try {
6324	<	(arg1)->swap(*arg2);
6325	<	} catch (const std::exception& e) {
6326	<	SWIG_exception(SWIG_RuntimeError, e.what());
6327	<	}
6328	<	}
6329	<	resultobj = SWIG_Py_Void();
6330	<	return resultobj;
6331	<	fail:
6332	<	return NULL;
6333	<	}
6334	<
6335	<
6336	<	SWIGINTERN PyObject *_wrap_objectMap_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6337	<	PyObject *resultobj = 0;
6338	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6339	<	SwigValueWrapper<std::allocator<std::pair<std::string const,std::string > > > result;
6340	<	void *argp1 = 0 ;
6341	<	int res1 = 0 ;
6342	<	PyObject * obj0 = 0 ;
6343	<
6344	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_get_allocator",&obj0)) SWIG_fail;
6345	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6346	<	if (!SWIG_IsOK(res1)) {
6347	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_get_allocator" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
6348	<	}
6349	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6350	<	{
6351	<	try {
6352	<	result = ((std::map<std::string,std::string > const *)arg1)->get_allocator();
6353	<	} catch (const std::exception& e) {
6354	<	SWIG_exception(SWIG_RuntimeError, e.what());
6355	<	}
6356	<	}
6357	<	resultobj = SWIG_NewPointerObj((new std::map<std::string,std::string >::allocator_type(static_cast< const std::map<std::string,std::string >::allocator_type& >(result))), SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
6358	<	return resultobj;
6359	<	fail:
6360	<	return NULL;
6361	<	}
6362	<
6363	<
6364	<	SWIGINTERN PyObject *_wrap_objectMap_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6365	<	PyObject *resultobj = 0;
6366	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6367	<	std::map<std::string,std::string >::iterator result;
6368	<	void *argp1 = 0 ;
6369	<	int res1 = 0 ;
6370	<	PyObject * obj0 = 0 ;
6371	<
6372	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_begin",&obj0)) SWIG_fail;
6373	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6374	<	if (!SWIG_IsOK(res1)) {
6375	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_begin" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6376	<	}
6377	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6378	<	{
6379	<	try {
6380	<	result = (arg1)->begin();
6381	<	} catch (const std::exception& e) {
6382	<	SWIG_exception(SWIG_RuntimeError, e.what());
1348	>	{
1349	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1350		}
1351	<	}
1352	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
1353	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
6387	<	return resultobj;
6388	<	fail:
6389	<	return NULL;
1351	>	return resultobj;
1352	>	fail:
1353	>	return NULL;
1354		}
1355
1356
1357	<	SWIGINTERN PyObject *_wrap_objectMap_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1358	<	PyObject *resultobj = 0;
1359	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1360	<	std::map<std::string,std::string >::const_iterator result;
1361	<	void *argp1 = 0 ;
1362	<	int res1 = 0 ;
1363	<	PyObject * obj0 = 0 ;
1364	<
1365	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_begin",&obj0)) SWIG_fail;
1366	<	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 );
1367	<	if (!SWIG_IsOK(res1)) {
1368	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_begin" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
1369	<	}
1370	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1371	<	{
1372	<	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());
1357	>	static PyObject *_wrap_objectMap___setitem__(PyObject *self, PyObject *args) {
1358	>	PyObject *resultobj;
1359	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1360	>	std::string arg2 ;
1361	>	std::string arg3 ;
1362	>	PyObject * obj0 = 0 ;
1363	>	PyObject * obj1 = 0 ;
1364	>	PyObject * obj2 = 0 ;
1365	>
1366	>	if(!PyArg_ParseTuple(args,(char *)"OOO:objectMap___setitem__",&obj0,&obj1,&obj2)) goto fail;
1367	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1368	>	{
1369	>	if (PyString_Check(obj1))
1370	>	arg2 = std::string(PyString_AsString(obj1));
1371	>	else
1372	>	SWIG_exception(SWIG_TypeError, "string expected");
1373		}
1374	<	}
1375	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
1376	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1377	<	return resultobj;
1378	<	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);
1374	>	{
1375	>	if (PyString_Check(obj2))
1376	>	arg3 = std::string(PyString_AsString(obj2));
1377	>	else
1378	>	SWIG_exception(SWIG_TypeError, "string expected");
1379		}
1380	<	}
1381	<	if (argc == 1) {
1382	<	int _v;
1383	<	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));
1384	<	_v = SWIG_CheckState(res);
1385	<	if (_v) {
1386	<	return _wrap_objectMap_begin__SWIG_1(self, args);
1380	>	{
1381	>	try {
1382	>	std_maplstd_stringcstd_string_g___setitem_____(arg1,arg2,arg3);
1383	>
1384	>	}catch (const std::exception& e) {
1385	>	SWIG_exception(SWIG_RuntimeError, e.what());
1386	>	}
1387		}
1388	<	}
1389	<
1390	<	fail:
1391	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_begin'");
6451	<	return NULL;
1388	>	Py_INCREF(Py_None); resultobj = Py_None;
1389	>	return resultobj;
1390	>	fail:
1391	>	return NULL;
1392		}
1393
1394
1395	<	SWIGINTERN PyObject *_wrap_objectMap_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1396	<	PyObject *resultobj = 0;
1397	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1398	<	std::map<std::string,std::string >::iterator result;
1399	<	void *argp1 = 0 ;
1400	<	int res1 = 0 ;
1401	<	PyObject * obj0 = 0 ;
1402	<
1403	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_end",&obj0)) SWIG_fail;
1404	<	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 );
1405	<	if (!SWIG_IsOK(res1)) {
1406	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_end" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1407	<	}
1408	<	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());
1395	>	static PyObject *_wrap_objectMap___delitem__(PyObject *self, PyObject *args) {
1396	>	PyObject *resultobj;
1397	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1398	>	std::string arg2 ;
1399	>	PyObject * obj0 = 0 ;
1400	>	PyObject * obj1 = 0 ;
1401	>
1402	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___delitem__",&obj0,&obj1)) goto fail;
1403	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1404	>	{
1405	>	if (PyString_Check(obj1))
1406	>	arg2 = std::string(PyString_AsString(obj1));
1407	>	else
1408	>	SWIG_exception(SWIG_TypeError, "string expected");
1409		}
1410	<	}
1411	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
1412	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1413	<	return resultobj;
1414	<	fail:
1415	<	return NULL;
1416	<	}
1417	<
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());
1410	>	{
1411	>	try {
1412	>	std_maplstd_stringcstd_string_g___delitem_____(arg1,arg2);
1413	>
1414	>	}catch (std::out_of_range& e) {
1415	>	PyErr_SetString(PyExc_KeyError,const_cast<char*>(e.what()));
1416	>	SWIG_fail;
1417	>	}
1418		}
1419	<	}
1420	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
1421	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1422	<	return resultobj;
6508	<	fail:
6509	<	return NULL;
1419	>	Py_INCREF(Py_None); resultobj = Py_None;
1420	>	return resultobj;
1421	>	fail:
1422	>	return NULL;
1423		}
1424
1425
1426	<	SWIGINTERN PyObject *_wrap_objectMap_end(PyObject *self, PyObject *args) {
1427	<	int argc;
1428	<	PyObject *argv[2];
1429	<	int ii;
1430	<
1431	<	if (!PyTuple_Check(args)) SWIG_fail;
1432	<	argc = PyObject_Length(args);
1433	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1434	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1435	<	}
1436	<	if (argc == 1) {
1437	<	int _v;
1438	<	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));
1439	<	_v = SWIG_CheckState(res);
1440	<	if (_v) {
6528	<	return _wrap_objectMap_end__SWIG_0(self, args);
1426	>	static PyObject *_wrap_objectMap_has_key(PyObject *self, PyObject *args) {
1427	>	PyObject *resultobj;
1428	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1429	>	std::string arg2 ;
1430	>	bool result;
1431	>	PyObject * obj0 = 0 ;
1432	>	PyObject * obj1 = 0 ;
1433	>
1434	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap_has_key",&obj0,&obj1)) goto fail;
1435	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1436	>	{
1437	>	if (PyString_Check(obj1))
1438	>	arg2 = std::string(PyString_AsString(obj1));
1439	>	else
1440	>	SWIG_exception(SWIG_TypeError, "string expected");
1441		}
1442	<	}
1443	<	if (argc == 1) {
1444	<	int _v;
1445	<	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));
1446	<	_v = SWIG_CheckState(res);
1447	<	if (_v) {
1448	<	return _wrap_objectMap_end__SWIG_1(self, args);
1442	>	{
1443	>	try {
1444	>	result = (bool)std_maplstd_stringcstd_string_g_has_key___(arg1,arg2);
1445	>
1446	>	}catch (const std::exception& e) {
1447	>	SWIG_exception(SWIG_RuntimeError, e.what());
1448	>	}
1449		}
1450	<	}
1451	<
1452	<	fail:
1453	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_end'");
6542	<	return NULL;
1450	>	resultobj = PyInt_FromLong((long)result);
1451	>	return resultobj;
1452	>	fail:
1453	>	return NULL;
1454		}
1455
1456
1457	<	SWIGINTERN PyObject *_wrap_objectMap_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1458	<	PyObject *resultobj = 0;
1459	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1460	<	std::map<std::string,std::string >::reverse_iterator result;
1461	<	void *argp1 = 0 ;
1462	<	int res1 = 0 ;
1463	<	PyObject * obj0 = 0 ;
1464	<
1465	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rbegin",&obj0)) SWIG_fail;
1466	<	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 );
1467	<	if (!SWIG_IsOK(res1)) {
1468	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rbegin" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1469	<	}
1470	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1471	<	{
6561	<	try {
6562	<	result = (arg1)->rbegin();
6563	<	} catch (const std::exception& e) {
6564	<	SWIG_exception(SWIG_RuntimeError, e.what());
1457	>	static PyObject *_wrap_objectMap_keys(PyObject *self, PyObject *args) {
1458	>	PyObject *resultobj;
1459	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1460	>	PyObject *result;
1461	>	PyObject * obj0 = 0 ;
1462	>
1463	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_keys",&obj0)) goto fail;
1464	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1465	>	{
1466	>	try {
1467	>	result = (PyObject *)std_maplstd_stringcstd_string_g_keys___(arg1);
1468	>
1469	>	}catch (const std::exception& e) {
1470	>	SWIG_exception(SWIG_RuntimeError, e.what());
1471	>	}
1472		}
1473	<	}
1474	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::reverse_iterator & >(result)),
1475	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1476	<	return resultobj;
6570	<	fail:
6571	<	return NULL;
1473	>	resultobj = result;
1474	>	return resultobj;
1475	>	fail:
1476	>	return NULL;
1477		}
1478
1479
1480	<	SWIGINTERN PyObject *_wrap_objectMap_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1481	<	PyObject *resultobj = 0;
1482	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1483	<	std::map<std::string,std::string >::const_reverse_iterator result;
1484	<	void *argp1 = 0 ;
1485	<	int res1 = 0 ;
1486	<	PyObject * obj0 = 0 ;
1487	<
1488	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rbegin",&obj0)) SWIG_fail;
1489	<	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 );
1490	<	if (!SWIG_IsOK(res1)) {
1491	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rbegin" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
1492	<	}
1493	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1494	<	{
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());
1480	>	static PyObject *_wrap_objectMap_values(PyObject *self, PyObject *args) {
1481	>	PyObject *resultobj;
1482	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1483	>	PyObject *result;
1484	>	PyObject * obj0 = 0 ;
1485	>
1486	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_values",&obj0)) goto fail;
1487	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1488	>	{
1489	>	try {
1490	>	result = (PyObject *)std_maplstd_stringcstd_string_g_values___(arg1);
1491	>
1492	>	}catch (const std::exception& e) {
1493	>	SWIG_exception(SWIG_RuntimeError, e.what());
1494	>	}
1495		}
1496	<	}
1497	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_reverse_iterator & >(result)),
1498	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1499	<	return resultobj;
6599	<	fail:
6600	<	return NULL;
1496	>	resultobj = result;
1497	>	return resultobj;
1498	>	fail:
1499	>	return NULL;
1500		}
1501
1502
1503	<	SWIGINTERN PyObject *_wrap_objectMap_rbegin(PyObject *self, PyObject *args) {
1504	<	int argc;
1505	<	PyObject *argv[2];
1506	<	int ii;
1507	<
1508	<	if (!PyTuple_Check(args)) SWIG_fail;
1509	<	argc = PyObject_Length(args);
1510	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1511	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1512	<	}
1513	<	if (argc == 1) {
1514	<	int _v;
1515	<	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));
1516	<	_v = SWIG_CheckState(res);
1517	<	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);
1503	>	static PyObject *_wrap_objectMap_items(PyObject *self, PyObject *args) {
1504	>	PyObject *resultobj;
1505	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1506	>	PyObject *result;
1507	>	PyObject * obj0 = 0 ;
1508	>
1509	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap_items",&obj0)) goto fail;
1510	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1511	>	{
1512	>	try {
1513	>	result = (PyObject *)std_maplstd_stringcstd_string_g_items___(arg1);
1514	>
1515	>	}catch (const std::exception& e) {
1516	>	SWIG_exception(SWIG_RuntimeError, e.what());
1517	>	}
1518		}
1519	<	}
1520	<
1521	<	fail:
1522	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_rbegin'");
6633	<	return NULL;
1519	>	resultobj = result;
1520	>	return resultobj;
1521	>	fail:
1522	>	return NULL;
1523		}
1524
1525
1526	<	SWIGINTERN PyObject *_wrap_objectMap_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1527	<	PyObject *resultobj = 0;
1528	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1529	<	std::map<std::string,std::string >::reverse_iterator result;
1530	<	void *argp1 = 0 ;
1531	<	int res1 = 0 ;
1532	<	PyObject * obj0 = 0 ;
1533	<
1534	<	if (!PyArg_ParseTuple(args,(char *)"O:objectMap_rend",&obj0)) SWIG_fail;
1535	<	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 );
1536	<	if (!SWIG_IsOK(res1)) {
1537	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_rend" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1538	<	}
1539	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1540	<	{
6652	<	try {
6653	<	result = (arg1)->rend();
6654	<	} catch (const std::exception& e) {
6655	<	SWIG_exception(SWIG_RuntimeError, e.what());
1526	>	static PyObject *_wrap_objectMap___contains__(PyObject *self, PyObject *args) {
1527	>	PyObject *resultobj;
1528	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1529	>	std::string arg2 ;
1530	>	bool result;
1531	>	PyObject * obj0 = 0 ;
1532	>	PyObject * obj1 = 0 ;
1533	>
1534	>	if(!PyArg_ParseTuple(args,(char *)"OO:objectMap___contains__",&obj0,&obj1)) goto fail;
1535	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1536	>	{
1537	>	if (PyString_Check(obj1))
1538	>	arg2 = std::string(PyString_AsString(obj1));
1539	>	else
1540	>	SWIG_exception(SWIG_TypeError, "string expected");
1541		}
1542	<	}
1543	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::reverse_iterator & >(result)),
1544	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1545	<	return resultobj;
1546	<	fail:
1547	<	return NULL;
1548	<	}
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());
1542	>	{
1543	>	try {
1544	>	result = (bool)std_maplstd_stringcstd_string_g___contains_____(arg1,arg2);
1545	>
1546	>	}catch (const std::exception& e) {
1547	>	SWIG_exception(SWIG_RuntimeError, e.what());
1548	>	}
1549		}
1550	<	}
1551	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_reverse_iterator & >(result)),
1552	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1553	<	return resultobj;
6690	<	fail:
6691	<	return NULL;
1550	>	resultobj = PyInt_FromLong((long)result);
1551	>	return resultobj;
1552	>	fail:
1553	>	return NULL;
1554		}
1555
1556
1557	<	SWIGINTERN PyObject *_wrap_objectMap_rend(PyObject *self, PyObject *args) {
1558	<	int argc;
1559	<	PyObject *argv[2];
1560	<	int ii;
1561	<
1562	<	if (!PyTuple_Check(args)) SWIG_fail;
1563	<	argc = PyObject_Length(args);
1564	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1565	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1566	<	}
1567	<	if (argc == 1) {
1568	<	int _v;
1569	<	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));
1570	<	_v = SWIG_CheckState(res);
1571	<	if (_v) {
1572	<	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);
1557	>	static PyObject *_wrap_objectMap___iter__(PyObject *self, PyObject *args) {
1558	>	PyObject *resultobj;
1559	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1560	>	PyObject *result;
1561	>	PyObject * obj0 = 0 ;
1562	>
1563	>	if(!PyArg_ParseTuple(args,(char *)"O:objectMap___iter__",&obj0)) goto fail;
1564	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1565	>	{
1566	>	try {
1567	>	result = (PyObject *)std_maplstd_stringcstd_string_g___iter_____(arg1);
1568	>
1569	>	}catch (std::runtime_error& e) {
1570	>	PyErr_SetString(PyExc_RuntimeError,const_cast<char*>(e.what()));
1571	>	SWIG_fail;
1572	>	}
1573		}
1574	<	}
1575	<
1576	<	fail:
1577	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_rend'");
6724	<	return NULL;
1574	>	resultobj = result;
1575	>	return resultobj;
1576	>	fail:
1577	>	return NULL;
1578		}
1579
1580
1581	<	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1582	<	PyObject *resultobj = 0;
1583	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1584	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
1585	<	std::map<std::string,std::string >::size_type result;
1586	<	void *argp1 = 0 ;
1587	<	int res1 = 0 ;
1588	<	int res2 = SWIG_OLDOBJ ;
1589	<	PyObject * obj0 = 0 ;
1590	<	PyObject * obj1 = 0 ;
1591	<
1592	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_erase",&obj0,&obj1)) SWIG_fail;
1593	<	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 );
1594	<	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());
1581	>	static PyObject *_wrap_delete_objectMap(PyObject *self, PyObject *args) {
1582	>	PyObject *resultobj;
1583	>	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1584	>	PyObject * obj0 = 0 ;
1585	>
1586	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_objectMap",&obj0)) goto fail;
1587	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1588	>	{
1589	>	try {
1590	>	delete arg1;
1591	>
1592	>	}catch (const std::exception& e) {
1593	>	SWIG_exception(SWIG_RuntimeError, e.what());
1594	>	}
1595		}
1596	<	}
1597	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
1598	<	if (SWIG_IsNewObj(res2)) delete arg2;
1599	<	return resultobj;
6766	<	fail:
6767	<	if (SWIG_IsNewObj(res2)) delete arg2;
6768	<	return NULL;
1596	>	Py_INCREF(Py_None); resultobj = Py_None;
1597	>	return resultobj;
1598	>	fail:
1599	>	return NULL;
1600		}
1601
1602
1603	<	SWIGINTERN PyObject *_wrap_objectMap_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1604	<	PyObject *resultobj = 0;
1605	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1606	<	std::map<std::string,std::string >::key_type *arg2 = 0 ;
1607	<	std::map<std::string,std::string >::size_type result;
1608	<	void *argp1 = 0 ;
1609	<	int res1 = 0 ;
1610	<	int res2 = SWIG_OLDOBJ ;
1611	<	PyObject * obj0 = 0 ;
1612	<	PyObject * obj1 = 0 ;
1613	<
1614	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_count",&obj0,&obj1)) SWIG_fail;
1615	<	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 );
1616	<	if (!SWIG_IsOK(res1)) {
1617	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_count" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
1618	<	}
1619	<	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 &""'");
1603	>	static PyObject * objectMap_swigregister(PyObject *self, PyObject *args) {
1604	>	PyObject *obj;
1605	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
1606	>	SWIG_TypeClientData(SWIGTYPE_p_std__mapTstd__string_std__string_t, obj);
1607	>	Py_INCREF(obj);
1608	>	return Py_BuildValue((char *)"");
1609	>	}
1610	>	static PyObject *_wrap_new_vector_string__SWIG_0(PyObject *self, PyObject *args) {
1611	>	PyObject *resultobj;
1612	>	unsigned int arg1 = (unsigned int) 0 ;
1613	>	std::vector<std::string > *result;
1614	>	PyObject * obj0 = 0 ;
1615	>
1616	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_vector_string",&obj0)) goto fail;
1617	>	if (obj0) {
1618	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1619	>	if (PyErr_Occurred()) SWIG_fail;
1620		}
1621	<	arg2 = ptr;
1622	<	}
1623	<	{
1624	<	try {
1625	<	result = ((std::map<std::string,std::string > const *)arg1)->count((std::map<std::string,std::string >::key_type const &)*arg2);
1626	<	} catch (const std::exception& e) {
1627	<	SWIG_exception(SWIG_RuntimeError, e.what());
1621	>	{
1622	>	try {
1623	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1);
1624	>
1625	>	}catch (const std::exception& e) {
1626	>	SWIG_exception(SWIG_RuntimeError, e.what());
1627	>	}
1628		}
1629	<	}
1630	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
1631	<	if (SWIG_IsNewObj(res2)) delete arg2;
1632	<	return resultobj;
6810	<	fail:
6811	<	if (SWIG_IsNewObj(res2)) delete arg2;
6812	<	return NULL;
1629	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1630	>	return resultobj;
1631	>	fail:
1632	>	return NULL;
1633		}
1634
1635
1636	<	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1637	<	PyObject *resultobj = 0;
1638	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1639	<	std::map<std::string,std::string >::iterator arg2 ;
1640	<	void *argp1 = 0 ;
1641	<	int res1 = 0 ;
1642	<	swig::PySwigIterator *iter2 = 0 ;
1643	<	int res2 ;
1644	<	PyObject * obj0 = 0 ;
1645	<	PyObject * obj1 = 0 ;
1646	<
1647	<	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_erase",&obj0,&obj1)) SWIG_fail;
1648	<	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 );
1649	<	if (!SWIG_IsOK(res1)) {
1650	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1651	<	}
1652	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1653	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
1654	<	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""'");
1636	>	static PyObject *_wrap_new_vector_string__SWIG_1(PyObject *self, PyObject *args) {
1637	>	PyObject *resultobj;
1638	>	unsigned int arg1 ;
1639	>	std::string *arg2 = 0 ;
1640	>	std::vector<std::string > *result;
1641	>	std::string temp2 ;
1642	>	PyObject * obj0 = 0 ;
1643	>	PyObject * obj1 = 0 ;
1644	>
1645	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) goto fail;
1646	>	arg1 = (unsigned int) PyInt_AsLong(obj0);
1647	>	if (PyErr_Occurred()) SWIG_fail;
1648	>	{
1649	>	if (PyString_Check(obj1)) {
1650	>	temp2 = std::string(PyString_AsString(obj1));
1651	>	arg2 = &temp2;
1652	>	}else {
1653	>	SWIG_exception(SWIG_TypeError, "string expected");
1654	>	}
1655		}
1656	<	}
1657	<	{
1658	<	try {
1659	<	(arg1)->erase(arg2);
1660	<	} catch (const std::exception& e) {
1661	<	SWIG_exception(SWIG_RuntimeError, e.what());
1656	>	{
1657	>	try {
1658	>	result = (std::vector<std::string > *)new std::vector<std::string >(arg1,(std::string const &)*arg2);
1659	>
1660	>	}catch (const std::exception& e) {
1661	>	SWIG_exception(SWIG_RuntimeError, e.what());
1662	>	}
1663		}
1664	<	}
1665	<	resultobj = SWIG_Py_Void();
1666	<	return resultobj;
1667	<	fail:
6854	<	return NULL;
1664	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1665	>	return resultobj;
1666	>	fail:
1667	>	return NULL;
1668		}
1669
1670
1671	<	SWIGINTERN PyObject *_wrap_objectMap_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1672	<	PyObject *resultobj = 0;
1673	<	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
1674	<	std::map<std::string,std::string >::iterator arg2 ;
1675	<	std::map<std::string,std::string >::iterator arg3 ;
1676	<	void *argp1 = 0 ;
1677	<	int res1 = 0 ;
1678	<	swig::PySwigIterator *iter2 = 0 ;
1679	<	int res2 ;
1680	<	swig::PySwigIterator *iter3 = 0 ;
1681	<	int res3 ;
1682	<	PyObject * obj0 = 0 ;
1683	<	PyObject * obj1 = 0 ;
1684	<	PyObject * obj2 = 0 ;
1685	<
1686	<	if (!PyArg_ParseTuple(args,(char *)"OOO:objectMap_erase",&obj0,&obj1,&obj2)) SWIG_fail;
1687	<	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 );
1688	<	if (!SWIG_IsOK(res1)) {
1689	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_erase" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
1690	<	}
1691	<	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
1692	<	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
1693	<	if (!SWIG_IsOK(res2) || !iter2) {
1694	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::iterator""'");
1695	<	} else {
1696	<	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);
1697	<	if (iter_t) {
1698	<	arg2 = iter_t->get_current();
1699	<	} else {
1700	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "2"" of type '" "std::map<std::string,std::string >::iterator""'");
1701	<	}
1702	<	}
1703	<	res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
1704	<	if (!SWIG_IsOK(res3) || !iter3) {
1705	<	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "objectMap_erase" "', argument " "3"" of type '" "std::map<std::string,std::string >::iterator""'");
1706	<	} 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""'");
1671	>	static PyObject *_wrap_new_vector_string__SWIG_2(PyObject *self, PyObject *args) {
1672	>	PyObject *resultobj;
1673	>	std::vector<std::string > *arg1 = 0 ;
1674	>	std::vector<std::string > *result;
1675	>	std::vector<std::string > temp1 ;
1676	>	std::vector<std::string > *v1 ;
1677	>	PyObject * obj0 = 0 ;
1678	>
1679	>	if(!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) goto fail;
1680	>	{
1681	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1682	>	unsigned int size = (PyTuple_Check(obj0) ?
1683	>	PyTuple_Size(obj0) :
1684	>	PyList_Size(obj0));
1685	>	temp1 = std::vector<std::string >(size);
1686	>	arg1 = &temp1;
1687	>	for (unsigned int i=0; i<size; i++) {
1688	>	PyObject* o = PySequence_GetItem(obj0,i);
1689	>	if (PyString_Check(o)) {
1690	>	temp1[i] = (std::string)(\
1691	>	SwigString_AsString(o));
1692	>	Py_DECREF(o);
1693	>	}else {
1694	>	Py_DECREF(o);
1695	>	PyErr_SetString(PyExc_TypeError,
1696	>	"vector<""std::string""> expected");
1697	>	SWIG_fail;
1698	>	}
1699	>	}
1700	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1701	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1702	>	arg1 = v1;
1703	>	}else {
1704	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1705	>	SWIG_fail;
1706	>	}
1707		}
1708	<	}
1709	<	{
1710	<	try {
1711	<	(arg1)->erase(arg2,arg3);
1712	<	} catch (const std::exception& e) {
1713	<	SWIG_exception(SWIG_RuntimeError, e.what());
1708	>	{
1709	>	try {
1710	>	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1711	>
1712	>	}catch (const std::exception& e) {
1713	>	SWIG_exception(SWIG_RuntimeError, e.what());
1714	>	}
1715		}
1716	<	}
1717	<	resultobj = SWIG_Py_Void();
1718	<	return resultobj;
1719	<	fail:
6911	<	return NULL;
1716	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_std__vectorTstd__string_t, 1);
1717	>	return resultobj;
1718	>	fail:
1719	>	return NULL;
1720		}
1721
1722
1723	<	SWIGINTERN PyObject *_wrap_objectMap_erase(PyObject *self, PyObject *args) {
1724	<	int argc;
1725	<	PyObject *argv[4];
1726	<	int ii;
1727	<
1728	<	if (!PyTuple_Check(args)) SWIG_fail;
1729	<	argc = PyObject_Length(args);
1730	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
1731	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1732	<	}
1733	<	if (argc == 2) {
1734	<	int _v;
1735	<	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));
1736	<	_v = SWIG_CheckState(res);
1737	<	if (_v) {
1738	<	swig::PySwigIterator *iter = 0;
1739	<	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));
1723	>	static PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
1724	>	int argc;
1725	>	PyObject *argv[3];
1726	>	int ii;
1727	>
1728	>	argc = PyObject_Length(args);
1729	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
1730	>	argv[ii] = PyTuple_GetItem(args,ii);
1731	>	}
1732	>	if ((argc >= 0) && (argc <= 1)) {
1733	>	int _v;
1734	>	if (argc <= 0) {
1735	>	return _wrap_new_vector_string__SWIG_0(self,args);
1736	>	}
1737	>	{
1738	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1739	>	}
1740		if (_v) {
1741	<	return _wrap_objectMap_erase__SWIG_2(self, args);
1741	>	return _wrap_new_vector_string__SWIG_0(self,args);
1742		}
6965	–	}
6966	–	}
6967	–	}
6968	–
6969	–	fail:
6970	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_erase'");
6971	–	return NULL;
6972	–	}
6973	–
6974	–
6975	–	SWIGINTERN PyObject *_wrap_objectMap_find__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6976	–	PyObject *resultobj = 0;
6977	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
6978	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
6979	–	std::map<std::string,std::string >::iterator result;
6980	–	void *argp1 = 0 ;
6981	–	int res1 = 0 ;
6982	–	int res2 = SWIG_OLDOBJ ;
6983	–	PyObject * obj0 = 0 ;
6984	–	PyObject * obj1 = 0 ;
6985	–
6986	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_find",&obj0,&obj1)) SWIG_fail;
6987	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
6988	–	if (!SWIG_IsOK(res1)) {
6989	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_find" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
6990	–	}
6991	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
6992	–	{
6993	–	std::string *ptr = (std::string *)0;
6994	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
6995	–	if (!SWIG_IsOK(res2)) {
6996	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_find" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
6997	–	}
6998	–	if (!ptr) {
6999	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_find" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7000	–	}
7001	–	arg2 = ptr;
7002	–	}
7003	–	{
7004	–	try {
7005	–	result = (arg1)->find((std::map<std::string,std::string >::key_type const &)*arg2);
7006	–	} catch (const std::exception& e) {
7007	–	SWIG_exception(SWIG_RuntimeError, e.what());
7008	–	}
7009	–	}
7010	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
7011	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7012	–	if (SWIG_IsNewObj(res2)) delete arg2;
7013	–	return resultobj;
7014	–	fail:
7015	–	if (SWIG_IsNewObj(res2)) delete arg2;
7016	–	return NULL;
7017	–	}
7018	–
7019	–
7020	–	SWIGINTERN PyObject *_wrap_objectMap_find__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7021	–	PyObject *resultobj = 0;
7022	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7023	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7024	–	std::map<std::string,std::string >::const_iterator result;
7025	–	void *argp1 = 0 ;
7026	–	int res1 = 0 ;
7027	–	int res2 = SWIG_OLDOBJ ;
7028	–	PyObject * obj0 = 0 ;
7029	–	PyObject * obj1 = 0 ;
7030	–
7031	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_find",&obj0,&obj1)) SWIG_fail;
7032	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7033	–	if (!SWIG_IsOK(res1)) {
7034	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_find" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
7035	–	}
7036	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7037	–	{
7038	–	std::string *ptr = (std::string *)0;
7039	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7040	–	if (!SWIG_IsOK(res2)) {
7041	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_find" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7042	–	}
7043	–	if (!ptr) {
7044	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_find" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7045	–	}
7046	–	arg2 = ptr;
7047	–	}
7048	–	{
7049	–	try {
7050	–	result = ((std::map<std::string,std::string > const *)arg1)->find((std::map<std::string,std::string >::key_type const &)*arg2);
7051	–	} catch (const std::exception& e) {
7052	–	SWIG_exception(SWIG_RuntimeError, e.what());
7053	–	}
7054	–	}
7055	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
7056	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7057	–	if (SWIG_IsNewObj(res2)) delete arg2;
7058	–	return resultobj;
7059	–	fail:
7060	–	if (SWIG_IsNewObj(res2)) delete arg2;
7061	–	return NULL;
7062	–	}
7063	–
7064	–
7065	–	SWIGINTERN PyObject *_wrap_objectMap_find(PyObject *self, PyObject *args) {
7066	–	int argc;
7067	–	PyObject *argv[3];
7068	–	int ii;
7069	–
7070	–	if (!PyTuple_Check(args)) SWIG_fail;
7071	–	argc = PyObject_Length(args);
7072	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7073	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
7074	–	}
7075	–	if (argc == 2) {
7076	–	int _v;
7077	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7078	–	_v = SWIG_CheckState(res);
7079	–	if (_v) {
7080	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7081	–	_v = SWIG_CheckState(res);
7082	–	if (_v) {
7083	–	return _wrap_objectMap_find__SWIG_0(self, args);
7084	–	}
7085	–	}
7086	–	}
7087	–	if (argc == 2) {
7088	–	int _v;
7089	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7090	–	_v = SWIG_CheckState(res);
7091	–	if (_v) {
7092	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7093	–	_v = SWIG_CheckState(res);
7094	–	if (_v) {
7095	–	return _wrap_objectMap_find__SWIG_1(self, args);
7096	–	}
7097	–	}
7098	–	}
7099	–
7100	–	fail:
7101	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_find'");
7102	–	return NULL;
7103	–	}
7104	–
7105	–
7106	–	SWIGINTERN PyObject *_wrap_objectMap_lower_bound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7107	–	PyObject *resultobj = 0;
7108	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7109	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7110	–	std::map<std::string,std::string >::iterator result;
7111	–	void *argp1 = 0 ;
7112	–	int res1 = 0 ;
7113	–	int res2 = SWIG_OLDOBJ ;
7114	–	PyObject * obj0 = 0 ;
7115	–	PyObject * obj1 = 0 ;
7116	–
7117	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_lower_bound",&obj0,&obj1)) SWIG_fail;
7118	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7119	–	if (!SWIG_IsOK(res1)) {
7120	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_lower_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
7121	–	}
7122	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7123	–	{
7124	–	std::string *ptr = (std::string *)0;
7125	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7126	–	if (!SWIG_IsOK(res2)) {
7127	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7128	–	}
7129	–	if (!ptr) {
7130	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7131	–	}
7132	–	arg2 = ptr;
7133	–	}
7134	–	{
7135	–	try {
7136	–	result = (arg1)->lower_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7137	–	} catch (const std::exception& e) {
7138	–	SWIG_exception(SWIG_RuntimeError, e.what());
7139	–	}
7140	–	}
7141	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
7142	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7143	–	if (SWIG_IsNewObj(res2)) delete arg2;
7144	–	return resultobj;
7145	–	fail:
7146	–	if (SWIG_IsNewObj(res2)) delete arg2;
7147	–	return NULL;
7148	–	}
7149	–
7150	–
7151	–	SWIGINTERN PyObject *_wrap_objectMap_lower_bound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7152	–	PyObject *resultobj = 0;
7153	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7154	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7155	–	std::map<std::string,std::string >::const_iterator result;
7156	–	void *argp1 = 0 ;
7157	–	int res1 = 0 ;
7158	–	int res2 = SWIG_OLDOBJ ;
7159	–	PyObject * obj0 = 0 ;
7160	–	PyObject * obj1 = 0 ;
7161	–
7162	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_lower_bound",&obj0,&obj1)) SWIG_fail;
7163	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7164	–	if (!SWIG_IsOK(res1)) {
7165	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_lower_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
7166	–	}
7167	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7168	–	{
7169	–	std::string *ptr = (std::string *)0;
7170	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7171	–	if (!SWIG_IsOK(res2)) {
7172	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7173	–	}
7174	–	if (!ptr) {
7175	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_lower_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7176	–	}
7177	–	arg2 = ptr;
7178	–	}
7179	–	{
7180	–	try {
7181	–	result = ((std::map<std::string,std::string > const *)arg1)->lower_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7182	–	} catch (const std::exception& e) {
7183	–	SWIG_exception(SWIG_RuntimeError, e.what());
7184	–	}
7185	–	}
7186	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
7187	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7188	–	if (SWIG_IsNewObj(res2)) delete arg2;
7189	–	return resultobj;
7190	–	fail:
7191	–	if (SWIG_IsNewObj(res2)) delete arg2;
7192	–	return NULL;
7193	–	}
7194	–
7195	–
7196	–	SWIGINTERN PyObject *_wrap_objectMap_lower_bound(PyObject *self, PyObject *args) {
7197	–	int argc;
7198	–	PyObject *argv[3];
7199	–	int ii;
7200	–
7201	–	if (!PyTuple_Check(args)) SWIG_fail;
7202	–	argc = PyObject_Length(args);
7203	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7204	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
7205	–	}
7206	–	if (argc == 2) {
7207	–	int _v;
7208	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7209	–	_v = SWIG_CheckState(res);
7210	–	if (_v) {
7211	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7212	–	_v = SWIG_CheckState(res);
7213	–	if (_v) {
7214	–	return _wrap_objectMap_lower_bound__SWIG_0(self, args);
7215	–	}
7216	–	}
7217	–	}
7218	–	if (argc == 2) {
7219	–	int _v;
7220	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7221	–	_v = SWIG_CheckState(res);
7222	–	if (_v) {
7223	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7224	–	_v = SWIG_CheckState(res);
7225	–	if (_v) {
7226	–	return _wrap_objectMap_lower_bound__SWIG_1(self, args);
7227	–	}
7228	–	}
7229	–	}
7230	–
7231	–	fail:
7232	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_lower_bound'");
7233	–	return NULL;
7234	–	}
7235	–
7236	–
7237	–	SWIGINTERN PyObject *_wrap_objectMap_upper_bound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7238	–	PyObject *resultobj = 0;
7239	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7240	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7241	–	std::map<std::string,std::string >::iterator result;
7242	–	void *argp1 = 0 ;
7243	–	int res1 = 0 ;
7244	–	int res2 = SWIG_OLDOBJ ;
7245	–	PyObject * obj0 = 0 ;
7246	–	PyObject * obj1 = 0 ;
7247	–
7248	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_upper_bound",&obj0,&obj1)) SWIG_fail;
7249	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7250	–	if (!SWIG_IsOK(res1)) {
7251	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_upper_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
7252	–	}
7253	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7254	–	{
7255	–	std::string *ptr = (std::string *)0;
7256	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7257	–	if (!SWIG_IsOK(res2)) {
7258	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_upper_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7259	–	}
7260	–	if (!ptr) {
7261	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_upper_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7262	–	}
7263	–	arg2 = ptr;
7264	–	}
7265	–	{
7266	–	try {
7267	–	result = (arg1)->upper_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7268	–	} catch (const std::exception& e) {
7269	–	SWIG_exception(SWIG_RuntimeError, e.what());
7270	–	}
7271	–	}
7272	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::iterator & >(result)),
7273	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7274	–	if (SWIG_IsNewObj(res2)) delete arg2;
7275	–	return resultobj;
7276	–	fail:
7277	–	if (SWIG_IsNewObj(res2)) delete arg2;
7278	–	return NULL;
7279	–	}
7280	–
7281	–
7282	–	SWIGINTERN PyObject *_wrap_objectMap_upper_bound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7283	–	PyObject *resultobj = 0;
7284	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7285	–	std::map<std::string,std::string >::key_type *arg2 = 0 ;
7286	–	std::map<std::string,std::string >::const_iterator result;
7287	–	void *argp1 = 0 ;
7288	–	int res1 = 0 ;
7289	–	int res2 = SWIG_OLDOBJ ;
7290	–	PyObject * obj0 = 0 ;
7291	–	PyObject * obj1 = 0 ;
7292	–
7293	–	if (!PyArg_ParseTuple(args,(char *)"OO:objectMap_upper_bound",&obj0,&obj1)) SWIG_fail;
7294	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, 0 |  0 );
7295	–	if (!SWIG_IsOK(res1)) {
7296	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "objectMap_upper_bound" "', argument " "1"" of type '" "std::map<std::string,std::string > const *""'");
7297	–	}
7298	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7299	–	{
7300	–	std::string *ptr = (std::string *)0;
7301	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
7302	–	if (!SWIG_IsOK(res2)) {
7303	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "objectMap_upper_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7304	–	}
7305	–	if (!ptr) {
7306	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "objectMap_upper_bound" "', argument " "2"" of type '" "std::map<std::string,std::string >::key_type const &""'");
7307	–	}
7308	–	arg2 = ptr;
7309	–	}
7310	–	{
7311	–	try {
7312	–	result = ((std::map<std::string,std::string > const *)arg1)->upper_bound((std::map<std::string,std::string >::key_type const &)*arg2);
7313	–	} catch (const std::exception& e) {
7314	–	SWIG_exception(SWIG_RuntimeError, e.what());
7315	–	}
7316	–	}
7317	–	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map<std::string,std::string >::const_iterator & >(result)),
7318	–	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
7319	–	if (SWIG_IsNewObj(res2)) delete arg2;
7320	–	return resultobj;
7321	–	fail:
7322	–	if (SWIG_IsNewObj(res2)) delete arg2;
7323	–	return NULL;
7324	–	}
7325	–
7326	–
7327	–	SWIGINTERN PyObject *_wrap_objectMap_upper_bound(PyObject *self, PyObject *args) {
7328	–	int argc;
7329	–	PyObject *argv[3];
7330	–	int ii;
7331	–
7332	–	if (!PyTuple_Check(args)) SWIG_fail;
7333	–	argc = PyObject_Length(args);
7334	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
7335	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
7336	–	}
7337	–	if (argc == 2) {
7338	–	int _v;
7339	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7340	–	_v = SWIG_CheckState(res);
7341	–	if (_v) {
7342	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7343	–	_v = SWIG_CheckState(res);
7344	–	if (_v) {
7345	–	return _wrap_objectMap_upper_bound__SWIG_0(self, args);
7346	–	}
7347	–	}
7348	–	}
7349	–	if (argc == 2) {
7350	–	int _v;
7351	–	int res = swig::asptr(argv[0], (std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >**)(0));
7352	–	_v = SWIG_CheckState(res);
7353	–	if (_v) {
7354	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
7355	–	_v = SWIG_CheckState(res);
7356	–	if (_v) {
7357	–	return _wrap_objectMap_upper_bound__SWIG_1(self, args);
7358	–	}
7359	–	}
7360	–	}
7361	–
7362	–	fail:
7363	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'objectMap_upper_bound'");
7364	–	return NULL;
7365	–	}
7366	–
7367	–
7368	–	SWIGINTERN PyObject *_wrap_delete_objectMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7369	–	PyObject *resultobj = 0;
7370	–	std::map<std::string,std::string > *arg1 = (std::map<std::string,std::string > *) 0 ;
7371	–	void *argp1 = 0 ;
7372	–	int res1 = 0 ;
7373	–	PyObject * obj0 = 0 ;
7374	–
7375	–	if (!PyArg_ParseTuple(args,(char *)"O:delete_objectMap",&obj0)) SWIG_fail;
7376	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, SWIG_POINTER_DISOWN |  0 );
7377	–	if (!SWIG_IsOK(res1)) {
7378	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_objectMap" "', argument " "1"" of type '" "std::map<std::string,std::string > *""'");
7379	–	}
7380	–	arg1 = reinterpret_cast< std::map<std::string,std::string > * >(argp1);
7381	–	{
7382	–	try {
7383	–	delete arg1;
7384	–
7385	–	} catch (const std::exception& e) {
7386	–	SWIG_exception(SWIG_RuntimeError, e.what());
7387	–	}
7388	–	}
7389	–	resultobj = SWIG_Py_Void();
7390	–	return resultobj;
7391	–	fail:
7392	–	return NULL;
7393	–	}
7394	–
7395	–
7396	–	SWIGINTERN PyObject *objectMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7397	–	PyObject *obj;
7398	–	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
7399	–	SWIG_TypeNewClientData(SWIGTYPE_p_std__mapTstd__string_std__string_std__lessTstd__string_t_std__allocatorTstd__pairTstd__string_const_std__string_t_t_t, SWIG_NewClientData(obj));
7400	–	return SWIG_Py_Void();
7401	–	}
7402	–
7403	–	SWIGINTERN PyObject *_wrap_vector_string_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7404	–	PyObject *resultobj = 0;
7405	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7406	–	PyObject **arg2 = (PyObject **) 0 ;
7407	–	swig::PySwigIterator *result = 0 ;
7408	–	void *argp1 = 0 ;
7409	–	int res1 = 0 ;
7410	–	PyObject * obj0 = 0 ;
7411	–
7412	–	arg2 = &obj0;
7413	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_iterator",&obj0)) SWIG_fail;
7414	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7415	–	if (!SWIG_IsOK(res1)) {
7416	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_iterator" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7417	–	}
7418	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7419	–	{
7420	–	try {
7421	–	result = (swig::PySwigIterator *)std_vector_Sl_std_string_Sg__iterator(arg1,arg2);
7422	–	} catch (const std::exception& e) {
7423	–	SWIG_exception(SWIG_RuntimeError, e.what());
7424	–	}
7425	–	}
7426	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
7427	–	return resultobj;
7428	–	fail:
7429	–	return NULL;
7430	–	}
7431	–
7432	–
7433	–	SWIGINTERN PyObject *_wrap_vector_string___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7434	–	PyObject *resultobj = 0;
7435	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7436	–	bool result;
7437	–	void *argp1 = 0 ;
7438	–	int res1 = 0 ;
7439	–	PyObject * obj0 = 0 ;
7440	–
7441	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) SWIG_fail;
7442	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7443	–	if (!SWIG_IsOK(res1)) {
7444	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___nonzero__" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
7445	–	}
7446	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7447	–	{
7448	–	try {
7449	–	result = (bool)std_vector_Sl_std_string_Sg____nonzero__((std::vector<std::string > const *)arg1);
7450	–	} catch (const std::exception& e) {
7451	–	SWIG_exception(SWIG_RuntimeError, e.what());
7452	–	}
7453	–	}
7454	–	resultobj = SWIG_From_bool(static_cast< bool >(result));
7455	–	return resultobj;
7456	–	fail:
7457	–	return NULL;
7458	–	}
7459	–
7460	–
7461	–	SWIGINTERN PyObject *_wrap_vector_string___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7462	–	PyObject *resultobj = 0;
7463	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7464	–	std::vector<std::string >::size_type result;
7465	–	void *argp1 = 0 ;
7466	–	int res1 = 0 ;
7467	–	PyObject * obj0 = 0 ;
7468	–
7469	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) SWIG_fail;
7470	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7471	–	if (!SWIG_IsOK(res1)) {
7472	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___len__" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
7473	–	}
7474	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7475	–	{
7476	–	try {
7477	–	result = std_vector_Sl_std_string_Sg____len__((std::vector<std::string > const *)arg1);
7478	–	} catch (const std::exception& e) {
7479	–	SWIG_exception(SWIG_RuntimeError, e.what());
7480	–	}
7481	–	}
7482	–	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7483	–	return resultobj;
7484	–	fail:
7485	–	return NULL;
7486	–	}
7487	–
7488	–
7489	–	SWIGINTERN PyObject *_wrap_vector_string_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7490	–	PyObject *resultobj = 0;
7491	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7492	–	std::vector<std::string >::value_type result;
7493	–	void *argp1 = 0 ;
7494	–	int res1 = 0 ;
7495	–	PyObject * obj0 = 0 ;
7496	–
7497	–	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) SWIG_fail;
7498	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7499	–	if (!SWIG_IsOK(res1)) {
7500	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_pop" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7501	–	}
7502	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7503	–	{
7504	–	try {
7505	–	try {
7506	–	result = std_vector_Sl_std_string_Sg__pop(arg1);
7507	–	}
7508	–	catch(std::out_of_range &_e) {
7509	–	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7510	–	}
7511	–
7512	–	} catch (const std::exception& e) {
7513	–	SWIG_exception(SWIG_RuntimeError, e.what());
7514	–	}
7515	–	}
7516	–	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
7517	–	return resultobj;
7518	–	fail:
7519	–	return NULL;
7520	–	}
7521	–
7522	–
7523	–	SWIGINTERN PyObject *_wrap_vector_string___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7524	–	PyObject *resultobj = 0;
7525	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7526	–	std::vector<std::string >::difference_type arg2 ;
7527	–	std::vector<std::string >::difference_type arg3 ;
7528	–	std::vector<std::string,std::allocator<std::string > > *result = 0 ;
7529	–	void *argp1 = 0 ;
7530	–	int res1 = 0 ;
7531	–	ptrdiff_t val2 ;
7532	–	int ecode2 = 0 ;
7533	–	ptrdiff_t val3 ;
7534	–	int ecode3 = 0 ;
7535	–	PyObject * obj0 = 0 ;
7536	–	PyObject * obj1 = 0 ;
7537	–	PyObject * obj2 = 0 ;
7538	–
7539	–	if (!PyArg_ParseTuple(args,(char *)"OOO:vector_string___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7540	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7541	–	if (!SWIG_IsOK(res1)) {
7542	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___getslice__" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7543	–	}
7544	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7545	–	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7546	–	if (!SWIG_IsOK(ecode2)) {
7547	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string___getslice__" "', argument " "2"" of type '" "std::vector<std::string >::difference_type""'");
7548	–	}
7549	–	arg2 = static_cast< std::vector<std::string >::difference_type >(val2);
7550	–	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7551	–	if (!SWIG_IsOK(ecode3)) {
7552	–	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string___getslice__" "', argument " "3"" of type '" "std::vector<std::string >::difference_type""'");
7553	–	}
7554	–	arg3 = static_cast< std::vector<std::string >::difference_type >(val3);
7555	–	{
7556	–	try {
7557	–	try {
7558	–	result = (std::vector<std::string,std::allocator<std::string > > *)std_vector_Sl_std_string_Sg____getslice__(arg1,arg2,arg3);
7559	–	}
7560	–	catch(std::out_of_range &_e) {
7561	–	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7562	–	}
7563	–
7564	–	} catch (const std::exception& e) {
7565	–	SWIG_exception(SWIG_RuntimeError, e.what());
7566	–	}
7567	–	}
7568	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_OWN |  0 );
7569	–	return resultobj;
7570	–	fail:
7571	–	return NULL;
7572	–	}
7573	–
7574	–
7575	–	SWIGINTERN PyObject *_wrap_vector_string___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7576	–	PyObject *resultobj = 0;
7577	–	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
7578	–	std::vector<std::string >::difference_type arg2 ;
7579	–	std::vector<std::string >::difference_type arg3 ;
7580	–	std::vector<std::string,std::allocator<std::string > > *arg4 = 0 ;
7581	–	void *argp1 = 0 ;
7582	–	int res1 = 0 ;
7583	–	ptrdiff_t val2 ;
7584	–	int ecode2 = 0 ;
7585	–	ptrdiff_t val3 ;
7586	–	int ecode3 = 0 ;
7587	–	int res4 = SWIG_OLDOBJ ;
7588	–	PyObject * obj0 = 0 ;
7589	–	PyObject * obj1 = 0 ;
7590	–	PyObject * obj2 = 0 ;
7591	–	PyObject * obj3 = 0 ;
7592	–
7593	–	if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7594	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
7595	–	if (!SWIG_IsOK(res1)) {
7596	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string___setslice__" "', argument " "1"" of type '" "std::vector<std::string > *""'");
7597	–	}
7598	–	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
7599	–	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7600	–	if (!SWIG_IsOK(ecode2)) {
7601	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string___setslice__" "', argument " "2"" of type '" "std::vector<std::string >::difference_type""'");
7602	–	}
7603	–	arg2 = static_cast< std::vector<std::string >::difference_type >(val2);
7604	–	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7605	–	if (!SWIG_IsOK(ecode3)) {
7606	–	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string___setslice__" "', argument " "3"" of type '" "std::vector<std::string >::difference_type""'");
7607	–	}
7608	–	arg3 = static_cast< std::vector<std::string >::difference_type >(val3);
7609	–	{
7610	–	std::vector<std::string,std::allocator<std::string > > *ptr = (std::vector<std::string,std::allocator<std::string > > *)0;
7611	–	res4 = swig::asptr(obj3, &ptr);
7612	–	if (!SWIG_IsOK(res4)) {
7613	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_string___setslice__" "', argument " "4"" of type '" "std::vector<std::string,std::allocator<std::string > > const &""'");
7614	–	}
7615	–	if (!ptr) {
7616	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string___setslice__" "', argument " "4"" of type '" "std::vector<std::string,std::allocator<std::string > > const &""'");
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());
1743		}
1744	<	}
1745	<	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 {
1744	>	if (argc == 1) {
1745	>	int _v;
1746		{
1747	<	std::vector<std::string >::value_type const &_result_ref = std_vector_Sl_std_string_Sg____getitem__((std::vector<std::string > const *)arg1,arg2);
1748	<	result = (std::vector<std::string >::value_type *) &_result_ref;
1747	>	/* native sequence? */
1748	>	if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
1749	>	unsigned int size = (PyTuple_Check(argv[0]) ?
1750	>	PyTuple_Size(argv[0]) :
1751	>	PyList_Size(argv[0]));
1752	>	if (size == 0) {
1753	>	/* an empty sequence can be of any type */
1754	>	_v = 1;
1755	>	}else {
1756	>	/* check the first element only */
1757	>	PyObject* o = PySequence_GetItem(argv[0],0);
1758	>	if (PyString_Check(o))
1759	>	_v = 1;
1760	>	else
1761	>	_v = 0;
1762	>	Py_DECREF(o);
1763	>	}
1764	>	}else {
1765	>	/* wrapped vector? */
1766	>	std::vector<std::string >* v;
1767	>	if (SWIG_ConvertPtr(argv[0],(void **) &v,
1768	>	SWIGTYPE_p_std__vectorTstd__string_t,0) != -1)
1769	>	_v = 1;
1770	>	else
1771	>	_v = 0;
1772	>	}
1773	>	}
1774	>	if (_v) {
1775	>	return _wrap_new_vector_string__SWIG_2(self,args);
1776		}
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 &""'");
1777		}
1778	<	arg1 = ptr;
1779	<	}
1780	<	{
1781	<	try {
1782	<	result = (std::vector<std::string > *)new std::vector<std::string >((std::vector<std::string > const &)*arg1);
1783	<	} catch (const std::exception& e) {
1784	<	SWIG_exception(SWIG_RuntimeError, e.what());
1778	>	if (argc == 2) {
1779	>	int _v;
1780	>	{
1781	>	_v = (PyInt_Check(argv[0]) || PyLong_Check(argv[0])) ? 1 : 0;
1782	>	}
1783	>	if (_v) {
1784	>	{
1785	>	_v = PyString_Check(argv[1]) ? 1 : 0;
1786	>	}
1787	>	if (_v) {
1788	>	return _wrap_new_vector_string__SWIG_1(self,args);
1789	>	}
1790	>	}
1791		}
1792	<	}
1793	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
1794	<	if (SWIG_IsNewObj(res1)) delete arg1;
7932	<	return resultobj;
7933	<	fail:
7934	<	if (SWIG_IsNewObj(res1)) delete arg1;
7935	<	return NULL;
1792	>
1793	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_vector_string'");
1794	>	return NULL;
1795		}
1796
1797
1798	<	SWIGINTERN PyObject *_wrap_vector_string_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1799	<	PyObject *resultobj = 0;
1800	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1801	<	bool result;
1802	<	void *argp1 = 0 ;
1803	<	int res1 = 0 ;
1804	<	PyObject * obj0 = 0 ;
1805	<
1806	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_empty",&obj0)) SWIG_fail;
1807	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
1808	<	if (!SWIG_IsOK(res1)) {
1809	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_empty" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
1810	<	}
1811	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
1812	<	{
1813	<	try {
1814	<	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1815	<	} catch (const std::exception& e) {
1816	<	SWIG_exception(SWIG_RuntimeError, e.what());
1798	>	static PyObject *_wrap_vector_string___len__(PyObject *self, PyObject *args) {
1799	>	PyObject *resultobj;
1800	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1801	>	unsigned int result;
1802	>	std::vector<std::string > temp1 ;
1803	>	std::vector<std::string > *v1 ;
1804	>	PyObject * obj0 = 0 ;
1805	>
1806	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___len__",&obj0)) goto fail;
1807	>	{
1808	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1809	>	unsigned int size = (PyTuple_Check(obj0) ?
1810	>	PyTuple_Size(obj0) :
1811	>	PyList_Size(obj0));
1812	>	temp1 = std::vector<std::string >(size);
1813	>	arg1 = &temp1;
1814	>	for (unsigned int i=0; i<size; i++) {
1815	>	PyObject* o = PySequence_GetItem(obj0,i);
1816	>	if (PyString_Check(o)) {
1817	>	temp1[i] = (std::string)(\
1818	>	SwigString_AsString(o));
1819	>	Py_DECREF(o);
1820	>	}else {
1821	>	Py_DECREF(o);
1822	>	PyErr_SetString(PyExc_TypeError,
1823	>	"vector<""std::string""> expected");
1824	>	SWIG_fail;
1825	>	}
1826	>	}
1827	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1828	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1829	>	arg1 = v1;
1830	>	}else {
1831	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1832	>	SWIG_fail;
1833	>	}
1834		}
1835	<	}
1836	<	resultobj = SWIG_From_bool(static_cast< bool >(result));
1837	<	return resultobj;
1838	<	fail:
1839	<	return NULL;
1840	<	}
1841	<
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());
1835	>	{
1836	>	try {
1837	>	result = (unsigned int)((std::vector<std::string > const *)arg1)->size();
1838	>
1839	>	}catch (const std::exception& e) {
1840	>	SWIG_exception(SWIG_RuntimeError, e.what());
1841	>	}
1842		}
1843	<	}
1844	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
1845	<	return resultobj;
1846	<	fail:
7991	<	return NULL;
1843	>	resultobj = PyInt_FromLong((long)result);
1844	>	return resultobj;
1845	>	fail:
1846	>	return NULL;
1847		}
1848
1849
1850	<	SWIGINTERN PyObject *_wrap_vector_string_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1851	<	PyObject *resultobj = 0;
1852	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1853	<	void *argp1 = 0 ;
1854	<	int res1 = 0 ;
1855	<	PyObject * obj0 = 0 ;
1856	<
1857	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) SWIG_fail;
1858	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
1859	<	if (!SWIG_IsOK(res1)) {
1860	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_clear" "', argument " "1"" of type '" "std::vector<std::string > *""'");
1861	<	}
1862	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
1863	<	{
1864	<	try {
1865	<	(arg1)->clear();
1866	<	} catch (const std::exception& e) {
1867	<	SWIG_exception(SWIG_RuntimeError, e.what());
1850	>	static PyObject *_wrap_vector_string___nonzero__(PyObject *self, PyObject *args) {
1851	>	PyObject *resultobj;
1852	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1853	>	bool result;
1854	>	std::vector<std::string > temp1 ;
1855	>	std::vector<std::string > *v1 ;
1856	>	PyObject * obj0 = 0 ;
1857	>
1858	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string___nonzero__",&obj0)) goto fail;
1859	>	{
1860	>	if (PyTuple_Check(obj0) || PyList_Check(obj0)) {
1861	>	unsigned int size = (PyTuple_Check(obj0) ?
1862	>	PyTuple_Size(obj0) :
1863	>	PyList_Size(obj0));
1864	>	temp1 = std::vector<std::string >(size);
1865	>	arg1 = &temp1;
1866	>	for (unsigned int i=0; i<size; i++) {
1867	>	PyObject* o = PySequence_GetItem(obj0,i);
1868	>	if (PyString_Check(o)) {
1869	>	temp1[i] = (std::string)(\
1870	>	SwigString_AsString(o));
1871	>	Py_DECREF(o);
1872	>	}else {
1873	>	Py_DECREF(o);
1874	>	PyErr_SetString(PyExc_TypeError,
1875	>	"vector<""std::string""> expected");
1876	>	SWIG_fail;
1877	>	}
1878	>	}
1879	>	}else if (SWIG_ConvertPtr(obj0,(void **) &v1,
1880	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
1881	>	arg1 = v1;
1882	>	}else {
1883	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
1884	>	SWIG_fail;
1885	>	}
1886		}
1887	<	}
1888	<	resultobj = SWIG_Py_Void();
1889	<	return resultobj;
1890	<	fail:
1891	<	return NULL;
1892	<	}
1893	<
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());
1887	>	{
1888	>	try {
1889	>	result = (bool)((std::vector<std::string > const *)arg1)->empty();
1890	>
1891	>	}catch (const std::exception& e) {
1892	>	SWIG_exception(SWIG_RuntimeError, e.what());
1893	>	}
1894		}
1895	<	}
1896	<	resultobj = SWIG_Py_Void();
1897	<	return resultobj;
1898	<	fail:
8057	<	return NULL;
1895	>	resultobj = PyInt_FromLong((long)result);
1896	>	return resultobj;
1897	>	fail:
1898	>	return NULL;
1899		}
1900
1901
1902	<	SWIGINTERN PyObject *_wrap_vector_string_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1903	<	PyObject *resultobj = 0;
1904	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1905	<	SwigValueWrapper<std::allocator<std::string > > result;
1906	<	void *argp1 = 0 ;
1907	<	int res1 = 0 ;
1908	<	PyObject * obj0 = 0 ;
1909	<
1910	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_get_allocator",&obj0)) SWIG_fail;
1911	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
1912	<	if (!SWIG_IsOK(res1)) {
1913	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_get_allocator" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
1914	<	}
1915	<	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());
1902	>	static PyObject *_wrap_vector_string_clear(PyObject *self, PyObject *args) {
1903	>	PyObject *resultobj;
1904	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1905	>	PyObject * obj0 = 0 ;
1906	>
1907	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_clear",&obj0)) goto fail;
1908	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1909	>	{
1910	>	try {
1911	>	(arg1)->clear();
1912	>
1913	>	}catch (const std::exception& e) {
1914	>	SWIG_exception(SWIG_RuntimeError, e.what());
1915	>	}
1916		}
1917	<	}
1918	<	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 );
1919	<	return resultobj;
1920	<	fail:
8085	<	return NULL;
1917	>	Py_INCREF(Py_None); resultobj = Py_None;
1918	>	return resultobj;
1919	>	fail:
1920	>	return NULL;
1921		}
1922
1923
1924	<	SWIGINTERN PyObject *_wrap_vector_string_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1925	<	PyObject *resultobj = 0;
1926	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1927	<	std::vector<std::string >::iterator result;
1928	<	void *argp1 = 0 ;
1929	<	int res1 = 0 ;
1930	<	PyObject * obj0 = 0 ;
1931	<
1932	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_begin",&obj0)) SWIG_fail;
1933	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
1934	<	if (!SWIG_IsOK(res1)) {
1935	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_begin" "', argument " "1"" of type '" "std::vector<std::string > *""'");
1936	<	}
1937	<	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());
1924	>	static PyObject *_wrap_vector_string_append(PyObject *self, PyObject *args) {
1925	>	PyObject *resultobj;
1926	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1927	>	std::string arg2 ;
1928	>	PyObject * obj0 = 0 ;
1929	>	PyObject * obj1 = 0 ;
1930	>
1931	>	if(!PyArg_ParseTuple(args,(char *)"OO:vector_string_append",&obj0,&obj1)) goto fail;
1932	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1933	>	{
1934	>	if (PyString_Check(obj1))
1935	>	arg2 = std::string(PyString_AsString(obj1));
1936	>	else
1937	>	SWIG_exception(SWIG_TypeError, "string expected");
1938		}
1939	<	}
1940	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
1941	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1942	<	return resultobj;
1943	<	fail:
1944	<	return NULL;
1945	<	}
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());
1939	>	{
1940	>	try {
1941	>	(arg1)->push_back(arg2);
1942	>
1943	>	}catch (const std::exception& e) {
1944	>	SWIG_exception(SWIG_RuntimeError, e.what());
1945	>	}
1946		}
1947	<	}
1948	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::const_iterator & >(result)),
1949	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
1950	<	return resultobj;
8142	<	fail:
8143	<	return NULL;
1947	>	Py_INCREF(Py_None); resultobj = Py_None;
1948	>	return resultobj;
1949	>	fail:
1950	>	return NULL;
1951		}
1952
1953
1954	<	SWIGINTERN PyObject *_wrap_vector_string_begin(PyObject *self, PyObject *args) {
1955	<	int argc;
1956	<	PyObject *argv[2];
1957	<	int ii;
1958	<
1959	<	if (!PyTuple_Check(args)) SWIG_fail;
1960	<	argc = PyObject_Length(args);
1961	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
1962	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
1963	<	}
1964	<	if (argc == 1) {
1965	<	int _v;
1966	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
1967	<	_v = SWIG_CheckState(res);
1968	<	if (_v) {
8162	<	return _wrap_vector_string_begin__SWIG_0(self, args);
1954	>	static PyObject *_wrap_vector_string_pop(PyObject *self, PyObject *args) {
1955	>	PyObject *resultobj;
1956	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1957	>	std::string result;
1958	>	PyObject * obj0 = 0 ;
1959	>
1960	>	if(!PyArg_ParseTuple(args,(char *)"O:vector_string_pop",&obj0)) goto fail;
1961	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1962	>	{
1963	>	try {
1964	>	result = std_vectorlstd_string_g_pop___(arg1);
1965	>
1966	>	}catch (std::out_of_range& e) {
1967	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1968	>	}
1969		}
1970	<	}
1971	<	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);
1970	>	{
1971	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1972		}
1973	<	}
1974	<
1975	<	fail:
8175	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_begin'");
8176	<	return NULL;
1973	>	return resultobj;
1974	>	fail:
1975	>	return NULL;
1976		}
1977
1978
1979	<	SWIGINTERN PyObject *_wrap_vector_string_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
1980	<	PyObject *resultobj = 0;
1981	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1982	<	std::vector<std::string >::iterator result;
1983	<	void *argp1 = 0 ;
1984	<	int res1 = 0 ;
1985	<	PyObject * obj0 = 0 ;
1986	<
1987	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_end",&obj0)) SWIG_fail;
1988	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
1989	<	if (!SWIG_IsOK(res1)) {
1990	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_end" "', argument " "1"" of type '" "std::vector<std::string > *""'");
1991	<	}
1992	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
1993	<	{
1994	<	try {
8196	<	result = (arg1)->end();
8197	<	} catch (const std::exception& e) {
8198	<	SWIG_exception(SWIG_RuntimeError, e.what());
1979	>	static PyObject *_wrap_vector_string___getitem__(PyObject *self, PyObject *args) {
1980	>	PyObject *resultobj;
1981	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
1982	>	int arg2 ;
1983	>	std::string result;
1984	>	PyObject * obj0 = 0 ;
1985	>
1986	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___getitem__",&obj0,&arg2)) goto fail;
1987	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
1988	>	{
1989	>	try {
1990	>	result = std_vectorlstd_string_g___getitem_____(arg1,arg2);
1991	>
1992	>	}catch (std::out_of_range& e) {
1993	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
1994	>	}
1995		}
1996	<	}
1997	<	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());
1996	>	{
1997	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
1998		}
1999	<	}
2000	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::const_iterator & >(result)),
2001	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
8232	<	return resultobj;
8233	<	fail:
8234	<	return NULL;
1999	>	return resultobj;
2000	>	fail:
2001	>	return NULL;
2002		}
2003
2004
2005	<	SWIGINTERN PyObject *_wrap_vector_string_end(PyObject *self, PyObject *args) {
2006	<	int argc;
2007	<	PyObject *argv[2];
2008	<	int ii;
2009	<
2010	<	if (!PyTuple_Check(args)) SWIG_fail;
2011	<	argc = PyObject_Length(args);
2012	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2013	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2014	<	}
2015	<	if (argc == 1) {
2016	<	int _v;
2017	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2018	<	_v = SWIG_CheckState(res);
2019	<	if (_v) {
2020	<	return _wrap_vector_string_end__SWIG_0(self, args);
2005	>	static PyObject *_wrap_vector_string___getslice__(PyObject *self, PyObject *args) {
2006	>	PyObject *resultobj;
2007	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2008	>	int arg2 ;
2009	>	int arg3 ;
2010	>	std::vector<std::string > result;
2011	>	PyObject * obj0 = 0 ;
2012	>
2013	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___getslice__",&obj0,&arg2,&arg3)) goto fail;
2014	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2015	>	{
2016	>	try {
2017	>	result = std_vectorlstd_string_g___getslice_____(arg1,arg2,arg3);
2018	>
2019	>	}catch (const std::exception& e) {
2020	>	SWIG_exception(SWIG_RuntimeError, e.what());
2021	>	}
2022		}
2023	<	}
2024	<	if (argc == 1) {
2025	<	int _v;
2026	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2027	<	_v = SWIG_CheckState(res);
8260	<	if (_v) {
8261	<	return _wrap_vector_string_end__SWIG_1(self, args);
2023	>	{
2024	>	resultobj = PyTuple_New((&result)->size());
2025	>	for (unsigned int i=0; i<(&result)->size(); i++)
2026	>	PyTuple_SetItem(resultobj,i,
2027	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2028		}
2029	<	}
2030	<
2031	<	fail:
8266	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_end'");
8267	<	return NULL;
2029	>	return resultobj;
2030	>	fail:
2031	>	return NULL;
2032		}
2033
2034
2035	<	SWIGINTERN PyObject *_wrap_vector_string_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2036	<	PyObject *resultobj = 0;
2037	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2038	<	std::vector<std::string >::reverse_iterator result;
2039	<	void *argp1 = 0 ;
2040	<	int res1 = 0 ;
2041	<	PyObject * obj0 = 0 ;
2042	<
2043	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_rbegin",&obj0)) SWIG_fail;
2044	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2045	<	if (!SWIG_IsOK(res1)) {
2046	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_rbegin" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2047	<	}
2048	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2049	<	{
8286	<	try {
8287	<	result = (arg1)->rbegin();
8288	<	} catch (const std::exception& e) {
8289	<	SWIG_exception(SWIG_RuntimeError, e.what());
2035	>	static PyObject *_wrap_vector_string___setitem__(PyObject *self, PyObject *args) {
2036	>	PyObject *resultobj;
2037	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2038	>	int arg2 ;
2039	>	std::string arg3 ;
2040	>	PyObject * obj0 = 0 ;
2041	>	PyObject * obj2 = 0 ;
2042	>
2043	>	if(!PyArg_ParseTuple(args,(char *)"OiO:vector_string___setitem__",&obj0,&arg2,&obj2)) goto fail;
2044	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2045	>	{
2046	>	if (PyString_Check(obj2))
2047	>	arg3 = std::string(PyString_AsString(obj2));
2048	>	else
2049	>	SWIG_exception(SWIG_TypeError, "string expected");
2050		}
2051	<	}
2052	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::reverse_iterator & >(result)),
2053	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
2054	<	return resultobj;
2055	<	fail:
2056	<	return NULL;
2057	<	}
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());
2051	>	{
2052	>	try {
2053	>	std_vectorlstd_string_g___setitem_____(arg1,arg2,arg3);
2054	>
2055	>	}catch (std::out_of_range& e) {
2056	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2057	>	}
2058		}
2059	<	}
2060	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::const_reverse_iterator & >(result)),
2061	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
2062	<	return resultobj;
8324	<	fail:
8325	<	return NULL;
2059	>	Py_INCREF(Py_None); resultobj = Py_None;
2060	>	return resultobj;
2061	>	fail:
2062	>	return NULL;
2063		}
2064
2065
2066	<	SWIGINTERN PyObject *_wrap_vector_string_rbegin(PyObject *self, PyObject *args) {
2067	<	int argc;
2068	<	PyObject *argv[2];
2069	<	int ii;
2070	<
2071	<	if (!PyTuple_Check(args)) SWIG_fail;
2072	<	argc = PyObject_Length(args);
2073	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2074	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2075	<	}
2076	<	if (argc == 1) {
2077	<	int _v;
2078	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2079	<	_v = SWIG_CheckState(res);
2080	<	if (_v) {
2081	<	return _wrap_vector_string_rbegin__SWIG_0(self, args);
2082	<	}
2083	<	}
2084	<	if (argc == 1) {
2085	<	int _v;
2086	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2087	<	_v = SWIG_CheckState(res);
2088	<	if (_v) {
2089	<	return _wrap_vector_string_rbegin__SWIG_1(self, args);
2066	>	static PyObject *_wrap_vector_string___setslice__(PyObject *self, PyObject *args) {
2067	>	PyObject *resultobj;
2068	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2069	>	int arg2 ;
2070	>	int arg3 ;
2071	>	std::vector<std::string > *arg4 = 0 ;
2072	>	std::vector<std::string > temp4 ;
2073	>	std::vector<std::string > *v4 ;
2074	>	PyObject * obj0 = 0 ;
2075	>	PyObject * obj3 = 0 ;
2076	>
2077	>	if(!PyArg_ParseTuple(args,(char *)"OiiO:vector_string___setslice__",&obj0,&arg2,&arg3,&obj3)) goto fail;
2078	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2079	>	{
2080	>	if (PyTuple_Check(obj3) || PyList_Check(obj3)) {
2081	>	unsigned int size = (PyTuple_Check(obj3) ?
2082	>	PyTuple_Size(obj3) :
2083	>	PyList_Size(obj3));
2084	>	temp4 = std::vector<std::string >(size);
2085	>	arg4 = &temp4;
2086	>	for (unsigned int i=0; i<size; i++) {
2087	>	PyObject* o = PySequence_GetItem(obj3,i);
2088	>	if (PyString_Check(o)) {
2089	>	temp4[i] = (std::string)(\
2090	>	SwigString_AsString(o));
2091	>	Py_DECREF(o);
2092	>	}else {
2093	>	Py_DECREF(o);
2094	>	PyErr_SetString(PyExc_TypeError,
2095	>	"vector<""std::string""> expected");
2096	>	SWIG_fail;
2097	>	}
2098	>	}
2099	>	}else if (SWIG_ConvertPtr(obj3,(void **) &v4,
2100	>	SWIGTYPE_p_std__vectorTstd__string_t,1) != -1){
2101	>	arg4 = v4;
2102	>	}else {
2103	>	PyErr_SetString(PyExc_TypeError,"vector<""std::string" "> expected");
2104	>	SWIG_fail;
2105	>	}
2106		}
2107	<	}
2108	<
2109	<	fail:
2110	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_rbegin'");
2111	<	return NULL;
2112	<	}
2113	<
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());
2107	>	{
2108	>	try {
2109	>	std_vectorlstd_string_g___setslice_____(arg1,arg2,arg3,(std::vector<std::string > const &)*arg4);
2110	>
2111	>	}catch (const std::exception& e) {
2112	>	SWIG_exception(SWIG_RuntimeError, e.what());
2113	>	}
2114		}
2115	<	}
2116	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::reverse_iterator & >(result)),
2117	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
2118	<	return resultobj;
8386	<	fail:
8387	<	return NULL;
2115	>	Py_INCREF(Py_None); resultobj = Py_None;
2116	>	return resultobj;
2117	>	fail:
2118	>	return NULL;
2119		}
2120
2121
2122	<	SWIGINTERN PyObject *_wrap_vector_string_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2123	<	PyObject *resultobj = 0;
2124	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2125	<	std::vector<std::string >::const_reverse_iterator result;
2126	<	void *argp1 = 0 ;
2127	<	int res1 = 0 ;
2128	<	PyObject * obj0 = 0 ;
2129	<
2130	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_rend",&obj0)) SWIG_fail;
2131	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2132	<	if (!SWIG_IsOK(res1)) {
2133	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_rend" "', argument " "1"" of type '" "std::vector<std::string > const *""'");
2134	<	}
2135	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2136	<	{
8406	<	try {
8407	<	result = ((std::vector<std::string > const *)arg1)->rend();
8408	<	} catch (const std::exception& e) {
8409	<	SWIG_exception(SWIG_RuntimeError, e.what());
2122	>	static PyObject *_wrap_vector_string___delitem__(PyObject *self, PyObject *args) {
2123	>	PyObject *resultobj;
2124	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2125	>	int arg2 ;
2126	>	PyObject * obj0 = 0 ;
2127	>
2128	>	if(!PyArg_ParseTuple(args,(char *)"Oi:vector_string___delitem__",&obj0,&arg2)) goto fail;
2129	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2130	>	{
2131	>	try {
2132	>	std_vectorlstd_string_g___delitem_____(arg1,arg2);
2133	>
2134	>	}catch (std::out_of_range& e) {
2135	>	SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
2136	>	}
2137		}
2138	<	}
2139	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::const_reverse_iterator & >(result)),
2140	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
2141	<	return resultobj;
8415	<	fail:
8416	<	return NULL;
2138	>	Py_INCREF(Py_None); resultobj = Py_None;
2139	>	return resultobj;
2140	>	fail:
2141	>	return NULL;
2142		}
2143
2144
2145	<	SWIGINTERN PyObject *_wrap_vector_string_rend(PyObject *self, PyObject *args) {
2146	<	int argc;
2147	<	PyObject *argv[2];
2148	<	int ii;
2149	<
2150	<	if (!PyTuple_Check(args)) SWIG_fail;
2151	<	argc = PyObject_Length(args);
2152	<	for (ii = 0; (ii < argc) && (ii < 1); ii++) {
2153	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2154	<	}
2155	<	if (argc == 1) {
2156	<	int _v;
2157	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2158	<	_v = SWIG_CheckState(res);
2159	<	if (_v) {
2160	<	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);
2145	>	static PyObject *_wrap_vector_string___delslice__(PyObject *self, PyObject *args) {
2146	>	PyObject *resultobj;
2147	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2148	>	int arg2 ;
2149	>	int arg3 ;
2150	>	PyObject * obj0 = 0 ;
2151	>
2152	>	if(!PyArg_ParseTuple(args,(char *)"Oii:vector_string___delslice__",&obj0,&arg2,&arg3)) goto fail;
2153	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2154	>	{
2155	>	try {
2156	>	std_vectorlstd_string_g___delslice_____(arg1,arg2,arg3);
2157	>
2158	>	}catch (const std::exception& e) {
2159	>	SWIG_exception(SWIG_RuntimeError, e.what());
2160	>	}
2161		}
2162	<	}
2163	<
2164	<	fail:
2165	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_rend'");
8449	<	return NULL;
2162	>	Py_INCREF(Py_None); resultobj = Py_None;
2163	>	return resultobj;
2164	>	fail:
2165	>	return NULL;
2166		}
2167
2168
2169	<	SWIGINTERN PyObject *_wrap_new_vector_string__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2170	<	PyObject *resultobj = 0;
2171	<	std::vector<std::string >::size_type arg1 ;
2172	<	std::vector<std::string > *result = 0 ;
2173	<	size_t val1 ;
2174	<	int ecode1 = 0 ;
2175	<	PyObject * obj0 = 0 ;
2176	<
2177	<	if (!PyArg_ParseTuple(args,(char *)"O:new_vector_string",&obj0)) SWIG_fail;
2178	<	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
2179	<	if (!SWIG_IsOK(ecode1)) {
2180	<	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vector_string" "', argument " "1"" of type '" "std::vector<std::string >::size_type""'");
2181	<	}
2182	<	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());
2169	>	static PyObject *_wrap_delete_vector_string(PyObject *self, PyObject *args) {
2170	>	PyObject *resultobj;
2171	>	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2172	>	PyObject * obj0 = 0 ;
2173	>
2174	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_vector_string",&obj0)) goto fail;
2175	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2176	>	{
2177	>	try {
2178	>	delete arg1;
2179	>
2180	>	}catch (const std::exception& e) {
2181	>	SWIG_exception(SWIG_RuntimeError, e.what());
2182	>	}
2183		}
2184	<	}
2185	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
2186	<	return resultobj;
2187	<	fail:
8477	<	return NULL;
2184	>	Py_INCREF(Py_None); resultobj = Py_None;
2185	>	return resultobj;
2186	>	fail:
2187	>	return NULL;
2188		}
2189
2190
2191	<	SWIGINTERN PyObject *_wrap_vector_string_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2192	<	PyObject *resultobj = 0;
2193	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2194	<	void *argp1 = 0 ;
2195	<	int res1 = 0 ;
2196	<	PyObject * obj0 = 0 ;
2197	<
2198	<	if (!PyArg_ParseTuple(args,(char *)"O:vector_string_pop_back",&obj0)) SWIG_fail;
2199	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2200	<	if (!SWIG_IsOK(res1)) {
2201	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_pop_back" "', argument " "1"" of type '" "std::vector<std::string > *""'");
2202	<	}
2203	<	arg1 = reinterpret_cast< std::vector<std::string > * >(argp1);
2204	<	{
2205	<	try {
2206	<	(arg1)->pop_back();
2207	<	} catch (const std::exception& e) {
2208	<	SWIG_exception(SWIG_RuntimeError, e.what());
2191	>	static PyObject * vector_string_swigregister(PyObject *self, PyObject *args) {
2192	>	PyObject *obj;
2193	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2194	>	SWIG_TypeClientData(SWIGTYPE_p_std__vectorTstd__string_t, obj);
2195	>	Py_INCREF(obj);
2196	>	return Py_BuildValue((char *)"");
2197	>	}
2198	>	static PyObject *_wrap_BossSession_show(PyObject *self, PyObject *args) {
2199	>	PyObject *resultobj;
2200	>	BossSession *arg1 = (BossSession *) 0 ;
2201	>	std::vector<std::string > *arg2 = 0 ;
2202	>	PyObject *result;
2203	>	PyObject * obj0 = 0 ;
2204	>	PyObject * obj1 = 0 ;
2205	>
2206	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_show",&obj0,&obj1)) goto fail;
2207	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2208	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2209	>	if (arg2 == NULL) {
2210	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
2211		}
2212	<	}
2213	<	resultobj = SWIG_Py_Void();
2214	<	return resultobj;
2215	<	fail:
2216	<	return NULL;
2217	<	}
2218	<
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());
2212	>	{
2213	>	try {
2214	>	result = (PyObject *)BossSession_show(arg1,*arg2);
2215	>
2216	>	}catch (const std::exception& e) {
2217	>	SWIG_exception(SWIG_RuntimeError, e.what());
2218	>	}
2219		}
2220	<	}
2221	<	resultobj = SWIG_Py_Void();
2222	<	return resultobj;
2223	<	fail:
8540	<	return NULL;
2220	>	resultobj = result;
2221	>	return resultobj;
2222	>	fail:
2223	>	return NULL;
2224		}
2225
2226
2227	<	SWIGINTERN PyObject *_wrap_vector_string_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2228	<	PyObject *resultobj = 0;
2229	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2230	<	std::vector<std::string >::iterator arg2 ;
2231	<	std::vector<std::string >::iterator result;
2232	<	void *argp1 = 0 ;
2233	<	int res1 = 0 ;
2234	<	swig::PySwigIterator *iter2 = 0 ;
2235	<	int res2 ;
2236	<	PyObject * obj0 = 0 ;
2237	<	PyObject * obj1 = 0 ;
2238	<
2239	<	if (!PyArg_ParseTuple(args,(char *)"OO:vector_string_erase",&obj0,&obj1)) SWIG_fail;
2240	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, 0 |  0 );
2241	<	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());
2227	>	static PyObject *_wrap_BossSession_CHTools(PyObject *self, PyObject *args) {
2228	>	PyObject *resultobj;
2229	>	BossSession *arg1 = (BossSession *) 0 ;
2230	>	PyObject *result;
2231	>	PyObject * obj0 = 0 ;
2232	>
2233	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_CHTools",&obj0)) goto fail;
2234	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2235	>	{
2236	>	try {
2237	>	result = (PyObject *)BossSession_CHTools(arg1);
2238	>
2239	>	}catch (const std::exception& e) {
2240	>	SWIG_exception(SWIG_RuntimeError, e.what());
2241	>	}
2242		}
2243	<	}
2244	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
2245	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
2246	<	return resultobj;
8583	<	fail:
8584	<	return NULL;
2243	>	resultobj = result;
2244	>	return resultobj;
2245	>	fail:
2246	>	return NULL;
2247		}
2248
2249
2250	<	SWIGINTERN PyObject *_wrap_vector_string_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2251	<	PyObject *resultobj = 0;
2252	<	std::vector<std::string > *arg1 = (std::vector<std::string > *) 0 ;
2253	<	std::vector<std::string >::iterator arg2 ;
2254	<	std::vector<std::string >::iterator arg3 ;
2255	<	std::vector<std::string >::iterator result;
2256	<	void *argp1 = 0 ;
2257	<	int res1 = 0 ;
2258	<	swig::PySwigIterator *iter2 = 0 ;
2259	<	int res2 ;
2260	<	swig::PySwigIterator *iter3 = 0 ;
2261	<	int res3 ;
2262	<	PyObject * obj0 = 0 ;
2263	<	PyObject * obj1 = 0 ;
2264	<	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());
2250	>	static PyObject *_wrap_BossSession_ProgramTypes(PyObject *self, PyObject *args) {
2251	>	PyObject *resultobj;
2252	>	BossSession *arg1 = (BossSession *) 0 ;
2253	>	PyObject *result;
2254	>	PyObject * obj0 = 0 ;
2255	>
2256	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_ProgramTypes",&obj0)) goto fail;
2257	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2258	>	{
2259	>	try {
2260	>	result = (PyObject *)BossSession_ProgramTypes(arg1);
2261	>
2262	>	}catch (const std::exception& e) {
2263	>	SWIG_exception(SWIG_RuntimeError, e.what());
2264	>	}
2265		}
2266	<	}
2267	<	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<std::string >::iterator & >(result)),
2268	<	swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
2269	<	return resultobj;
8642	<	fail:
8643	<	return NULL;
2266	>	resultobj = result;
2267	>	return resultobj;
2268	>	fail:
2269	>	return NULL;
2270		}
2271
2272
2273	<	SWIGINTERN PyObject *_wrap_vector_string_erase(PyObject *self, PyObject *args) {
2274	<	int argc;
2275	<	PyObject *argv[4];
2276	<	int ii;
2277	<
2278	<	if (!PyTuple_Check(args)) SWIG_fail;
2279	<	argc = PyObject_Length(args);
2280	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
2281	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2282	<	}
2283	<	if (argc == 2) {
2284	<	int _v;
2285	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2286	<	_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_vector_string_erase__SWIG_1(self, args);
2273	>	static PyObject *_wrap_BossSession_RTMons(PyObject *self, PyObject *args) {
2274	>	PyObject *resultobj;
2275	>	BossSession *arg1 = (BossSession *) 0 ;
2276	>	PyObject *result;
2277	>	PyObject * obj0 = 0 ;
2278	>
2279	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_RTMons",&obj0)) goto fail;
2280	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2281	>	{
2282	>	try {
2283	>	result = (PyObject *)BossSession_RTMons(arg1);
2284	>
2285	>	}catch (const std::exception& e) {
2286	>	SWIG_exception(SWIG_RuntimeError, e.what());
2287		}
8685	–	}
2288		}
2289	<	}
2290	<
2291	<	fail:
2292	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_erase'");
8691	<	return NULL;
2289	>	resultobj = result;
2290	>	return resultobj;
2291	>	fail:
2292	>	return NULL;
2293		}
2294
2295
2296	<	SWIGINTERN PyObject *_wrap_new_vector_string__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2297	<	PyObject *resultobj = 0;
2298	<	std::vector<std::string >::size_type arg1 ;
2299	<	std::vector<std::string >::value_type *arg2 = 0 ;
2300	<	std::vector<std::string > *result = 0 ;
2301	<	size_t val1 ;
2302	<	int ecode1 = 0 ;
2303	<	int res2 = SWIG_OLDOBJ ;
2304	<	PyObject * obj0 = 0 ;
2305	<	PyObject * obj1 = 0 ;
2306	<
2307	<	if (!PyArg_ParseTuple(args,(char *)"OO:new_vector_string",&obj0,&obj1)) SWIG_fail;
2308	<	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
2309	<	if (!SWIG_IsOK(ecode1)) {
2310	<	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());
2296	>	static PyObject *_wrap_BossSession_schedulers(PyObject *self, PyObject *args) {
2297	>	PyObject *resultobj;
2298	>	BossSession *arg1 = (BossSession *) 0 ;
2299	>	PyObject *result;
2300	>	PyObject * obj0 = 0 ;
2301	>
2302	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_schedulers",&obj0)) goto fail;
2303	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2304	>	{
2305	>	try {
2306	>	result = (PyObject *)BossSession_schedulers(arg1);
2307	>
2308	>	}catch (const std::exception& e) {
2309	>	SWIG_exception(SWIG_RuntimeError, e.what());
2310	>	}
2311		}
2312	<	}
2313	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__string_std__allocatorTstd__string_t_t, SWIG_POINTER_NEW |  0 );
2314	<	if (SWIG_IsNewObj(res2)) delete arg2;
2315	<	return resultobj;
8733	<	fail:
8734	<	if (SWIG_IsNewObj(res2)) delete arg2;
8735	<	return NULL;
2312	>	resultobj = result;
2313	>	return resultobj;
2314	>	fail:
2315	>	return NULL;
2316		}
2317
2318
2319	<	SWIGINTERN PyObject *_wrap_new_vector_string(PyObject *self, PyObject *args) {
2320	<	int argc;
2321	<	PyObject *argv[3];
2322	<	int ii;
2323	<
2324	<	if (!PyTuple_Check(args)) SWIG_fail;
2325	<	argc = PyObject_Length(args);
2326	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
2327	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2328	<	}
2329	<	if (argc == 0) {
2330	<	return _wrap_new_vector_string__SWIG_0(self, args);
2331	<	}
2332	<	if (argc == 1) {
2333	<	int _v;
2319	>	static PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
2320	>	PyObject *resultobj;
2321	>	BossSession *arg1 = (BossSession *) 0 ;
2322	>	std::string *arg2 = 0 ;
2323	>	std::string *arg3 = 0 ;
2324	>	std::string const &arg4_defvalue = "" ;
2325	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
2326	>	std::string const &arg5_defvalue = "" ;
2327	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2328	>	bool arg6 = (bool) false ;
2329	>	PyObject *result;
2330	>	std::string temp2 ;
2331	>	std::string temp3 ;
2332	>	std::string temp4 ;
2333	>	std::string temp5 ;
2334	>	PyObject * obj0 = 0 ;
2335	>	PyObject * obj1 = 0 ;
2336	>	PyObject * obj2 = 0 ;
2337	>	PyObject * obj3 = 0 ;
2338	>	PyObject * obj4 = 0 ;
2339	>	PyObject * obj5 = 0 ;
2340	>
2341	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2342	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2343		{
2344	<	int res = SWIG_AsVal_size_t(argv[0], NULL);
2345	<	_v = SWIG_CheckState(res);
2346	<	}
2347	<	if (_v) {
2348	<	return _wrap_new_vector_string__SWIG_2(self, args);
2349	<	}
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);
2344	>	if (PyString_Check(obj1)) {
2345	>	temp2 = std::string(PyString_AsString(obj1));
2346	>	arg2 = &temp2;
2347	>	}else {
2348	>	SWIG_exception(SWIG_TypeError, "string expected");
2349	>	}
2350		}
8769	–	}
8770	–	if (argc == 2) {
8771	–	int _v;
2351		{
2352	<	int res = SWIG_AsVal_size_t(argv[0], NULL);
2353	<	_v = SWIG_CheckState(res);
2354	<	}
2355	<	if (_v) {
2356	<	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	<	}
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 (!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	<	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	<	}
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	<	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	<	}
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	<	return _wrap_vector_string_resize__SWIG_1(self, args);
2352	>	if (PyString_Check(obj2)) {
2353	>	temp3 = std::string(PyString_AsString(obj2));
2354	>	arg3 = &temp3;
2355	>	}else {
2356	>	SWIG_exception(SWIG_TypeError, "string expected");
2357		}
9039	–	}
2358		}
2359	<	}
2360	<
2361	<	fail:
2362	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'vector_string_resize'");
2363	<	return NULL;
2364	<	}
2365	<
2366	<
2367	<	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	<	}
9081	<	{
9082	<	std::string *ptr = (std::string *)0;
9083	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
9084	<	if (!SWIG_IsOK(res3)) {
9085	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_string_insert" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
9086	<	}
9087	<	if (!ptr) {
9088	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_insert" "', argument " "3"" of type '" "std::vector<std::string >::value_type const &""'");
9089	<	}
9090	<	arg3 = ptr;
9091	<	}
9092	<	{
9093	<	try {
9094	<	result = (arg1)->insert(arg2,(std::vector<std::string >::value_type const &)*arg3);
9095	<	} catch (const std::exception& e) {
9096	<	SWIG_exception(SWIG_RuntimeError, e.what());
9097	<	}
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""'");
2359	>	if (obj3) {
2360	>	{
2361	>	if (PyString_Check(obj3)) {
2362	>	temp4 = std::string(PyString_AsString(obj3));
2363	>	arg4 = &temp4;
2364	>	}else {
2365	>	SWIG_exception(SWIG_TypeError, "string expected");
2366	>	}
2367	>	}
2368		}
2369	<	}
2370	<	ecode3 = SWIG_AsVal_size_t(obj2, &val3);
2371	<	if (!SWIG_IsOK(ecode3)) {
2372	<	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string_insert" "', argument " "3"" of type '" "std::vector<std::string >::size_type""'");
2373	<	}
2374	<	arg3 = static_cast< std::vector<std::string >::size_type >(val3);
2375	<	{
2376	<	std::string *ptr = (std::string *)0;
2377	<	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 &""'");
2369	>	if (obj4) {
2370	>	{
2371	>	if (PyString_Check(obj4)) {
2372	>	temp5 = std::string(PyString_AsString(obj4));
2373	>	arg5 = &temp5;
2374	>	}else {
2375	>	SWIG_exception(SWIG_TypeError, "string expected");
2376	>	}
2377	>	}
2378		}
2379	<	if (!ptr) {
2380	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_insert" "', argument " "4"" of type '" "std::vector<std::string >::value_type const &""'");
2379	>	if (obj5) {
2380	>	arg6 = PyInt_AsLong(obj5) ? true : false;
2381	>	if (PyErr_Occurred()) SWIG_fail;
2382		}
2383	<	arg4 = ptr;
2384	<	}
2385	<	{
2386	<	try {
2387	<	(arg1)->insert(arg2,arg3,(std::vector<std::string >::value_type const &)*arg4);
2388	<	} catch (const std::exception& e) {
2389	<	SWIG_exception(SWIG_RuntimeError, e.what());
2383	>	{
2384	>	try {
2385	>	result = (PyObject *)BossSession_schedListMatch(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
2386	>
2387	>	}catch (const std::exception& e) {
2388	>	SWIG_exception(SWIG_RuntimeError, e.what());
2389	>	}
2390		}
2391	<	}
2392	<	resultobj = SWIG_Py_Void();
2393	<	if (SWIG_IsNewObj(res4)) delete arg4;
2394	<	return resultobj;
9170	<	fail:
9171	<	if (SWIG_IsNewObj(res4)) delete arg4;
9172	<	return NULL;
2391	>	resultobj = result;
2392	>	return resultobj;
2393	>	fail:
2394	>	return NULL;
2395		}
2396
2397
2398	<	SWIGINTERN PyObject *_wrap_vector_string_insert(PyObject *self, PyObject *args) {
2399	<	int argc;
2400	<	PyObject *argv[5];
2401	<	int ii;
2402	<
2403	<	if (!PyTuple_Check(args)) SWIG_fail;
2404	<	argc = PyObject_Length(args);
2405	<	for (ii = 0; (ii < argc) && (ii < 4); ii++) {
2406	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2407	<	}
2408	<	if (argc == 3) {
2409	<	int _v;
2410	<	int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator<std::string > >**)(0));
2411	<	_v = SWIG_CheckState(res);
2412	<	if (_v) {
2413	<	swig::PySwigIterator *iter = 0;
2414	<	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
2415	<	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<std::string >::iterator > *>(iter) != 0));
2416	<	if (_v) {
2417	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
2418	<	_v = SWIG_CheckState(res);
2419	<	if (_v) {
2420	<	return _wrap_vector_string_insert__SWIG_0(self, args);
2398	>	static PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
2399	>	PyObject *resultobj;
2400	>	BossSession *arg1 = (BossSession *) 0 ;
2401	>	int arg2 = (int) SCHEDULED ;
2402	>	std::string const &arg3_defvalue = "all" ;
2403	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
2404	>	std::string const &arg4_defvalue = "all" ;
2405	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
2406	>	std::string const &arg5_defvalue = "" ;
2407	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2408	>	std::string arg6 = (std::string) "" ;
2409	>	std::string arg7 = (std::string) "" ;
2410	>	std::string arg8 = (std::string) "" ;
2411	>	std::string arg9 = (std::string) "" ;
2412	>	bool arg10 = (bool) false ;
2413	>	PyObject *result;
2414	>	std::string temp3 ;
2415	>	std::string temp4 ;
2416	>	std::string temp5 ;
2417	>	PyObject * obj0 = 0 ;
2418	>	PyObject * obj2 = 0 ;
2419	>	PyObject * obj3 = 0 ;
2420	>	PyObject * obj4 = 0 ;
2421	>	PyObject * obj5 = 0 ;
2422	>	PyObject * obj6 = 0 ;
2423	>	PyObject * obj7 = 0 ;
2424	>	PyObject * obj8 = 0 ;
2425	>	PyObject * obj9 = 0 ;
2426	>
2427	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_queryTasks",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
2428	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2429	>	if (obj2) {
2430	>	{
2431	>	if (PyString_Check(obj2)) {
2432	>	temp3 = std::string(PyString_AsString(obj2));
2433	>	arg3 = &temp3;
2434	>	}else {
2435	>	SWIG_exception(SWIG_TypeError, "string expected");
2436	>	}
2437		}
9200	–	}
2438		}
2439	<	}
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) {
2439	>	if (obj3) {
2440		{
2441	<	int res = SWIG_AsVal_size_t(argv[2], NULL);
2442	<	_v = SWIG_CheckState(res);
2443	<	}
2444	<	if (_v) {
2445	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
2446	<	_v = SWIG_CheckState(res);
9219	<	if (_v) {
9220	<	return _wrap_vector_string_insert__SWIG_1(self, args);
9221	<	}
2441	>	if (PyString_Check(obj3)) {
2442	>	temp4 = std::string(PyString_AsString(obj3));
2443	>	arg4 = &temp4;
2444	>	}else {
2445	>	SWIG_exception(SWIG_TypeError, "string expected");
2446	>	}
2447		}
9223	–	}
9224	–	}
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	–	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());
2448		}
2449	<	}
2450	<	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
2451	<	return resultobj;
2452	<	fail:
2453	<	return NULL;
2454	<	}
2455	<
2456	<
2457	<	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());
2449	>	if (obj4) {
2450	>	{
2451	>	if (PyString_Check(obj4)) {
2452	>	temp5 = std::string(PyString_AsString(obj4));
2453	>	arg5 = &temp5;
2454	>	}else {
2455	>	SWIG_exception(SWIG_TypeError, "string expected");
2456	>	}
2457	>	}
2458		}
2459	<	}
2460	<	resultobj = SWIG_Py_Void();
2461	<	return resultobj;
2462	<	fail:
2463	<	return NULL;
2464	<	}
2465	<
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""'");
2459	>	if (obj5) {
2460	>	{
2461	>	if (PyString_Check(obj5))
2462	>	arg6 = std::string(PyString_AsString(obj5));
2463	>	else
2464	>	SWIG_exception(SWIG_TypeError, "string expected");
2465	>	}
2466		}
2467	<	arg1 = *ptr;
2468	<	if (SWIG_IsNewObj(res)) delete ptr;
2469	<	}
2470	<	{
2471	<	try {
2472	<	result = (BossSession *)new BossSession(arg1);
2473	<	} catch (const std::exception& e) {
9352	<	SWIG_exception(SWIG_RuntimeError, e.what());
2467	>	if (obj6) {
2468	>	{
2469	>	if (PyString_Check(obj6))
2470	>	arg7 = std::string(PyString_AsString(obj6));
2471	>	else
2472	>	SWIG_exception(SWIG_TypeError, "string expected");
2473	>	}
2474		}
2475	<	}
2476	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossSession, SWIG_POINTER_NEW |  0 );
2477	<	return resultobj;
2478	<	fail:
2479	<	return NULL;
2480	<	}
2481	<
9361	<
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());
2475	>	if (obj7) {
2476	>	{
2477	>	if (PyString_Check(obj7))
2478	>	arg8 = std::string(PyString_AsString(obj7));
2479	>	else
2480	>	SWIG_exception(SWIG_TypeError, "string expected");
2481	>	}
2482		}
2483	<	}
2484	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossSession, SWIG_POINTER_NEW |  0 );
2485	<	return resultobj;
2486	<	fail:
2487	<	return NULL;
2488	<	}
2489	<
9380	<
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);
2483	>	if (obj8) {
2484	>	{
2485	>	if (PyString_Check(obj8))
2486	>	arg9 = std::string(PyString_AsString(obj8));
2487	>	else
2488	>	SWIG_exception(SWIG_TypeError, "string expected");
2489	>	}
2490		}
2491	<	}
2492	<
2493	<	fail:
9404	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_BossSession'");
9405	<	return NULL;
9406	<	}
9407	<
9408	<
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());
2491	>	if (obj9) {
2492	>	arg10 = PyInt_AsLong(obj9) ? true : false;
2493	>	if (PyErr_Occurred()) SWIG_fail;
2494		}
2495	<	}
2496	<	resultobj = SWIG_Py_Void();
2497	<	return resultobj;
2498	<	fail:
2499	<	return NULL;
2500	<	}
2501	<
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());
2495	>	{
2496	>	try {
2497	>	result = (PyObject *)BossSession_queryTasks(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
2498	>
2499	>	}catch (const std::exception& e) {
2500	>	SWIG_exception(SWIG_RuntimeError, e.what());
2501	>	}
2502		}
2503	<	}
2504	<	resultobj = SWIG_Py_Void();
2505	<	return resultobj;
2506	<	fail:
9460	<	return NULL;
2503	>	resultobj = result;
2504	>	return resultobj;
2505	>	fail:
2506	>	return NULL;
2507		}
2508
2509
2510	<	SWIGINTERN PyObject *_wrap_BossSession_makeBossTask__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2511	<	PyObject *resultobj = 0;
2512	<	BossSession *arg1 = (BossSession *) 0 ;
2513	<	std::string *arg2 = 0 ;
2514	<	BossTask *result = 0 ;
2515	<	void *argp1 = 0 ;
2516	<	int res1 = 0 ;
2517	<	int res2 = SWIG_OLDOBJ ;
2518	<	PyObject * obj0 = 0 ;
2519	<	PyObject * obj1 = 0 ;
2520	<
2521	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_makeBossTask",&obj0,&obj1)) SWIG_fail;
2522	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2523	<	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	<	if (!ptr) {
9488	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_makeBossTask" "', argument " "2"" of type '" "std::string const &""'");
2510	>	static PyObject *_wrap_new_BossSession(PyObject *self, PyObject *args) {
2511	>	PyObject *resultobj;
2512	>	std::string arg1 = (std::string) "" ;
2513	>	BossSession *result;
2514	>	PyObject * obj0 = 0 ;
2515	>
2516	>	if(!PyArg_ParseTuple(args,(char *)"|O:new_BossSession",&obj0)) goto fail;
2517	>	if (obj0) {
2518	>	{
2519	>	if (PyString_Check(obj0))
2520	>	arg1 = std::string(PyString_AsString(obj0));
2521	>	else
2522	>	SWIG_exception(SWIG_TypeError, "string expected");
2523	>	}
2524		}
2525	<	arg2 = ptr;
2526	<	}
2527	<	{
2528	<	try {
2529	<	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2530	<	} catch (const std::exception& e) {
2531	<	SWIG_exception(SWIG_RuntimeError, e.what());
2525	>	{
2526	>	try {
2527	>	result = (BossSession *)new BossSession(arg1);
2528	>
2529	>	}catch (const std::exception& e) {
2530	>	SWIG_exception(SWIG_RuntimeError, e.what());
2531	>	}
2532		}
2533	<	}
2534	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, 0 |  0 );
2535	<	if (SWIG_IsNewObj(res2)) delete arg2;
2536	<	return resultobj;
9502	<	fail:
9503	<	if (SWIG_IsNewObj(res2)) delete arg2;
9504	<	return NULL;
2533	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossSession, 1);
2534	>	return resultobj;
2535	>	fail:
2536	>	return NULL;
2537		}
2538
2539
2540	<	SWIGINTERN PyObject *_wrap_BossSession_makeBossTask__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2541	<	PyObject *resultobj = 0;
2542	<	BossSession *arg1 = (BossSession *) 0 ;
2543	<	BossTask *result = 0 ;
2544	<	void *argp1 = 0 ;
2545	<	int res1 = 0 ;
2546	<	PyObject * obj0 = 0 ;
2547	<
2548	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_makeBossTask",&obj0)) SWIG_fail;
2549	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2550	<	if (!SWIG_IsOK(res1)) {
2551	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_makeBossTask" "', argument " "1"" of type '" "BossSession *""'");
2552	<	}
2553	<	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());
2540	>	static PyObject *_wrap_delete_BossSession(PyObject *self, PyObject *args) {
2541	>	PyObject *resultobj;
2542	>	BossSession *arg1 = (BossSession *) 0 ;
2543	>	PyObject * obj0 = 0 ;
2544	>
2545	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossSession",&obj0)) goto fail;
2546	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2547	>	{
2548	>	try {
2549	>	delete arg1;
2550	>
2551	>	}catch (const std::exception& e) {
2552	>	SWIG_exception(SWIG_RuntimeError, e.what());
2553	>	}
2554		}
2555	<	}
2556	<	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, 0 |  0 );
2557	<	return resultobj;
2558	<	fail:
9532	<	return NULL;
2555	>	Py_INCREF(Py_None); resultobj = Py_None;
2556	>	return resultobj;
2557	>	fail:
2558	>	return NULL;
2559		}
2560
2561
2562	<	SWIGINTERN PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2563	<	int argc;
2564	<	PyObject *argv[3];
2565	<	int ii;
2566	<
2567	<	if (!PyTuple_Check(args)) SWIG_fail;
2568	<	argc = PyObject_Length(args);
2569	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
2570	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2571	<	}
2572	<	if (argc == 1) {
2573	<	int _v;
2574	<	void *vptr = 0;
2575	<	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	<	}
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	<	}
2562	>	static PyObject *_wrap_BossSession_clear(PyObject *self, PyObject *args) {
2563	>	PyObject *resultobj;
2564	>	BossSession *arg1 = (BossSession *) 0 ;
2565	>	PyObject * obj0 = 0 ;
2566	>
2567	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clear",&obj0)) goto fail;
2568	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2569	>	{
2570	>	try {
2571	>	(arg1)->clear();
2572	>
2573	>	}catch (const std::exception& e) {
2574	>	SWIG_exception(SWIG_RuntimeError, e.what());
2575	>	}
2576		}
2577	<	}
2578	<
2579	<	fail:
2580	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_makeBossTask'");
9571	<	return NULL;
2577	>	Py_INCREF(Py_None); resultobj = Py_None;
2578	>	return resultobj;
2579	>	fail:
2580	>	return NULL;
2581		}
2582
2583
2584	<	SWIGINTERN PyObject *_wrap_BossSession_destroyBossTask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2585	<	PyObject *resultobj = 0;
2586	<	BossSession *arg1 = (BossSession *) 0 ;
2587	<	BossTask *arg2 = (BossTask *) 0 ;
2588	<	void *argp1 = 0 ;
2589	<	int res1 = 0 ;
2590	<	void *argp2 = 0 ;
2591	<	int res2 = 0 ;
2592	<	PyObject * obj0 = 0 ;
2593	<	PyObject * obj1 = 0 ;
2594	<
2595	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) SWIG_fail;
2596	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2597	<	if (!SWIG_IsOK(res1)) {
2598	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_destroyBossTask" "', argument " "1"" of type '" "BossSession *""'");
2599	<	}
2600	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2601	<	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_BossTask, 0 |  0 );
2602	<	if (!SWIG_IsOK(res2)) {
2603	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_destroyBossTask" "', argument " "2"" of type '" "BossTask *""'");
2604	<	}
9596	<	arg2 = reinterpret_cast< BossTask * >(argp2);
9597	<	{
9598	<	try {
9599	<	(arg1)->destroyBossTask(arg2);
9600	<	} catch (const std::exception& e) {
9601	<	SWIG_exception(SWIG_RuntimeError, e.what());
2584	>	static PyObject *_wrap_BossSession_makeBossTask(PyObject *self, PyObject *args) {
2585	>	PyObject *resultobj;
2586	>	BossSession *arg1 = (BossSession *) 0 ;
2587	>	std::string const &arg2_defvalue = "" ;
2588	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
2589	>	BossTask *result;
2590	>	std::string temp2 ;
2591	>	PyObject * obj0 = 0 ;
2592	>	PyObject * obj1 = 0 ;
2593	>
2594	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_makeBossTask",&obj0,&obj1)) goto fail;
2595	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2596	>	if (obj1) {
2597	>	{
2598	>	if (PyString_Check(obj1)) {
2599	>	temp2 = std::string(PyString_AsString(obj1));
2600	>	arg2 = &temp2;
2601	>	}else {
2602	>	SWIG_exception(SWIG_TypeError, "string expected");
2603	>	}
2604	>	}
2605		}
2606	<	}
2607	<	resultobj = SWIG_Py_Void();
2608	<	return resultobj;
2609	<	fail:
2610	<	return NULL;
2611	<	}
2612	<
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());
2606	>	{
2607	>	try {
2608	>	result = (BossTask *)(arg1)->makeBossTask((std::string const &)*arg2);
2609	>
2610	>	}catch (const std::exception& e) {
2611	>	SWIG_exception(SWIG_RuntimeError, e.what());
2612	>	}
2613		}
2614	<	}
2615	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2616	<	return resultobj;
2617	<	fail:
9635	<	return NULL;
2614	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 0);
2615	>	return resultobj;
2616	>	fail:
2617	>	return NULL;
2618		}
2619
2620
2621	<	SWIGINTERN PyObject *_wrap_BossSession_defaultProgramType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2622	<	PyObject *resultobj = 0;
2623	<	BossSession *arg1 = (BossSession *) 0 ;
2624	<	std::string result;
2625	<	void *argp1 = 0 ;
2626	<	int res1 = 0 ;
2627	<	PyObject * obj0 = 0 ;
2628	<
2629	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) SWIG_fail;
2630	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2631	<	if (!SWIG_IsOK(res1)) {
2632	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultProgramType" "', argument " "1"" of type '" "BossSession *""'");
2633	<	}
2634	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2635	<	{
2636	<	try {
2637	<	result = (arg1)->defaultProgramType();
9656	<	} catch (const std::exception& e) {
9657	<	SWIG_exception(SWIG_RuntimeError, e.what());
2621	>	static PyObject *_wrap_BossSession_destroyBossTask(PyObject *self, PyObject *args) {
2622	>	PyObject *resultobj;
2623	>	BossSession *arg1 = (BossSession *) 0 ;
2624	>	BossTask *arg2 = (BossTask *) 0 ;
2625	>	PyObject * obj0 = 0 ;
2626	>	PyObject * obj1 = 0 ;
2627	>
2628	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossSession_destroyBossTask",&obj0,&obj1)) goto fail;
2629	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2630	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2631	>	{
2632	>	try {
2633	>	(arg1)->destroyBossTask(arg2);
2634	>
2635	>	}catch (const std::exception& e) {
2636	>	SWIG_exception(SWIG_RuntimeError, e.what());
2637	>	}
2638		}
2639	<	}
2640	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2641	<	return resultobj;
2642	<	fail:
9663	<	return NULL;
2639	>	Py_INCREF(Py_None); resultobj = Py_None;
2640	>	return resultobj;
2641	>	fail:
2642	>	return NULL;
2643		}
2644
2645
2646	<	SWIGINTERN PyObject *_wrap_BossSession_defaultRTMon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2647	<	PyObject *resultobj = 0;
2648	<	BossSession *arg1 = (BossSession *) 0 ;
2649	<	std::string result;
2650	<	void *argp1 = 0 ;
2651	<	int res1 = 0 ;
2652	<	PyObject * obj0 = 0 ;
2653	<
2654	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) SWIG_fail;
2655	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2656	<	if (!SWIG_IsOK(res1)) {
2657	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultRTMon" "', argument " "1"" of type '" "BossSession *""'");
2658	<	}
2659	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2660	<	{
9682	<	try {
9683	<	result = (arg1)->defaultRTMon();
9684	<	} catch (const std::exception& e) {
9685	<	SWIG_exception(SWIG_RuntimeError, e.what());
2646	>	static PyObject *_wrap_BossSession_defaultCHTool(PyObject *self, PyObject *args) {
2647	>	PyObject *resultobj;
2648	>	BossSession *arg1 = (BossSession *) 0 ;
2649	>	std::string result;
2650	>	PyObject * obj0 = 0 ;
2651	>
2652	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultCHTool",&obj0)) goto fail;
2653	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2654	>	{
2655	>	try {
2656	>	result = (arg1)->defaultCHTool();
2657	>
2658	>	}catch (const std::exception& e) {
2659	>	SWIG_exception(SWIG_RuntimeError, e.what());
2660	>	}
2661		}
2662	<	}
2663	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9689	<	return resultobj;
9690	<	fail:
9691	<	return NULL;
9692	<	}
9693	<
9694	<
9695	<	SWIGINTERN PyObject *_wrap_BossSession_defaultScheduler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9696	<	PyObject *resultobj = 0;
9697	<	BossSession *arg1 = (BossSession *) 0 ;
9698	<	std::string result;
9699	<	void *argp1 = 0 ;
9700	<	int res1 = 0 ;
9701	<	PyObject * obj0 = 0 ;
9702	<
9703	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) SWIG_fail;
9704	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9705	<	if (!SWIG_IsOK(res1)) {
9706	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_defaultScheduler" "', argument " "1"" of type '" "BossSession *""'");
9707	<	}
9708	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9709	<	{
9710	<	try {
9711	<	result = (arg1)->defaultScheduler();
9712	<	} catch (const std::exception& e) {
9713	<	SWIG_exception(SWIG_RuntimeError, e.what());
2662	>	{
2663	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2664		}
2665	<	}
2666	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2667	<	return resultobj;
9718	<	fail:
9719	<	return NULL;
2665	>	return resultobj;
2666	>	fail:
2667	>	return NULL;
2668		}
2669
2670
2671	<	SWIGINTERN PyObject *_wrap_BossSession_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2672	<	PyObject *resultobj = 0;
2673	<	BossSession *arg1 = (BossSession *) 0 ;
2674	<	std::string result;
2675	<	void *argp1 = 0 ;
2676	<	int res1 = 0 ;
2677	<	PyObject * obj0 = 0 ;
2678	<
2679	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) SWIG_fail;
2680	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2681	<	if (!SWIG_IsOK(res1)) {
2682	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_version" "', argument " "1"" of type '" "BossSession *""'");
2683	<	}
2684	<	arg1 = reinterpret_cast< BossSession * >(argp1);
2685	<	{
9738	<	try {
9739	<	result = (arg1)->version();
9740	<	} catch (const std::exception& e) {
9741	<	SWIG_exception(SWIG_RuntimeError, e.what());
2671	>	static PyObject *_wrap_BossSession_defaultProgramType(PyObject *self, PyObject *args) {
2672	>	PyObject *resultobj;
2673	>	BossSession *arg1 = (BossSession *) 0 ;
2674	>	std::string result;
2675	>	PyObject * obj0 = 0 ;
2676	>
2677	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultProgramType",&obj0)) goto fail;
2678	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2679	>	{
2680	>	try {
2681	>	result = (arg1)->defaultProgramType();
2682	>
2683	>	}catch (const std::exception& e) {
2684	>	SWIG_exception(SWIG_RuntimeError, e.what());
2685	>	}
2686		}
2687	<	}
2688	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
9745	<	return resultobj;
9746	<	fail:
9747	<	return NULL;
9748	<	}
9749	<
9750	<
9751	<	SWIGINTERN PyObject *_wrap_BossSession_clientID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9752	<	PyObject *resultobj = 0;
9753	<	BossSession *arg1 = (BossSession *) 0 ;
9754	<	std::string result;
9755	<	void *argp1 = 0 ;
9756	<	int res1 = 0 ;
9757	<	PyObject * obj0 = 0 ;
9758	<
9759	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) SWIG_fail;
9760	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9761	<	if (!SWIG_IsOK(res1)) {
9762	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_clientID" "', argument " "1"" of type '" "BossSession *""'");
9763	<	}
9764	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9765	<	{
9766	<	try {
9767	<	result = (arg1)->clientID();
9768	<	} catch (const std::exception& e) {
9769	<	SWIG_exception(SWIG_RuntimeError, e.what());
2687	>	{
2688	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2689		}
2690	<	}
2691	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
2692	<	return resultobj;
9774	<	fail:
9775	<	return NULL;
2690	>	return resultobj;
2691	>	fail:
2692	>	return NULL;
2693		}
2694
2695
2696	<	SWIGINTERN PyObject *_wrap_BossSession_showConfigs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2697	<	PyObject *resultobj = 0;
2698	<	BossSession *arg1 = (BossSession *) 0 ;
2699	<	bool arg2 ;
2700	<	int result;
2701	<	void *argp1 = 0 ;
2702	<	int res1 = 0 ;
2703	<	bool val2 ;
2704	<	int ecode2 = 0 ;
2705	<	PyObject * obj0 = 0 ;
2706	<	PyObject * obj1 = 0 ;
2707	<
2708	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_showConfigs",&obj0,&obj1)) SWIG_fail;
2709	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2710	<	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());
2696	>	static PyObject *_wrap_BossSession_defaultRTMon(PyObject *self, PyObject *args) {
2697	>	PyObject *resultobj;
2698	>	BossSession *arg1 = (BossSession *) 0 ;
2699	>	std::string result;
2700	>	PyObject * obj0 = 0 ;
2701	>
2702	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultRTMon",&obj0)) goto fail;
2703	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2704	>	{
2705	>	try {
2706	>	result = (arg1)->defaultRTMon();
2707	>
2708	>	}catch (const std::exception& e) {
2709	>	SWIG_exception(SWIG_RuntimeError, e.what());
2710	>	}
2711		}
2712	<	}
2713	<	resultobj = SWIG_From_int(static_cast< int >(result));
9810	<	return resultobj;
9811	<	fail:
9812	<	return NULL;
9813	<	}
9814	<
9815	<
9816	<	SWIGINTERN PyObject *_wrap_BossSession_showConfigs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9817	<	PyObject *resultobj = 0;
9818	<	BossSession *arg1 = (BossSession *) 0 ;
9819	<	int result;
9820	<	void *argp1 = 0 ;
9821	<	int res1 = 0 ;
9822	<	PyObject * obj0 = 0 ;
9823	<
9824	<	if (!PyArg_ParseTuple(args,(char *)"O:BossSession_showConfigs",&obj0)) SWIG_fail;
9825	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
9826	<	if (!SWIG_IsOK(res1)) {
9827	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_showConfigs" "', argument " "1"" of type '" "BossSession *""'");
9828	<	}
9829	<	arg1 = reinterpret_cast< BossSession * >(argp1);
9830	<	{
9831	<	try {
9832	<	result = (int)(arg1)->showConfigs();
9833	<	} catch (const std::exception& e) {
9834	<	SWIG_exception(SWIG_RuntimeError, e.what());
2712	>	{
2713	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2714		}
2715	<	}
2716	<	resultobj = SWIG_From_int(static_cast< int >(result));
2717	<	return resultobj;
9839	<	fail:
9840	<	return NULL;
2715	>	return resultobj;
2716	>	fail:
2717	>	return NULL;
2718		}
2719
2720
2721	<	SWIGINTERN PyObject *_wrap_BossSession_showConfigs(PyObject *self, PyObject *args) {
2722	<	int argc;
2723	<	PyObject *argv[3];
2724	<	int ii;
2725	<
2726	<	if (!PyTuple_Check(args)) SWIG_fail;
2727	<	argc = PyObject_Length(args);
2728	<	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
2729	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2730	<	}
2731	<	if (argc == 1) {
2732	<	int _v;
2733	<	void *vptr = 0;
2734	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2735	<	_v = SWIG_CheckState(res);
9859	<	if (_v) {
9860	<	return _wrap_BossSession_showConfigs__SWIG_1(self, args);
2721	>	static PyObject *_wrap_BossSession_defaultScheduler(PyObject *self, PyObject *args) {
2722	>	PyObject *resultobj;
2723	>	BossSession *arg1 = (BossSession *) 0 ;
2724	>	std::string result;
2725	>	PyObject * obj0 = 0 ;
2726	>
2727	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_defaultScheduler",&obj0)) goto fail;
2728	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2729	>	{
2730	>	try {
2731	>	result = (arg1)->defaultScheduler();
2732	>
2733	>	}catch (const std::exception& e) {
2734	>	SWIG_exception(SWIG_RuntimeError, e.what());
2735	>	}
2736		}
2737	<	}
2738	<	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	<	}
2737	>	{
2738	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2739		}
2740	<	}
2741	<
2742	<	fail:
9880	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_showConfigs'");
9881	<	return NULL;
2740	>	return resultobj;
2741	>	fail:
2742	>	return NULL;
2743		}
2744
2745
2746	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2747	<	PyObject *resultobj = 0;
2748	<	BossSession *arg1 = (BossSession *) 0 ;
2749	<	std::string arg2 ;
2750	<	std::string arg3 ;
2751	<	std::string arg4 ;
2752	<	int result;
2753	<	void *argp1 = 0 ;
2754	<	int res1 = 0 ;
2755	<	PyObject * obj0 = 0 ;
2756	<	PyObject * obj1 = 0 ;
2757	<	PyObject * obj2 = 0 ;
2758	<	PyObject * obj3 = 0 ;
2759	<
2760	<	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	<	arg2 = *ptr;
9912	<	if (SWIG_IsNewObj(res)) delete ptr;
9913	<	}
9914	<	{
9915	<	std::string *ptr = (std::string *)0;
9916	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
9917	<	if (!SWIG_IsOK(res) || !ptr) {
9918	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_RTupdate" "', argument " "3"" of type '" "std::string""'");
9919	<	}
9920	<	arg3 = *ptr;
9921	<	if (SWIG_IsNewObj(res)) delete ptr;
9922	<	}
9923	<	{
9924	<	std::string *ptr = (std::string *)0;
9925	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
9926	<	if (!SWIG_IsOK(res) || !ptr) {
9927	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_RTupdate" "', argument " "4"" of type '" "std::string""'");
2746	>	static PyObject *_wrap_BossSession_version(PyObject *self, PyObject *args) {
2747	>	PyObject *resultobj;
2748	>	BossSession *arg1 = (BossSession *) 0 ;
2749	>	std::string result;
2750	>	PyObject * obj0 = 0 ;
2751	>
2752	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_version",&obj0)) goto fail;
2753	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2754	>	{
2755	>	try {
2756	>	result = (arg1)->version();
2757	>
2758	>	}catch (const std::exception& e) {
2759	>	SWIG_exception(SWIG_RuntimeError, e.what());
2760	>	}
2761		}
2762	<	arg4 = *ptr;
2763	<	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());
2762	>	{
2763	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2764		}
2765	<	}
2766	<	resultobj = SWIG_From_int(static_cast< int >(result));
2767	<	return resultobj;
9941	<	fail:
9942	<	return NULL;
2765	>	return resultobj;
2766	>	fail:
2767	>	return NULL;
2768		}
2769
2770
2771	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2772	<	PyObject *resultobj = 0;
2773	<	BossSession *arg1 = (BossSession *) 0 ;
2774	<	std::string arg2 ;
2775	<	std::string arg3 ;
2776	<	int result;
2777	<	void *argp1 = 0 ;
2778	<	int res1 = 0 ;
2779	<	PyObject * obj0 = 0 ;
2780	<	PyObject * obj1 = 0 ;
2781	<	PyObject * obj2 = 0 ;
2782	<
2783	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_RTupdate",&obj0,&obj1,&obj2)) SWIG_fail;
2784	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2785	<	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	<	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""'");
2771	>	static PyObject *_wrap_BossSession_clientID(PyObject *self, PyObject *args) {
2772	>	PyObject *resultobj;
2773	>	BossSession *arg1 = (BossSession *) 0 ;
2774	>	std::string result;
2775	>	PyObject * obj0 = 0 ;
2776	>
2777	>	if(!PyArg_ParseTuple(args,(char *)"O:BossSession_clientID",&obj0)) goto fail;
2778	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2779	>	{
2780	>	try {
2781	>	result = (arg1)->clientID();
2782	>
2783	>	}catch (const std::exception& e) {
2784	>	SWIG_exception(SWIG_RuntimeError, e.what());
2785	>	}
2786		}
2787	<	arg3 = *ptr;
2788	<	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());
2787	>	{
2788	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
2789		}
2790	<	}
2791	<	resultobj = SWIG_From_int(static_cast< int >(result));
2792	<	return resultobj;
9991	<	fail:
9992	<	return NULL;
2790	>	return resultobj;
2791	>	fail:
2792	>	return NULL;
2793		}
2794
2795
2796	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2797	<	PyObject *resultobj = 0;
2798	<	BossSession *arg1 = (BossSession *) 0 ;
2799	<	std::string arg2 ;
2800	<	int result;
2801	<	void *argp1 = 0 ;
2802	<	int res1 = 0 ;
2803	<	PyObject * obj0 = 0 ;
2804	<	PyObject * obj1 = 0 ;
2805	<
2806	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_RTupdate",&obj0,&obj1)) SWIG_fail;
2807	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
2808	<	if (!SWIG_IsOK(res1)) {
10009	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_RTupdate" "', argument " "1"" of type '" "BossSession *""'");
10010	<	}
10011	<	arg1 = reinterpret_cast< BossSession * >(argp1);
10012	<	{
10013	<	std::string *ptr = (std::string *)0;
10014	<	int res = SWIG_AsPtr_std_string(obj1, &ptr);
10015	<	if (!SWIG_IsOK(res) || !ptr) {
10016	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_RTupdate" "', argument " "2"" of type '" "std::string""'");
10017	<	}
10018	<	arg2 = *ptr;
10019	<	if (SWIG_IsNewObj(res)) delete ptr;
10020	<	}
10021	<	{
10022	<	try {
10023	<	result = (int)(arg1)->RTupdate(arg2);
10024	<	} catch (const std::exception& e) {
10025	<	SWIG_exception(SWIG_RuntimeError, e.what());
2796	>	static PyObject *_wrap_BossSession_showConfigs(PyObject *self, PyObject *args) {
2797	>	PyObject *resultobj;
2798	>	BossSession *arg1 = (BossSession *) 0 ;
2799	>	bool arg2 = (bool) false ;
2800	>	int result;
2801	>	PyObject * obj0 = 0 ;
2802	>	PyObject * obj1 = 0 ;
2803	>
2804	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossSession_showConfigs",&obj0,&obj1)) goto fail;
2805	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2806	>	if (obj1) {
2807	>	arg2 = PyInt_AsLong(obj1) ? true : false;
2808	>	if (PyErr_Occurred()) SWIG_fail;
2809		}
2810	<	}
2811	<	resultobj = SWIG_From_int(static_cast< int >(result));
2812	<	return resultobj;
2813	<	fail:
2814	<	return NULL;
2815	<	}
2816	<
10034	<
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());
2810	>	{
2811	>	try {
2812	>	result = (int)(arg1)->showConfigs(arg2);
2813	>
2814	>	}catch (const std::exception& e) {
2815	>	SWIG_exception(SWIG_RuntimeError, e.what());
2816	>	}
2817		}
2818	<	}
2819	<	resultobj = SWIG_From_int(static_cast< int >(result));
2820	<	return resultobj;
2821	<	fail:
10059	<	return NULL;
2818	>	resultobj = PyInt_FromLong((long)result);
2819	>	return resultobj;
2820	>	fail:
2821	>	return NULL;
2822		}
2823
2824
2825	<	SWIGINTERN PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2826	<	int argc;
2827	<	PyObject *argv[5];
2828	<	int ii;
2829	<
2830	<	if (!PyTuple_Check(args)) SWIG_fail;
2831	<	argc = PyObject_Length(args);
2832	<	for (ii = 0; (ii < argc) && (ii < 4); ii++) {
2833	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2834	<	}
2835	<	if (argc == 1) {
2836	<	int _v;
2837	<	void *vptr = 0;
2838	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2839	<	_v = SWIG_CheckState(res);
2840	<	if (_v) {
2841	<	return _wrap_BossSession_RTupdate__SWIG_3(self, args);
2842	<	}
2843	<	}
2844	<	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);
2825	>	static PyObject *_wrap_BossSession_RTupdate(PyObject *self, PyObject *args) {
2826	>	PyObject *resultobj;
2827	>	BossSession *arg1 = (BossSession *) 0 ;
2828	>	std::string arg2 = (std::string) "all" ;
2829	>	std::string arg3 = (std::string) "all" ;
2830	>	std::string arg4 = (std::string) "" ;
2831	>	int result;
2832	>	PyObject * obj0 = 0 ;
2833	>	PyObject * obj1 = 0 ;
2834	>	PyObject * obj2 = 0 ;
2835	>	PyObject * obj3 = 0 ;
2836	>
2837	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossSession_RTupdate",&obj0,&obj1,&obj2,&obj3)) goto fail;
2838	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2839	>	if (obj1) {
2840	>	{
2841	>	if (PyString_Check(obj1))
2842	>	arg2 = std::string(PyString_AsString(obj1));
2843	>	else
2844	>	SWIG_exception(SWIG_TypeError, "string expected");
2845		}
10109	–	}
2846		}
2847	<	}
2848	<	if (argc == 4) {
2849	<	int _v;
2850	<	void *vptr = 0;
2851	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2852	<	_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	<	}
2847	>	if (obj2) {
2848	>	{
2849	>	if (PyString_Check(obj2))
2850	>	arg3 = std::string(PyString_AsString(obj2));
2851	>	else
2852	>	SWIG_exception(SWIG_TypeError, "string expected");
2853		}
10130	–	}
10131	–	}
10132	–	}
10133	–
10134	–	fail:
10135	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_RTupdate'");
10136	–	return NULL;
10137	–	}
10138	–
10139	–
10140	–	SWIGINTERN PyObject *_wrap_BossSession_listMatch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10141	–	PyObject *resultobj = 0;
10142	–	BossSession *arg1 = (BossSession *) 0 ;
10143	–	std::string *arg2 = 0 ;
10144	–	std::string *arg3 = 0 ;
10145	–	bool arg4 ;
10146	–	std::string *arg5 = 0 ;
10147	–	std::string *arg6 = 0 ;
10148	–	std::vector<std::string,std::allocator<std::string > > result;
10149	–	void *argp1 = 0 ;
10150	–	int res1 = 0 ;
10151	–	int res2 = SWIG_OLDOBJ ;
10152	–	int res3 = SWIG_OLDOBJ ;
10153	–	bool val4 ;
10154	–	int ecode4 = 0 ;
10155	–	int res5 = SWIG_OLDOBJ ;
10156	–	int res6 = SWIG_OLDOBJ ;
10157	–	PyObject * obj0 = 0 ;
10158	–	PyObject * obj1 = 0 ;
10159	–	PyObject * obj2 = 0 ;
10160	–	PyObject * obj3 = 0 ;
10161	–	PyObject * obj4 = 0 ;
10162	–	PyObject * obj5 = 0 ;
10163	–
10164	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
10165	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10166	–	if (!SWIG_IsOK(res1)) {
10167	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_listMatch" "', argument " "1"" of type '" "BossSession *""'");
10168	–	}
10169	–	arg1 = reinterpret_cast< BossSession * >(argp1);
10170	–	{
10171	–	std::string *ptr = (std::string *)0;
10172	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
10173	–	if (!SWIG_IsOK(res2)) {
10174	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10175	–	}
10176	–	if (!ptr) {
10177	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10178	–	}
10179	–	arg2 = ptr;
10180	–	}
10181	–	{
10182	–	std::string *ptr = (std::string *)0;
10183	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10184	–	if (!SWIG_IsOK(res3)) {
10185	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10186	–	}
10187	–	if (!ptr) {
10188	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10189	–	}
10190	–	arg3 = ptr;
10191	–	}
10192	–	ecode4 = SWIG_AsVal_bool(obj3, &val4);
10193	–	if (!SWIG_IsOK(ecode4)) {
10194	–	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossSession_listMatch" "', argument " "4"" of type '" "bool""'");
10195	–	}
10196	–	arg4 = static_cast< bool >(val4);
10197	–	{
10198	–	std::string *ptr = (std::string *)0;
10199	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10200	–	if (!SWIG_IsOK(res5)) {
10201	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_listMatch" "', argument " "5"" of type '" "std::string const &""'");
10202	–	}
10203	–	if (!ptr) {
10204	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "5"" of type '" "std::string const &""'");
10205	–	}
10206	–	arg5 = ptr;
10207	–	}
10208	–	{
10209	–	std::string *ptr = (std::string *)0;
10210	–	res6 = SWIG_AsPtr_std_string(obj5, &ptr);
10211	–	if (!SWIG_IsOK(res6)) {
10212	–	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BossSession_listMatch" "', argument " "6"" of type '" "std::string const &""'");
10213	–	}
10214	–	if (!ptr) {
10215	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "6"" of type '" "std::string const &""'");
10216	–	}
10217	–	arg6 = ptr;
10218	–	}
10219	–	{
10220	–	try {
10221	–	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
10222	–	} catch (const std::exception& e) {
10223	–	SWIG_exception(SWIG_RuntimeError, e.what());
10224	–	}
10225	–	}
10226	–	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
10227	–	if (SWIG_IsNewObj(res2)) delete arg2;
10228	–	if (SWIG_IsNewObj(res3)) delete arg3;
10229	–	if (SWIG_IsNewObj(res5)) delete arg5;
10230	–	if (SWIG_IsNewObj(res6)) delete arg6;
10231	–	return resultobj;
10232	–	fail:
10233	–	if (SWIG_IsNewObj(res2)) delete arg2;
10234	–	if (SWIG_IsNewObj(res3)) delete arg3;
10235	–	if (SWIG_IsNewObj(res5)) delete arg5;
10236	–	if (SWIG_IsNewObj(res6)) delete arg6;
10237	–	return NULL;
10238	–	}
10239	–
10240	–
10241	–	SWIGINTERN PyObject *_wrap_BossSession_listMatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10242	–	PyObject *resultobj = 0;
10243	–	BossSession *arg1 = (BossSession *) 0 ;
10244	–	std::string *arg2 = 0 ;
10245	–	std::string *arg3 = 0 ;
10246	–	bool arg4 ;
10247	–	std::string *arg5 = 0 ;
10248	–	std::vector<std::string,std::allocator<std::string > > result;
10249	–	void *argp1 = 0 ;
10250	–	int res1 = 0 ;
10251	–	int res2 = SWIG_OLDOBJ ;
10252	–	int res3 = SWIG_OLDOBJ ;
10253	–	bool val4 ;
10254	–	int ecode4 = 0 ;
10255	–	int res5 = SWIG_OLDOBJ ;
10256	–	PyObject * obj0 = 0 ;
10257	–	PyObject * obj1 = 0 ;
10258	–	PyObject * obj2 = 0 ;
10259	–	PyObject * obj3 = 0 ;
10260	–	PyObject * obj4 = 0 ;
10261	–
10262	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
10263	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10264	–	if (!SWIG_IsOK(res1)) {
10265	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_listMatch" "', argument " "1"" of type '" "BossSession *""'");
10266	–	}
10267	–	arg1 = reinterpret_cast< BossSession * >(argp1);
10268	–	{
10269	–	std::string *ptr = (std::string *)0;
10270	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
10271	–	if (!SWIG_IsOK(res2)) {
10272	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10273	–	}
10274	–	if (!ptr) {
10275	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10276	–	}
10277	–	arg2 = ptr;
10278	–	}
10279	–	{
10280	–	std::string *ptr = (std::string *)0;
10281	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10282	–	if (!SWIG_IsOK(res3)) {
10283	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10284	–	}
10285	–	if (!ptr) {
10286	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10287	–	}
10288	–	arg3 = ptr;
10289	–	}
10290	–	ecode4 = SWIG_AsVal_bool(obj3, &val4);
10291	–	if (!SWIG_IsOK(ecode4)) {
10292	–	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossSession_listMatch" "', argument " "4"" of type '" "bool""'");
10293	–	}
10294	–	arg4 = static_cast< bool >(val4);
10295	–	{
10296	–	std::string *ptr = (std::string *)0;
10297	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10298	–	if (!SWIG_IsOK(res5)) {
10299	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_listMatch" "', argument " "5"" of type '" "std::string const &""'");
2854		}
2855	<	if (!ptr) {
2856	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "5"" of type '" "std::string const &""'");
2857	<	}
2858	<	arg5 = ptr;
2859	<	}
2860	<	{
2861	<	try {
10308	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5);
10309	<	} catch (const std::exception& e) {
10310	<	SWIG_exception(SWIG_RuntimeError, e.what());
10311	<	}
10312	<	}
10313	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
10314	<	if (SWIG_IsNewObj(res2)) delete arg2;
10315	<	if (SWIG_IsNewObj(res3)) delete arg3;
10316	<	if (SWIG_IsNewObj(res5)) delete arg5;
10317	<	return resultobj;
10318	<	fail:
10319	<	if (SWIG_IsNewObj(res2)) delete arg2;
10320	<	if (SWIG_IsNewObj(res3)) delete arg3;
10321	<	if (SWIG_IsNewObj(res5)) delete arg5;
10322	<	return NULL;
10323	<	}
10324	<
10325	<
10326	<	SWIGINTERN PyObject *_wrap_BossSession_listMatch__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10327	<	PyObject *resultobj = 0;
10328	<	BossSession *arg1 = (BossSession *) 0 ;
10329	<	std::string *arg2 = 0 ;
10330	<	std::string *arg3 = 0 ;
10331	<	bool arg4 ;
10332	<	std::vector<std::string,std::allocator<std::string > > result;
10333	<	void *argp1 = 0 ;
10334	<	int res1 = 0 ;
10335	<	int res2 = SWIG_OLDOBJ ;
10336	<	int res3 = SWIG_OLDOBJ ;
10337	<	bool val4 ;
10338	<	int ecode4 = 0 ;
10339	<	PyObject * obj0 = 0 ;
10340	<	PyObject * obj1 = 0 ;
10341	<	PyObject * obj2 = 0 ;
10342	<	PyObject * obj3 = 0 ;
10343	<
10344	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10345	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10346	<	if (!SWIG_IsOK(res1)) {
10347	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_listMatch" "', argument " "1"" of type '" "BossSession *""'");
10348	<	}
10349	<	arg1 = reinterpret_cast< BossSession * >(argp1);
10350	<	{
10351	<	std::string *ptr = (std::string *)0;
10352	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
10353	<	if (!SWIG_IsOK(res2)) {
10354	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10355	<	}
10356	<	if (!ptr) {
10357	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10358	<	}
10359	<	arg2 = ptr;
10360	<	}
10361	<	{
10362	<	std::string *ptr = (std::string *)0;
10363	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10364	<	if (!SWIG_IsOK(res3)) {
10365	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10366	<	}
10367	<	if (!ptr) {
10368	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10369	<	}
10370	<	arg3 = ptr;
10371	<	}
10372	<	ecode4 = SWIG_AsVal_bool(obj3, &val4);
10373	<	if (!SWIG_IsOK(ecode4)) {
10374	<	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossSession_listMatch" "', argument " "4"" of type '" "bool""'");
10375	<	}
10376	<	arg4 = static_cast< bool >(val4);
10377	<	{
10378	<	try {
10379	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4);
10380	<	} catch (const std::exception& e) {
10381	<	SWIG_exception(SWIG_RuntimeError, e.what());
10382	<	}
10383	<	}
10384	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
10385	<	if (SWIG_IsNewObj(res2)) delete arg2;
10386	<	if (SWIG_IsNewObj(res3)) delete arg3;
10387	<	return resultobj;
10388	<	fail:
10389	<	if (SWIG_IsNewObj(res2)) delete arg2;
10390	<	if (SWIG_IsNewObj(res3)) delete arg3;
10391	<	return NULL;
10392	<	}
10393	<
10394	<
10395	<	SWIGINTERN PyObject *_wrap_BossSession_listMatch__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10396	<	PyObject *resultobj = 0;
10397	<	BossSession *arg1 = (BossSession *) 0 ;
10398	<	std::string *arg2 = 0 ;
10399	<	std::string *arg3 = 0 ;
10400	<	std::vector<std::string,std::allocator<std::string > > result;
10401	<	void *argp1 = 0 ;
10402	<	int res1 = 0 ;
10403	<	int res2 = SWIG_OLDOBJ ;
10404	<	int res3 = SWIG_OLDOBJ ;
10405	<	PyObject * obj0 = 0 ;
10406	<	PyObject * obj1 = 0 ;
10407	<	PyObject * obj2 = 0 ;
10408	<
10409	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_listMatch",&obj0,&obj1,&obj2)) SWIG_fail;
10410	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10411	<	if (!SWIG_IsOK(res1)) {
10412	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_listMatch" "', argument " "1"" of type '" "BossSession *""'");
10413	<	}
10414	<	arg1 = reinterpret_cast< BossSession * >(argp1);
10415	<	{
10416	<	std::string *ptr = (std::string *)0;
10417	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
10418	<	if (!SWIG_IsOK(res2)) {
10419	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10420	<	}
10421	<	if (!ptr) {
10422	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "2"" of type '" "std::string const &""'");
10423	<	}
10424	<	arg2 = ptr;
10425	<	}
10426	<	{
10427	<	std::string *ptr = (std::string *)0;
10428	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10429	<	if (!SWIG_IsOK(res3)) {
10430	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
10431	<	}
10432	<	if (!ptr) {
10433	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_listMatch" "', argument " "3"" of type '" "std::string const &""'");
2855	>	if (obj3) {
2856	>	{
2857	>	if (PyString_Check(obj3))
2858	>	arg4 = std::string(PyString_AsString(obj3));
2859	>	else
2860	>	SWIG_exception(SWIG_TypeError, "string expected");
2861	>	}
2862		}
2863	<	arg3 = ptr;
2864	<	}
2865	<	{
2866	<	try {
2867	<	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3);
2868	<	} catch (const std::exception& e) {
2869	<	SWIG_exception(SWIG_RuntimeError, e.what());
2863	>	{
2864	>	try {
2865	>	result = (int)(arg1)->RTupdate(arg2,arg3,arg4);
2866	>
2867	>	}catch (const std::exception& e) {
2868	>	SWIG_exception(SWIG_RuntimeError, e.what());
2869	>	}
2870		}
2871	<	}
2872	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
2873	<	if (SWIG_IsNewObj(res2)) delete arg2;
2874	<	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;
2871	>	resultobj = PyInt_FromLong((long)result);
2872	>	return resultobj;
2873	>	fail:
2874	>	return NULL;
2875		}
2876
2877
2878	<	SWIGINTERN PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
2879	<	int argc;
2880	<	PyObject *argv[7];
2881	<	int ii;
2882	<
2883	<	if (!PyTuple_Check(args)) SWIG_fail;
2884	<	argc = PyObject_Length(args);
2885	<	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
2886	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2887	<	}
2888	<	if (argc == 3) {
2889	<	int _v;
2890	<	void *vptr = 0;
2891	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2892	<	_v = SWIG_CheckState(res);
2893	<	if (_v) {
2894	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
2895	<	_v = SWIG_CheckState(res);
2896	<	if (_v) {
2897	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
2898	<	_v = SWIG_CheckState(res);
2899	<	if (_v) {
2900	<	return _wrap_BossSession_listMatch__SWIG_3(self, args);
2878	>	static PyObject *_wrap_BossSession_listMatch(PyObject *self, PyObject *args) {
2879	>	PyObject *resultobj;
2880	>	BossSession *arg1 = (BossSession *) 0 ;
2881	>	std::string *arg2 = 0 ;
2882	>	std::string *arg3 = 0 ;
2883	>	bool arg4 = (bool) false ;
2884	>	std::string const &arg5_defvalue = "" ;
2885	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2886	>	std::string const &arg6_defvalue = "" ;
2887	>	std::string *arg6 = (std::string *) &arg6_defvalue ;
2888	>	std::vector<std::string > result;
2889	>	std::string temp2 ;
2890	>	std::string temp3 ;
2891	>	std::string temp5 ;
2892	>	std::string temp6 ;
2893	>	PyObject * obj0 = 0 ;
2894	>	PyObject * obj1 = 0 ;
2895	>	PyObject * obj2 = 0 ;
2896	>	PyObject * obj3 = 0 ;
2897	>	PyObject * obj4 = 0 ;
2898	>	PyObject * obj5 = 0 ;
2899	>
2900	>	if(!PyArg_ParseTuple(args,(char *)"OOO|OOO:BossSession_listMatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
2901	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2902	>	{
2903	>	if (PyString_Check(obj1)) {
2904	>	temp2 = std::string(PyString_AsString(obj1));
2905	>	arg2 = &temp2;
2906	>	}else {
2907	>	SWIG_exception(SWIG_TypeError, "string expected");
2908		}
10479	–	}
2909		}
2910	<	}
2911	<	if (argc == 4) {
2912	<	int _v;
2913	<	void *vptr = 0;
2914	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2915	<	_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	<	}
2910	>	{
2911	>	if (PyString_Check(obj2)) {
2912	>	temp3 = std::string(PyString_AsString(obj2));
2913	>	arg3 = &temp3;
2914	>	}else {
2915	>	SWIG_exception(SWIG_TypeError, "string expected");
2916		}
10502	–	}
2917		}
2918	<	}
2919	<	if (argc == 5) {
2920	<	int _v;
2921	<	void *vptr = 0;
2922	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2923	<	_v = SWIG_CheckState(res);
2924	<	if (_v) {
2925	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
2926	<	_v = SWIG_CheckState(res);
2927	<	if (_v) {
2928	<	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);
2918	>	if (obj3) {
2919	>	arg4 = PyInt_AsLong(obj3) ? true : false;
2920	>	if (PyErr_Occurred()) SWIG_fail;
2921	>	}
2922	>	if (obj4) {
2923	>	{
2924	>	if (PyString_Check(obj4)) {
2925	>	temp5 = std::string(PyString_AsString(obj4));
2926	>	arg5 = &temp5;
2927	>	}else {
2928	>	SWIG_exception(SWIG_TypeError, "string expected");
2929		}
10527	–	}
2930		}
10529	–	}
2931		}
2932	<	}
2933	<	if (argc == 6) {
2934	<	int _v;
2935	<	void *vptr = 0;
2936	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2937	<	_v = SWIG_CheckState(res);
2938	<	if (_v) {
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	<	}
2932	>	if (obj5) {
2933	>	{
2934	>	if (PyString_Check(obj5)) {
2935	>	temp6 = std::string(PyString_AsString(obj5));
2936	>	arg6 = &temp6;
2937	>	}else {
2938	>	SWIG_exception(SWIG_TypeError, "string expected");
2939		}
10558	–	}
2940		}
10560	–	}
10561	–	}
10562	–	}
10563	–
10564	–	fail:
10565	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_listMatch'");
10566	–	return NULL;
10567	–	}
10568	–
10569	–
10570	–	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10571	–	PyObject *resultobj = 0;
10572	–	BossSession *arg1 = (BossSession *) 0 ;
10573	–	int arg2 ;
10574	–	std::string *arg3 = 0 ;
10575	–	std::string *arg4 = 0 ;
10576	–	std::string *arg5 = 0 ;
10577	–	std::string arg6 ;
10578	–	std::string arg7 ;
10579	–	std::string arg8 ;
10580	–	std::string arg9 ;
10581	–	void *argp1 = 0 ;
10582	–	int res1 = 0 ;
10583	–	int val2 ;
10584	–	int ecode2 = 0 ;
10585	–	int res3 = SWIG_OLDOBJ ;
10586	–	int res4 = SWIG_OLDOBJ ;
10587	–	int res5 = SWIG_OLDOBJ ;
10588	–	PyObject * obj0 = 0 ;
10589	–	PyObject * obj1 = 0 ;
10590	–	PyObject * obj2 = 0 ;
10591	–	PyObject * obj3 = 0 ;
10592	–	PyObject * obj4 = 0 ;
10593	–	PyObject * obj5 = 0 ;
10594	–	PyObject * obj6 = 0 ;
10595	–	PyObject * obj7 = 0 ;
10596	–	PyObject * obj8 = 0 ;
10597	–
10598	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
10599	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10600	–	if (!SWIG_IsOK(res1)) {
10601	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
10602	–	}
10603	–	arg1 = reinterpret_cast< BossSession * >(argp1);
10604	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
10605	–	if (!SWIG_IsOK(ecode2)) {
10606	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
10607	–	}
10608	–	arg2 = static_cast< int >(val2);
10609	–	{
10610	–	std::string *ptr = (std::string *)0;
10611	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10612	–	if (!SWIG_IsOK(res3)) {
10613	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10614	–	}
10615	–	if (!ptr) {
10616	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10617	–	}
10618	–	arg3 = ptr;
10619	–	}
10620	–	{
10621	–	std::string *ptr = (std::string *)0;
10622	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
10623	–	if (!SWIG_IsOK(res4)) {
10624	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10625	–	}
10626	–	if (!ptr) {
10627	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10628	–	}
10629	–	arg4 = ptr;
10630	–	}
10631	–	{
10632	–	std::string *ptr = (std::string *)0;
10633	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
10634	–	if (!SWIG_IsOK(res5)) {
10635	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10636	–	}
10637	–	if (!ptr) {
10638	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "5"" of type '" "std::string const &""'");
10639	–	}
10640	–	arg5 = ptr;
10641	–	}
10642	–	{
10643	–	std::string *ptr = (std::string *)0;
10644	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
10645	–	if (!SWIG_IsOK(res) || !ptr) {
10646	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "6"" of type '" "std::string""'");
10647	–	}
10648	–	arg6 = *ptr;
10649	–	if (SWIG_IsNewObj(res)) delete ptr;
10650	–	}
10651	–	{
10652	–	std::string *ptr = (std::string *)0;
10653	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
10654	–	if (!SWIG_IsOK(res) || !ptr) {
10655	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "7"" of type '" "std::string""'");
10656	–	}
10657	–	arg7 = *ptr;
10658	–	if (SWIG_IsNewObj(res)) delete ptr;
10659	–	}
10660	–	{
10661	–	std::string *ptr = (std::string *)0;
10662	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
10663	–	if (!SWIG_IsOK(res) || !ptr) {
10664	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "8"" of type '" "std::string""'");
10665	–	}
10666	–	arg8 = *ptr;
10667	–	if (SWIG_IsNewObj(res)) delete ptr;
10668	–	}
10669	–	{
10670	–	std::string *ptr = (std::string *)0;
10671	–	int res = SWIG_AsPtr_std_string(obj8, &ptr);
10672	–	if (!SWIG_IsOK(res) || !ptr) {
10673	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_schedulerQuery" "', argument " "9"" of type '" "std::string""'");
10674	–	}
10675	–	arg9 = *ptr;
10676	–	if (SWIG_IsNewObj(res)) delete ptr;
10677	–	}
10678	–	{
10679	–	try {
10680	–	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
10681	–	} catch (const std::exception& e) {
10682	–	SWIG_exception(SWIG_RuntimeError, e.what());
10683	–	}
10684	–	}
10685	–	resultobj = SWIG_Py_Void();
10686	–	if (SWIG_IsNewObj(res3)) delete arg3;
10687	–	if (SWIG_IsNewObj(res4)) delete arg4;
10688	–	if (SWIG_IsNewObj(res5)) delete arg5;
10689	–	return resultobj;
10690	–	fail:
10691	–	if (SWIG_IsNewObj(res3)) delete arg3;
10692	–	if (SWIG_IsNewObj(res4)) delete arg4;
10693	–	if (SWIG_IsNewObj(res5)) delete arg5;
10694	–	return NULL;
10695	–	}
10696	–
10697	–
10698	–	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10699	–	PyObject *resultobj = 0;
10700	–	BossSession *arg1 = (BossSession *) 0 ;
10701	–	int arg2 ;
10702	–	std::string *arg3 = 0 ;
10703	–	std::string *arg4 = 0 ;
10704	–	std::string *arg5 = 0 ;
10705	–	std::string arg6 ;
10706	–	std::string arg7 ;
10707	–	std::string arg8 ;
10708	–	void *argp1 = 0 ;
10709	–	int res1 = 0 ;
10710	–	int val2 ;
10711	–	int ecode2 = 0 ;
10712	–	int res3 = SWIG_OLDOBJ ;
10713	–	int res4 = SWIG_OLDOBJ ;
10714	–	int res5 = SWIG_OLDOBJ ;
10715	–	PyObject * obj0 = 0 ;
10716	–	PyObject * obj1 = 0 ;
10717	–	PyObject * obj2 = 0 ;
10718	–	PyObject * obj3 = 0 ;
10719	–	PyObject * obj4 = 0 ;
10720	–	PyObject * obj5 = 0 ;
10721	–	PyObject * obj6 = 0 ;
10722	–	PyObject * obj7 = 0 ;
10723	–
10724	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossSession_schedulerQuery",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
10725	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
10726	–	if (!SWIG_IsOK(res1)) {
10727	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedulerQuery" "', argument " "1"" of type '" "BossSession *""'");
10728	–	}
10729	–	arg1 = reinterpret_cast< BossSession * >(argp1);
10730	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
10731	–	if (!SWIG_IsOK(ecode2)) {
10732	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_schedulerQuery" "', argument " "2"" of type '" "int""'");
10733	–	}
10734	–	arg2 = static_cast< int >(val2);
10735	–	{
10736	–	std::string *ptr = (std::string *)0;
10737	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
10738	–	if (!SWIG_IsOK(res3)) {
10739	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10740	–	}
10741	–	if (!ptr) {
10742	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "3"" of type '" "std::string const &""'");
10743	–	}
10744	–	arg3 = ptr;
10745	–	}
10746	–	{
10747	–	std::string *ptr = (std::string *)0;
10748	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
10749	–	if (!SWIG_IsOK(res4)) {
10750	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
10751	–	}
10752	–	if (!ptr) {
10753	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedulerQuery" "', argument " "4"" of type '" "std::string const &""'");
2941		}
2942	<	arg4 = ptr;
2943	<	}
2944	<	{
2945	<	std::string *ptr = (std::string *)0;
2946	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
2947	<	if (!SWIG_IsOK(res5)) {
2948	<	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());
2942	>	{
2943	>	try {
2944	>	result = (arg1)->listMatch((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,(std::string const &)*arg6);
2945	>
2946	>	}catch (const std::exception& e) {
2947	>	SWIG_exception(SWIG_RuntimeError, e.what());
2948	>	}
2949		}
2950	<	}
2951	<	resultobj = SWIG_Py_Void();
2952	<	return resultobj;
2953	<	fail:
2954	<	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());
2950	>	{
2951	>	resultobj = PyTuple_New((&result)->size());
2952	>	for (unsigned int i=0; i<(&result)->size(); i++)
2953	>	PyTuple_SetItem(resultobj,i,
2954	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
2955		}
2956	<	}
2957	<	resultobj = SWIG_Py_Void();
2958	<	return resultobj;
11278	<	fail:
11279	<	return NULL;
2956	>	return resultobj;
2957	>	fail:
2958	>	return NULL;
2959		}
2960
2961
2962	<	SWIGINTERN PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
2963	<	int argc;
2964	<	PyObject *argv[10];
2965	<	int ii;
2966	<
2967	<	if (!PyTuple_Check(args)) SWIG_fail;
2968	<	argc = PyObject_Length(args);
2969	<	for (ii = 0; (ii < argc) && (ii < 9); ii++) {
2970	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
2971	<	}
2972	<	if (argc == 1) {
2973	<	int _v;
2974	<	void *vptr = 0;
2975	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2976	<	_v = SWIG_CheckState(res);
2977	<	if (_v) {
2978	<	return _wrap_BossSession_schedulerQuery__SWIG_8(self, args);
2979	<	}
2980	<	}
2981	<	if (argc == 2) {
2982	<	int _v;
2983	<	void *vptr = 0;
2984	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
2985	<	_v = SWIG_CheckState(res);
2986	<	if (_v) {
2987	<	{
2988	<	int res = SWIG_AsVal_int(argv[1], NULL);
2989	<	_v = SWIG_CheckState(res);
2990	<	}
2991	<	if (_v) {
2992	<	return _wrap_BossSession_schedulerQuery__SWIG_7(self, args);
2993	<	}
2994	<	}
2995	<	}
2996	<	if (argc == 3) {
11318	<	int _v;
11319	<	void *vptr = 0;
11320	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11321	<	_v = SWIG_CheckState(res);
11322	<	if (_v) {
11323	<	{
11324	<	int res = SWIG_AsVal_int(argv[1], NULL);
11325	<	_v = SWIG_CheckState(res);
11326	<	}
11327	<	if (_v) {
11328	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11329	<	_v = SWIG_CheckState(res);
11330	<	if (_v) {
11331	<	return _wrap_BossSession_schedulerQuery__SWIG_6(self, args);
11332	<	}
11333	<	}
11334	<	}
11335	<	}
11336	<	if (argc == 4) {
11337	<	int _v;
11338	<	void *vptr = 0;
11339	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11340	<	_v = SWIG_CheckState(res);
11341	<	if (_v) {
11342	<	{
11343	<	int res = SWIG_AsVal_int(argv[1], NULL);
11344	<	_v = SWIG_CheckState(res);
11345	<	}
11346	<	if (_v) {
11347	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11348	<	_v = SWIG_CheckState(res);
11349	<	if (_v) {
11350	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
11351	<	_v = SWIG_CheckState(res);
11352	<	if (_v) {
11353	<	return _wrap_BossSession_schedulerQuery__SWIG_5(self, args);
11354	<	}
11355	<	}
11356	<	}
11357	<	}
11358	<	}
11359	<	if (argc == 5) {
11360	<	int _v;
11361	<	void *vptr = 0;
11362	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
11363	<	_v = SWIG_CheckState(res);
11364	<	if (_v) {
11365	<	{
11366	<	int res = SWIG_AsVal_int(argv[1], NULL);
11367	<	_v = SWIG_CheckState(res);
11368	<	}
11369	<	if (_v) {
11370	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
11371	<	_v = SWIG_CheckState(res);
11372	<	if (_v) {
11373	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
11374	<	_v = SWIG_CheckState(res);
11375	<	if (_v) {
11376	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
11377	<	_v = SWIG_CheckState(res);
11378	<	if (_v) {
11379	<	return _wrap_BossSession_schedulerQuery__SWIG_4(self, args);
2962	>	static PyObject *_wrap_BossSession_schedulerQuery(PyObject *self, PyObject *args) {
2963	>	PyObject *resultobj;
2964	>	BossSession *arg1 = (BossSession *) 0 ;
2965	>	int arg2 = (int) SCHEDULED ;
2966	>	std::string const &arg3_defvalue = "all" ;
2967	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
2968	>	std::string const &arg4_defvalue = "all" ;
2969	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
2970	>	std::string const &arg5_defvalue = "" ;
2971	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
2972	>	std::string arg6 = (std::string) "" ;
2973	>	std::string arg7 = (std::string) "" ;
2974	>	std::string arg8 = (std::string) "" ;
2975	>	std::string arg9 = (std::string) "" ;
2976	>	std::string temp3 ;
2977	>	std::string temp4 ;
2978	>	std::string temp5 ;
2979	>	PyObject * obj0 = 0 ;
2980	>	PyObject * obj2 = 0 ;
2981	>	PyObject * obj3 = 0 ;
2982	>	PyObject * obj4 = 0 ;
2983	>	PyObject * obj5 = 0 ;
2984	>	PyObject * obj6 = 0 ;
2985	>	PyObject * obj7 = 0 ;
2986	>	PyObject * obj8 = 0 ;
2987	>
2988	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossSession_schedulerQuery",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
2989	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
2990	>	if (obj2) {
2991	>	{
2992	>	if (PyString_Check(obj2)) {
2993	>	temp3 = std::string(PyString_AsString(obj2));
2994	>	arg3 = &temp3;
2995	>	}else {
2996	>	SWIG_exception(SWIG_TypeError, "string expected");
2997		}
11381	–	}
2998		}
11383	–	}
2999		}
3000	<	}
3001	<	if (argc == 6) {
3002	<	int _v;
3003	<	void *vptr = 0;
3004	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3005	<	_v = SWIG_CheckState(res);
3006	<	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	<	}
3000	>	if (obj3) {
3001	>	{
3002	>	if (PyString_Check(obj3)) {
3003	>	temp4 = std::string(PyString_AsString(obj3));
3004	>	arg4 = &temp4;
3005	>	}else {
3006	>	SWIG_exception(SWIG_TypeError, "string expected");
3007		}
11412	–	}
3008		}
11414	–	}
3009		}
3010	<	}
3011	<	if (argc == 7) {
3012	<	int _v;
3013	<	void *vptr = 0;
3014	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3015	<	_v = SWIG_CheckState(res);
3016	<	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	<	}
3010	>	if (obj4) {
3011	>	{
3012	>	if (PyString_Check(obj4)) {
3013	>	temp5 = std::string(PyString_AsString(obj4));
3014	>	arg5 = &temp5;
3015	>	}else {
3016	>	SWIG_exception(SWIG_TypeError, "string expected");
3017		}
11447	–	}
3018		}
11449	–	}
3019		}
3020	<	}
3021	<	if (argc == 8) {
3022	<	int _v;
3023	<	void *vptr = 0;
3024	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3025	<	_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	<	}
3020	>	if (obj5) {
3021	>	{
3022	>	if (PyString_Check(obj5))
3023	>	arg6 = std::string(PyString_AsString(obj5));
3024	>	else
3025	>	SWIG_exception(SWIG_TypeError, "string expected");
3026		}
11488	–	}
3027		}
3028	<	}
3029	<	if (argc == 9) {
3030	<	int _v;
3031	<	void *vptr = 0;
3032	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3033	<	_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	<	}
3028	>	if (obj6) {
3029	>	{
3030	>	if (PyString_Check(obj6))
3031	>	arg7 = std::string(PyString_AsString(obj6));
3032	>	else
3033	>	SWIG_exception(SWIG_TypeError, "string expected");
3034		}
11531	–	}
11532	–	}
11533	–	}
11534	–
11535	–	fail:
11536	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_schedulerQuery'");
11537	–	return NULL;
11538	–	}
11539	–
11540	–
11541	–	SWIGINTERN PyObject *_wrap_BossSession_selectTasks__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11542	–	PyObject *resultobj = 0;
11543	–	BossSession *arg1 = (BossSession *) 0 ;
11544	–	std::string *arg2 = 0 ;
11545	–	std::string *arg3 = 0 ;
11546	–	std::string *arg4 = 0 ;
11547	–	std::string *arg5 = 0 ;
11548	–	std::vector<std::string,std::allocator<std::string > > result;
11549	–	void *argp1 = 0 ;
11550	–	int res1 = 0 ;
11551	–	int res2 = SWIG_OLDOBJ ;
11552	–	int res3 = SWIG_OLDOBJ ;
11553	–	int res4 = SWIG_OLDOBJ ;
11554	–	int res5 = SWIG_OLDOBJ ;
11555	–	PyObject * obj0 = 0 ;
11556	–	PyObject * obj1 = 0 ;
11557	–	PyObject * obj2 = 0 ;
11558	–	PyObject * obj3 = 0 ;
11559	–	PyObject * obj4 = 0 ;
11560	–
11561	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11562	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11563	–	if (!SWIG_IsOK(res1)) {
11564	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_selectTasks" "', argument " "1"" of type '" "BossSession *""'");
11565	–	}
11566	–	arg1 = reinterpret_cast< BossSession * >(argp1);
11567	–	{
11568	–	std::string *ptr = (std::string *)0;
11569	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11570	–	if (!SWIG_IsOK(res2)) {
11571	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11572	–	}
11573	–	if (!ptr) {
11574	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11575	–	}
11576	–	arg2 = ptr;
11577	–	}
11578	–	{
11579	–	std::string *ptr = (std::string *)0;
11580	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11581	–	if (!SWIG_IsOK(res3)) {
11582	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11583	–	}
11584	–	if (!ptr) {
11585	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11586	–	}
11587	–	arg3 = ptr;
11588	–	}
11589	–	{
11590	–	std::string *ptr = (std::string *)0;
11591	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
11592	–	if (!SWIG_IsOK(res4)) {
11593	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_selectTasks" "', argument " "4"" of type '" "std::string const &""'");
11594	–	}
11595	–	if (!ptr) {
11596	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "4"" of type '" "std::string const &""'");
11597	–	}
11598	–	arg4 = ptr;
11599	–	}
11600	–	{
11601	–	std::string *ptr = (std::string *)0;
11602	–	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
11603	–	if (!SWIG_IsOK(res5)) {
11604	–	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_selectTasks" "', argument " "5"" of type '" "std::string const &""'");
11605	–	}
11606	–	if (!ptr) {
11607	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "5"" of type '" "std::string const &""'");
11608	–	}
11609	–	arg5 = ptr;
11610	–	}
11611	–	{
11612	–	try {
11613	–	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
11614	–	} catch (const std::exception& e) {
11615	–	SWIG_exception(SWIG_RuntimeError, e.what());
11616	–	}
11617	–	}
11618	–	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
11619	–	if (SWIG_IsNewObj(res2)) delete arg2;
11620	–	if (SWIG_IsNewObj(res3)) delete arg3;
11621	–	if (SWIG_IsNewObj(res4)) delete arg4;
11622	–	if (SWIG_IsNewObj(res5)) delete arg5;
11623	–	return resultobj;
11624	–	fail:
11625	–	if (SWIG_IsNewObj(res2)) delete arg2;
11626	–	if (SWIG_IsNewObj(res3)) delete arg3;
11627	–	if (SWIG_IsNewObj(res4)) delete arg4;
11628	–	if (SWIG_IsNewObj(res5)) delete arg5;
11629	–	return NULL;
11630	–	}
11631	–
11632	–
11633	–	SWIGINTERN PyObject *_wrap_BossSession_selectTasks__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11634	–	PyObject *resultobj = 0;
11635	–	BossSession *arg1 = (BossSession *) 0 ;
11636	–	std::string *arg2 = 0 ;
11637	–	std::string *arg3 = 0 ;
11638	–	std::string *arg4 = 0 ;
11639	–	std::vector<std::string,std::allocator<std::string > > result;
11640	–	void *argp1 = 0 ;
11641	–	int res1 = 0 ;
11642	–	int res2 = SWIG_OLDOBJ ;
11643	–	int res3 = SWIG_OLDOBJ ;
11644	–	int res4 = SWIG_OLDOBJ ;
11645	–	PyObject * obj0 = 0 ;
11646	–	PyObject * obj1 = 0 ;
11647	–	PyObject * obj2 = 0 ;
11648	–	PyObject * obj3 = 0 ;
11649	–
11650	–	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11651	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11652	–	if (!SWIG_IsOK(res1)) {
11653	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_selectTasks" "', argument " "1"" of type '" "BossSession *""'");
11654	–	}
11655	–	arg1 = reinterpret_cast< BossSession * >(argp1);
11656	–	{
11657	–	std::string *ptr = (std::string *)0;
11658	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
11659	–	if (!SWIG_IsOK(res2)) {
11660	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11661	–	}
11662	–	if (!ptr) {
11663	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "2"" of type '" "std::string const &""'");
11664	–	}
11665	–	arg2 = ptr;
11666	–	}
11667	–	{
11668	–	std::string *ptr = (std::string *)0;
11669	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11670	–	if (!SWIG_IsOK(res3)) {
11671	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
11672	–	}
11673	–	if (!ptr) {
11674	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "3"" of type '" "std::string const &""'");
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 &""'");
3035		}
3036	<	if (!ptr) {
3037	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_selectTasks" "', argument " "4"" of type '" "std::string const &""'");
3038	<	}
3039	<	arg4 = ptr;
3040	<	}
3041	<	{
3042	<	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 &""'");
3036	>	if (obj7) {
3037	>	{
3038	>	if (PyString_Check(obj7))
3039	>	arg8 = std::string(PyString_AsString(obj7));
3040	>	else
3041	>	SWIG_exception(SWIG_TypeError, "string expected");
3042	>	}
3043		}
3044	<	arg2 = ptr;
3045	<	}
3046	<	{
3047	<	try {
3048	<	result = (arg1)->selectTasks((std::string const &)*arg2);
3049	<	} catch (const std::exception& e) {
3050	<	SWIG_exception(SWIG_RuntimeError, e.what());
3044	>	if (obj8) {
3045	>	{
3046	>	if (PyString_Check(obj8))
3047	>	arg9 = std::string(PyString_AsString(obj8));
3048	>	else
3049	>	SWIG_exception(SWIG_TypeError, "string expected");
3050	>	}
3051		}
3052	<	}
3053	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
3054	<	if (SWIG_IsNewObj(res2)) delete arg2;
3055	<	return resultobj;
3056	<	fail:
3057	<	if (SWIG_IsNewObj(res2)) delete arg2;
3058	<	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());
3052	>	{
3053	>	try {
3054	>	(arg1)->schedulerQuery(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3055	>
3056	>	}catch (const std::exception& e) {
3057	>	SWIG_exception(SWIG_RuntimeError, e.what());
3058	>	}
3059		}
3060	<	}
3061	<	resultobj = swig::from(static_cast< std::vector<std::string,std::allocator<std::string > > >(result));
3062	<	return resultobj;
3063	<	fail:
11837	<	return NULL;
3060	>	Py_INCREF(Py_None); resultobj = Py_None;
3061	>	return resultobj;
3062	>	fail:
3063	>	return NULL;
3064		}
3065
3066
3067	<	SWIGINTERN PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3068	<	int argc;
3069	<	PyObject *argv[6];
3070	<	int ii;
3071	<
3072	<	if (!PyTuple_Check(args)) SWIG_fail;
3073	<	argc = PyObject_Length(args);
3074	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
3075	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3076	<	}
3077	<	if (argc == 1) {
3078	<	int _v;
3079	<	void *vptr = 0;
3080	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3081	<	_v = SWIG_CheckState(res);
3082	<	if (_v) {
3083	<	return _wrap_BossSession_selectTasks__SWIG_4(self, args);
3084	<	}
3085	<	}
3086	<	if (argc == 2) {
3087	<	int _v;
3088	<	void *vptr = 0;
3089	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3090	<	_v = SWIG_CheckState(res);
3091	<	if (_v) {
3092	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3093	<	_v = SWIG_CheckState(res);
3094	<	if (_v) {
3095	<	return _wrap_BossSession_selectTasks__SWIG_3(self, args);
3096	<	}
3097	<	}
3098	<	}
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);
3067	>	static PyObject *_wrap_BossSession_selectTasks(PyObject *self, PyObject *args) {
3068	>	PyObject *resultobj;
3069	>	BossSession *arg1 = (BossSession *) 0 ;
3070	>	std::string const &arg2_defvalue = "all" ;
3071	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
3072	>	std::string const &arg3_defvalue = "" ;
3073	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3074	>	std::string const &arg4_defvalue = "" ;
3075	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3076	>	std::string const &arg5_defvalue = "" ;
3077	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3078	>	std::vector<std::string > result;
3079	>	std::string temp2 ;
3080	>	std::string temp3 ;
3081	>	std::string temp4 ;
3082	>	std::string temp5 ;
3083	>	PyObject * obj0 = 0 ;
3084	>	PyObject * obj1 = 0 ;
3085	>	PyObject * obj2 = 0 ;
3086	>	PyObject * obj3 = 0 ;
3087	>	PyObject * obj4 = 0 ;
3088	>
3089	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossSession_selectTasks",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
3090	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3091	>	if (obj1) {
3092	>	{
3093	>	if (PyString_Check(obj1)) {
3094	>	temp2 = std::string(PyString_AsString(obj1));
3095	>	arg2 = &temp2;
3096	>	}else {
3097	>	SWIG_exception(SWIG_TypeError, "string expected");
3098	>	}
3099		}
11887	–	}
3100		}
3101	<	}
3102	<	if (argc == 4) {
3103	<	int _v;
3104	<	void *vptr = 0;
3105	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3106	<	_v = SWIG_CheckState(res);
3107	<	if (_v) {
3108	<	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	<	}
3101	>	if (obj2) {
3102	>	{
3103	>	if (PyString_Check(obj2)) {
3104	>	temp3 = std::string(PyString_AsString(obj2));
3105	>	arg3 = &temp3;
3106	>	}else {
3107	>	SWIG_exception(SWIG_TypeError, "string expected");
3108	>	}
3109		}
11908	–	}
3110		}
3111	<	}
3112	<	if (argc == 5) {
3113	<	int _v;
3114	<	void *vptr = 0;
3115	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3116	<	_v = SWIG_CheckState(res);
3117	<	if (_v) {
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);
3111	>	if (obj3) {
3112	>	{
3113	>	if (PyString_Check(obj3)) {
3114	>	temp4 = std::string(PyString_AsString(obj3));
3115	>	arg4 = &temp4;
3116	>	}else {
3117	>	SWIG_exception(SWIG_TypeError, "string expected");
3118		}
11931	–	}
3119		}
11933	–	}
11934	–	}
11935	–	}
11936	–
11937	–	fail:
11938	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_selectTasks'");
11939	–	return NULL;
11940	–	}
11941	–
11942	–
11943	–	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11944	–	PyObject *resultobj = 0;
11945	–	BossSession *arg1 = (BossSession *) 0 ;
11946	–	int arg2 ;
11947	–	std::string *arg3 = 0 ;
11948	–	std::string *arg4 = 0 ;
11949	–	std::string *arg5 = 0 ;
11950	–	std::string arg6 ;
11951	–	std::string arg7 ;
11952	–	std::string arg8 ;
11953	–	std::string arg9 ;
11954	–	bool arg10 ;
11955	–	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
11956	–	void *argp1 = 0 ;
11957	–	int res1 = 0 ;
11958	–	int val2 ;
11959	–	int ecode2 = 0 ;
11960	–	int res3 = SWIG_OLDOBJ ;
11961	–	int res4 = SWIG_OLDOBJ ;
11962	–	int res5 = SWIG_OLDOBJ ;
11963	–	bool val10 ;
11964	–	int ecode10 = 0 ;
11965	–	PyObject * obj0 = 0 ;
11966	–	PyObject * obj1 = 0 ;
11967	–	PyObject * obj2 = 0 ;
11968	–	PyObject * obj3 = 0 ;
11969	–	PyObject * obj4 = 0 ;
11970	–	PyObject * obj5 = 0 ;
11971	–	PyObject * obj6 = 0 ;
11972	–	PyObject * obj7 = 0 ;
11973	–	PyObject * obj8 = 0 ;
11974	–	PyObject * obj9 = 0 ;
11975	–
11976	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:BossSession_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
11977	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
11978	–	if (!SWIG_IsOK(res1)) {
11979	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
11980	–	}
11981	–	arg1 = reinterpret_cast< BossSession * >(argp1);
11982	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
11983	–	if (!SWIG_IsOK(ecode2)) {
11984	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
11985	–	}
11986	–	arg2 = static_cast< int >(val2);
11987	–	{
11988	–	std::string *ptr = (std::string *)0;
11989	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
11990	–	if (!SWIG_IsOK(res3)) {
11991	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
11992	–	}
11993	–	if (!ptr) {
11994	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
11995	–	}
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	–	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	–	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	–	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	–	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	–	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 &""'");
3120		}
3121	<	if (!ptr) {
3122	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "5"" of type '" "std::string const &""'");
3123	<	}
3124	<	arg5 = ptr;
3125	<	}
3126	<	{
3127	<	std::string *ptr = (std::string *)0;
3128	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
3129	<	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	<	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	<	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	<	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	<	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	<	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	<	if (!ptr) {
12652	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12653	<	}
12654	<	arg3 = ptr;
12655	<	}
12656	<	{
12657	<	std::string *ptr = (std::string *)0;
12658	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
12659	<	if (!SWIG_IsOK(res4)) {
12660	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12661	<	}
12662	<	if (!ptr) {
12663	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "4"" of type '" "std::string const &""'");
12664	<	}
12665	<	arg4 = ptr;
12666	<	}
12667	<	{
12668	<	try {
12669	<	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
12670	<	} catch (const std::exception& e) {
12671	<	SWIG_exception(SWIG_RuntimeError, e.what());
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	<	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	<	if (!ptr) {
12718	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_query" "', argument " "3"" of type '" "std::string const &""'");
12719	<	}
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());
3121	>	if (obj4) {
3122	>	{
3123	>	if (PyString_Check(obj4)) {
3124	>	temp5 = std::string(PyString_AsString(obj4));
3125	>	arg5 = &temp5;
3126	>	}else {
3127	>	SWIG_exception(SWIG_TypeError, "string expected");
3128	>	}
3129	>	}
3130		}
3131	<	}
3132	<	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 );
3133	<	if (SWIG_IsNewObj(res3)) delete arg3;
3134	<	return resultobj;
3135	<	fail:
3136	<	if (SWIG_IsNewObj(res3)) delete arg3;
3137	<	return NULL;
12735	<	}
12736	<
12737	<
12738	<	SWIGINTERN PyObject *_wrap_BossSession_query__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12739	<	PyObject *resultobj = 0;
12740	<	BossSession *arg1 = (BossSession *) 0 ;
12741	<	int arg2 ;
12742	<	SwigValueWrapper<std::vector<BossTask *,std::allocator<BossTask * > > > result;
12743	<	void *argp1 = 0 ;
12744	<	int res1 = 0 ;
12745	<	int val2 ;
12746	<	int ecode2 = 0 ;
12747	<	PyObject * obj0 = 0 ;
12748	<	PyObject * obj1 = 0 ;
12749	<
12750	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossSession_query",&obj0,&obj1)) SWIG_fail;
12751	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
12752	<	if (!SWIG_IsOK(res1)) {
12753	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_query" "', argument " "1"" of type '" "BossSession *""'");
12754	<	}
12755	<	arg1 = reinterpret_cast< BossSession * >(argp1);
12756	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
12757	<	if (!SWIG_IsOK(ecode2)) {
12758	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_query" "', argument " "2"" of type '" "int""'");
12759	<	}
12760	<	arg2 = static_cast< int >(val2);
12761	<	{
12762	<	try {
12763	<	result = (arg1)->query(arg2);
12764	<	} catch (const std::exception& e) {
12765	<	SWIG_exception(SWIG_RuntimeError, e.what());
3131	>	{
3132	>	try {
3133	>	result = (arg1)->selectTasks((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
3134	>
3135	>	}catch (const std::exception& e) {
3136	>	SWIG_exception(SWIG_RuntimeError, e.what());
3137	>	}
3138		}
3139	<	}
3140	<	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 );
3141	<	return resultobj;
3142	<	fail:
3143	<	return NULL;
12772	<	}
12773	<
12774	<
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());
3139	>	{
3140	>	resultobj = PyTuple_New((&result)->size());
3141	>	for (unsigned int i=0; i<(&result)->size(); i++)
3142	>	PyTuple_SetItem(resultobj,i,
3143	>	SwigString_FromString(((std::vector<std::string > &)result)[i]));
3144		}
3145	<	}
3146	<	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 );
3147	<	return resultobj;
12798	<	fail:
12799	<	return NULL;
3145	>	return resultobj;
3146	>	fail:
3147	>	return NULL;
3148		}
3149
3150
3151	<	SWIGINTERN PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3152	<	int argc;
3153	<	PyObject *argv[11];
3154	<	int ii;
3155	<
3156	<	if (!PyTuple_Check(args)) SWIG_fail;
3157	<	argc = PyObject_Length(args);
3158	<	for (ii = 0; (ii < argc) && (ii < 10); ii++) {
3159	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3160	<	}
3161	<	if (argc == 1) {
3162	<	int _v;
3163	<	void *vptr = 0;
3164	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3165	<	_v = SWIG_CheckState(res);
3166	<	if (_v) {
3167	<	return _wrap_BossSession_query__SWIG_9(self, args);
3168	<	}
3169	<	}
3170	<	if (argc == 2) {
3171	<	int _v;
3172	<	void *vptr = 0;
3173	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3174	<	_v = SWIG_CheckState(res);
3175	<	if (_v) {
3176	<	{
3177	<	int res = SWIG_AsVal_int(argv[1], NULL);
3178	<	_v = SWIG_CheckState(res);
3179	<	}
3180	<	if (_v) {
3181	<	return _wrap_BossSession_query__SWIG_8(self, args);
3182	<	}
3183	<	}
3184	<	}
3185	<	if (argc == 3) {
3186	<	int _v;
3187	<	void *vptr = 0;
3188	<	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);
3151	>	static PyObject *_wrap_BossSession_query(PyObject *self, PyObject *args) {
3152	>	PyObject *resultobj;
3153	>	BossSession *arg1 = (BossSession *) 0 ;
3154	>	int arg2 = (int) SCHEDULED ;
3155	>	std::string const &arg3_defvalue = "all" ;
3156	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
3157	>	std::string const &arg4_defvalue = "all" ;
3158	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
3159	>	std::string const &arg5_defvalue = "" ;
3160	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
3161	>	std::string arg6 = (std::string) "" ;
3162	>	std::string arg7 = (std::string) "" ;
3163	>	std::string arg8 = (std::string) "" ;
3164	>	std::string arg9 = (std::string) "" ;
3165	>	bool arg10 = (bool) false ;
3166	>	SwigValueWrapper< std::vector<BossTask * > > result;
3167	>	std::string temp3 ;
3168	>	std::string temp4 ;
3169	>	std::string temp5 ;
3170	>	PyObject * obj0 = 0 ;
3171	>	PyObject * obj2 = 0 ;
3172	>	PyObject * obj3 = 0 ;
3173	>	PyObject * obj4 = 0 ;
3174	>	PyObject * obj5 = 0 ;
3175	>	PyObject * obj6 = 0 ;
3176	>	PyObject * obj7 = 0 ;
3177	>	PyObject * obj8 = 0 ;
3178	>	PyObject * obj9 = 0 ;
3179	>
3180	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOOO:BossSession_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) goto fail;
3181	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3182	>	if (obj2) {
3183	>	{
3184	>	if (PyString_Check(obj2)) {
3185	>	temp3 = std::string(PyString_AsString(obj2));
3186	>	arg3 = &temp3;
3187	>	}else {
3188	>	SWIG_exception(SWIG_TypeError, "string expected");
3189		}
12901	–	}
3190		}
12903	–	}
3191		}
3192	<	}
3193	<	if (argc == 6) {
3194	<	int _v;
3195	<	void *vptr = 0;
3196	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3197	<	_v = SWIG_CheckState(res);
3198	<	if (_v) {
12912	<	{
12913	<	int res = SWIG_AsVal_int(argv[1], NULL);
12914	<	_v = SWIG_CheckState(res);
12915	<	}
12916	<	if (_v) {
12917	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
12918	<	_v = SWIG_CheckState(res);
12919	<	if (_v) {
12920	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
12921	<	_v = SWIG_CheckState(res);
12922	<	if (_v) {
12923	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
12924	<	_v = SWIG_CheckState(res);
12925	<	if (_v) {
12926	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
12927	<	_v = SWIG_CheckState(res);
12928	<	if (_v) {
12929	<	return _wrap_BossSession_query__SWIG_4(self, args);
12930	<	}
3192	>	if (obj3) {
3193	>	{
3194	>	if (PyString_Check(obj3)) {
3195	>	temp4 = std::string(PyString_AsString(obj3));
3196	>	arg4 = &temp4;
3197	>	}else {
3198	>	SWIG_exception(SWIG_TypeError, "string expected");
3199		}
12932	–	}
3200		}
12934	–	}
3201		}
3202	<	}
3203	<	if (argc == 7) {
3204	<	int _v;
3205	<	void *vptr = 0;
3206	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3207	<	_v = SWIG_CheckState(res);
3208	<	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	<	}
3202	>	if (obj4) {
3203	>	{
3204	>	if (PyString_Check(obj4)) {
3205	>	temp5 = std::string(PyString_AsString(obj4));
3206	>	arg5 = &temp5;
3207	>	}else {
3208	>	SWIG_exception(SWIG_TypeError, "string expected");
3209		}
12967	–	}
3210		}
12969	–	}
3211		}
3212	<	}
3213	<	if (argc == 8) {
3214	<	int _v;
3215	<	void *vptr = 0;
3216	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3217	<	_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	<	}
3212	>	if (obj5) {
3213	>	{
3214	>	if (PyString_Check(obj5))
3215	>	arg6 = std::string(PyString_AsString(obj5));
3216	>	else
3217	>	SWIG_exception(SWIG_TypeError, "string expected");
3218		}
13008	–	}
3219		}
3220	<	}
3221	<	if (argc == 9) {
3222	<	int _v;
3223	<	void *vptr = 0;
3224	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3225	<	_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	<	}
3220	>	if (obj6) {
3221	>	{
3222	>	if (PyString_Check(obj6))
3223	>	arg7 = std::string(PyString_AsString(obj6));
3224	>	else
3225	>	SWIG_exception(SWIG_TypeError, "string expected");
3226		}
13051	–	}
3227		}
3228	<	}
3229	<	if (argc == 10) {
3230	<	int _v;
3231	<	void *vptr = 0;
3232	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3233	<	_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	<	}
3228	>	if (obj7) {
3229	>	{
3230	>	if (PyString_Check(obj7))
3231	>	arg8 = std::string(PyString_AsString(obj7));
3232	>	else
3233	>	SWIG_exception(SWIG_TypeError, "string expected");
3234		}
13100	–	}
3235		}
3236	<	}
3237	<
3238	<	fail:
3239	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_query'");
3240	<	return NULL;
3241	<	}
3242	<
13109	<
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	<	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());
3236	>	if (obj8) {
3237	>	{
3238	>	if (PyString_Check(obj8))
3239	>	arg9 = std::string(PyString_AsString(obj8));
3240	>	else
3241	>	SWIG_exception(SWIG_TypeError, "string expected");
3242	>	}
3243		}
3244	<	}
3245	<	resultobj = result;
3246	<	return resultobj;
13173	<	fail:
13174	<	return NULL;
13175	<	}
13176	<
13177	<
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());
3244	>	if (obj9) {
3245	>	arg10 = PyInt_AsLong(obj9) ? true : false;
3246	>	if (PyErr_Occurred()) SWIG_fail;
3247		}
3248	<	}
3249	<	resultobj = result;
3250	<	return resultobj;
3251	<	fail:
3252	<	return NULL;
3253	<	}
3254	<
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());
3248	>	{
3249	>	try {
3250	>	result = (arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9,arg10);
3251	>
3252	>	}catch (const std::exception& e) {
3253	>	SWIG_exception(SWIG_RuntimeError, e.what());
3254	>	}
3255		}
3256	<	}
3257	<	resultobj = result;
3258	<	return resultobj;
3259	<	fail:
13230	<	return NULL;
13231	<	}
13232	<
13233	<
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());
3256	>	{
3257	>	std::vector<BossTask * > * resultptr;
3258	>	resultptr = new std::vector<BossTask * >((std::vector<BossTask * > &) result);
3259	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTBossTask_p_t, 1);
3260		}
3261	<	}
3262	<	resultobj = result;
3263	<	return resultobj;
13257	<	fail:
13258	<	return NULL;
3261	>	return resultobj;
3262	>	fail:
3263	>	return NULL;
3264		}
3265
3266
3267	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3268	<	PyObject *resultobj = 0;
3269	<	BossSession *arg1 = (BossSession *) 0 ;
3270	<	std::string *arg2 = 0 ;
3271	<	std::string *arg3 = 0 ;
3272	<	std::string *arg4 = 0 ;
3273	<	std::string *arg5 = 0 ;
3274	<	bool arg6 ;
3275	<	PyObject *result = 0 ;
3276	<	void *argp1 = 0 ;
3277	<	int res1 = 0 ;
3278	<	int res2 = SWIG_OLDOBJ ;
3279	<	int res3 = SWIG_OLDOBJ ;
3280	<	int res4 = SWIG_OLDOBJ ;
3281	<	int res5 = SWIG_OLDOBJ ;
3282	<	bool val6 ;
3283	<	int ecode6 = 0 ;
3284	<	PyObject * obj0 = 0 ;
3285	<	PyObject * obj1 = 0 ;
3286	<	PyObject * obj2 = 0 ;
3287	<	PyObject * obj3 = 0 ;
3288	<	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	<	if (!ptr) {
13299	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13300	<	}
13301	<	arg2 = ptr;
13302	<	}
13303	<	{
13304	<	std::string *ptr = (std::string *)0;
13305	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
13306	<	if (!SWIG_IsOK(res3)) {
13307	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13308	<	}
13309	<	if (!ptr) {
13310	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13311	<	}
13312	<	arg3 = ptr;
13313	<	}
13314	<	{
13315	<	std::string *ptr = (std::string *)0;
13316	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
13317	<	if (!SWIG_IsOK(res4)) {
13318	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedListMatch" "', argument " "4"" of type '" "std::string const &""'");
13319	<	}
13320	<	if (!ptr) {
13321	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "4"" of type '" "std::string const &""'");
13322	<	}
13323	<	arg4 = ptr;
13324	<	}
13325	<	{
13326	<	std::string *ptr = (std::string *)0;
13327	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
13328	<	if (!SWIG_IsOK(res5)) {
13329	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_schedListMatch" "', argument " "5"" of type '" "std::string const &""'");
13330	<	}
13331	<	if (!ptr) {
13332	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "5"" of type '" "std::string const &""'");
13333	<	}
13334	<	arg5 = ptr;
13335	<	}
13336	<	ecode6 = SWIG_AsVal_bool(obj5, &val6);
13337	<	if (!SWIG_IsOK(ecode6)) {
13338	<	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BossSession_schedListMatch" "', argument " "6"" of type '" "bool""'");
13339	<	}
13340	<	arg6 = static_cast< bool >(val6);
13341	<	{
13342	<	try {
13343	<	result = (PyObject *)BossSession_schedListMatch__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
13344	<	} catch (const std::exception& e) {
13345	<	SWIG_exception(SWIG_RuntimeError, e.what());
3267	>	static PyObject * BossSession_swigregister(PyObject *self, PyObject *args) {
3268	>	PyObject *obj;
3269	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3270	>	SWIG_TypeClientData(SWIGTYPE_p_BossSession, obj);
3271	>	Py_INCREF(obj);
3272	>	return Py_BuildValue((char *)"");
3273	>	}
3274	>	static PyObject *_wrap_BossTaskException_key_set(PyObject *self, PyObject *args) {
3275	>	PyObject *resultobj;
3276	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3277	>	char *arg2 ;
3278	>	PyObject * obj0 = 0 ;
3279	>
3280	>	if(!PyArg_ParseTuple(args,(char *)"Os:BossTaskException_key_set",&obj0,&arg2)) goto fail;
3281	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3282	>	{
3283	>	if (arg2) {
3284	>	arg1->key = (char const *) (new char[strlen(arg2)+1]);
3285	>	strcpy((char *) arg1->key,arg2);
3286	>	}else {
3287	>	arg1->key = 0;
3288	>	}
3289		}
3290	<	}
3291	<	resultobj = result;
3292	<	if (SWIG_IsNewObj(res2)) delete arg2;
3293	<	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;
3290	>	Py_INCREF(Py_None); resultobj = Py_None;
3291	>	return resultobj;
3292	>	fail:
3293	>	return NULL;
3294		}
3295
3296
3297	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3298	<	PyObject *resultobj = 0;
3299	<	BossSession *arg1 = (BossSession *) 0 ;
3300	<	std::string *arg2 = 0 ;
3301	<	std::string *arg3 = 0 ;
3302	<	std::string *arg4 = 0 ;
3303	<	std::string *arg5 = 0 ;
3304	<	PyObject *result = 0 ;
3305	<	void *argp1 = 0 ;
3306	<	int res1 = 0 ;
3307	<	int res2 = SWIG_OLDOBJ ;
3308	<	int res3 = SWIG_OLDOBJ ;
3309	<	int res4 = SWIG_OLDOBJ ;
3310	<	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	<	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;
3297	>	static PyObject *_wrap_BossTaskException_key_get(PyObject *self, PyObject *args) {
3298	>	PyObject *resultobj;
3299	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3300	>	char *result;
3301	>	PyObject * obj0 = 0 ;
3302	>
3303	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) goto fail;
3304	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3305	>	result = (char *) ((arg1)->key);
3306	>
3307	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3308	>	return resultobj;
3309	>	fail:
3310	>	return NULL;
3311		}
3312
3313
3314	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3315	<	PyObject *resultobj = 0;
3316	<	BossSession *arg1 = (BossSession *) 0 ;
3317	<	std::string *arg2 = 0 ;
3318	<	std::string *arg3 = 0 ;
3319	<	std::string *arg4 = 0 ;
3320	<	PyObject *result = 0 ;
3321	<	void *argp1 = 0 ;
3322	<	int res1 = 0 ;
3323	<	int res2 = SWIG_OLDOBJ ;
3324	<	int res3 = SWIG_OLDOBJ ;
3325	<	int res4 = SWIG_OLDOBJ ;
3326	<	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	<	if (!ptr) {
13485	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13486	<	}
13487	<	arg2 = ptr;
13488	<	}
13489	<	{
13490	<	std::string *ptr = (std::string *)0;
13491	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
13492	<	if (!SWIG_IsOK(res3)) {
13493	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13494	<	}
13495	<	if (!ptr) {
13496	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13497	<	}
13498	<	arg3 = ptr;
13499	<	}
13500	<	{
13501	<	std::string *ptr = (std::string *)0;
13502	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
13503	<	if (!SWIG_IsOK(res4)) {
13504	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_schedListMatch" "', argument " "4"" of type '" "std::string const &""'");
13505	<	}
13506	<	if (!ptr) {
13507	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "4"" of type '" "std::string const &""'");
13508	<	}
13509	<	arg4 = ptr;
13510	<	}
13511	<	{
13512	<	try {
13513	<	result = (PyObject *)BossSession_schedListMatch__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
13514	<	} catch (const std::exception& e) {
13515	<	SWIG_exception(SWIG_RuntimeError, e.what());
3314	>	static PyObject *_wrap_new_BossTaskException(PyObject *self, PyObject *args) {
3315	>	PyObject *resultobj;
3316	>	char *arg1 ;
3317	>	BossTaskException *result;
3318	>
3319	>	if(!PyArg_ParseTuple(args,(char *)"s:new_BossTaskException",&arg1)) goto fail;
3320	>	{
3321	>	try {
3322	>	result = (BossTaskException *)new BossTaskException((char const *)arg1);
3323	>
3324	>	}catch (const std::exception& e) {
3325	>	SWIG_exception(SWIG_RuntimeError, e.what());
3326	>	}
3327		}
3328	<	}
3329	<	resultobj = result;
3330	<	if (SWIG_IsNewObj(res2)) delete arg2;
3331	<	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;
3328	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTaskException, 1);
3329	>	return resultobj;
3330	>	fail:
3331	>	return NULL;
3332		}
3333
3334
3335	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3336	<	PyObject *resultobj = 0;
3337	<	BossSession *arg1 = (BossSession *) 0 ;
3338	<	std::string *arg2 = 0 ;
3339	<	std::string *arg3 = 0 ;
3340	<	PyObject *result = 0 ;
3341	<	void *argp1 = 0 ;
3342	<	int res1 = 0 ;
3343	<	int res2 = SWIG_OLDOBJ ;
3344	<	int res3 = SWIG_OLDOBJ ;
3345	<	PyObject * obj0 = 0 ;
3346	<	PyObject * obj1 = 0 ;
3347	<	PyObject * obj2 = 0 ;
3348	<
3349	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossSession_schedListMatch",&obj0,&obj1,&obj2)) SWIG_fail;
13546	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13547	<	if (!SWIG_IsOK(res1)) {
13548	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_schedListMatch" "', argument " "1"" of type '" "BossSession *""'");
13549	<	}
13550	<	arg1 = reinterpret_cast< BossSession * >(argp1);
13551	<	{
13552	<	std::string *ptr = (std::string *)0;
13553	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
13554	<	if (!SWIG_IsOK(res2)) {
13555	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13556	<	}
13557	<	if (!ptr) {
13558	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "2"" of type '" "std::string const &""'");
13559	<	}
13560	<	arg2 = ptr;
13561	<	}
13562	<	{
13563	<	std::string *ptr = (std::string *)0;
13564	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
13565	<	if (!SWIG_IsOK(res3)) {
13566	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
13567	<	}
13568	<	if (!ptr) {
13569	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_schedListMatch" "', argument " "3"" of type '" "std::string const &""'");
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());
3335	>	static PyObject *_wrap_BossTaskException_what(PyObject *self, PyObject *args) {
3336	>	PyObject *resultobj;
3337	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3338	>	char *result;
3339	>	PyObject * obj0 = 0 ;
3340	>
3341	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) goto fail;
3342	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3343	>	{
3344	>	try {
3345	>	result = (char *)((BossTaskException const *)arg1)->what();
3346	>
3347	>	}catch (const std::exception& e) {
3348	>	SWIG_exception(SWIG_RuntimeError, e.what());
3349	>	}
3350		}
3351	<	}
3352	<	resultobj = result;
3353	<	if (SWIG_IsNewObj(res2)) delete arg2;
3354	<	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;
3351	>	resultobj = result ? PyString_FromString(result) : Py_BuildValue((char*)"");
3352	>	return resultobj;
3353	>	fail:
3354	>	return NULL;
3355		}
3356
3357
3358	<	SWIGINTERN PyObject *_wrap_BossSession_schedListMatch(PyObject *self, PyObject *args) {
3359	<	int argc;
3360	<	PyObject *argv[7];
3361	<	int ii;
3362	<
3363	<	if (!PyTuple_Check(args)) SWIG_fail;
3364	<	argc = PyObject_Length(args);
3365	<	for (ii = 0; (ii < argc) && (ii < 6); ii++) {
3366	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3367	<	}
3368	<	if (argc == 3) {
3369	<	int _v;
3370	<	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_BossSession_schedListMatch__SWIG_3(self, args);
13614	<	}
13615	<	}
13616	<	}
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	<	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	<	}
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	<	}
3358	>	static PyObject *_wrap_delete_BossTaskException(PyObject *self, PyObject *args) {
3359	>	PyObject *resultobj;
3360	>	BossTaskException *arg1 = (BossTaskException *) 0 ;
3361	>	PyObject * obj0 = 0 ;
3362	>
3363	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) goto fail;
3364	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTaskException,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3365	>	{
3366	>	try {
3367	>	delete arg1;
3368	>
3369	>	}catch (const std::exception& e) {
3370	>	SWIG_exception(SWIG_RuntimeError, e.what());
3371		}
13661	–	}
3372		}
3373	<	}
3374	<	if (argc == 6) {
3375	<	int _v;
3376	<	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	<	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	<	{
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	<
13696	<	fail:
13697	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_schedListMatch'");
13698	<	return NULL;
3373	>	Py_INCREF(Py_None); resultobj = Py_None;
3374	>	return resultobj;
3375	>	fail:
3376	>	return NULL;
3377		}
3378
3379
3380	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3381	<	PyObject *resultobj = 0;
3382	<	BossSession *arg1 = (BossSession *) 0 ;
3383	<	int arg2 ;
3384	<	std::string *arg3 = 0 ;
3385	<	std::string *arg4 = 0 ;
3386	<	std::string *arg5 = 0 ;
3387	<	std::string arg6 ;
3388	<	std::string arg7 ;
3389	<	std::string arg8 ;
3390	<	std::string arg9 ;
3391	<	bool arg10 ;
3392	<	PyObject *result = 0 ;
3393	<	void *argp1 = 0 ;
3394	<	int res1 = 0 ;
3395	<	int val2 ;
3396	<	int ecode2 = 0 ;
3397	<	int res3 = SWIG_OLDOBJ ;
3398	<	int res4 = SWIG_OLDOBJ ;
3399	<	int res5 = SWIG_OLDOBJ ;
3400	<	bool val10 ;
3401	<	int ecode10 = 0 ;
3402	<	PyObject * obj0 = 0 ;
13725	<	PyObject * obj1 = 0 ;
13726	<	PyObject * obj2 = 0 ;
13727	<	PyObject * obj3 = 0 ;
13728	<	PyObject * obj4 = 0 ;
13729	<	PyObject * obj5 = 0 ;
13730	<	PyObject * obj6 = 0 ;
13731	<	PyObject * obj7 = 0 ;
13732	<	PyObject * obj8 = 0 ;
13733	<	PyObject * obj9 = 0 ;
13734	<
13735	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:BossSession_queryTasks",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
13736	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossSession, 0 |  0 );
13737	<	if (!SWIG_IsOK(res1)) {
13738	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossSession_queryTasks" "', argument " "1"" of type '" "BossSession *""'");
13739	<	}
13740	<	arg1 = reinterpret_cast< BossSession * >(argp1);
13741	<	ecode2 = SWIG_AsVal_int(obj1, &val2);
13742	<	if (!SWIG_IsOK(ecode2)) {
13743	<	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossSession_queryTasks" "', argument " "2"" of type '" "int""'");
13744	<	}
13745	<	arg2 = static_cast< int >(val2);
13746	<	{
13747	<	std::string *ptr = (std::string *)0;
13748	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
13749	<	if (!SWIG_IsOK(res3)) {
13750	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
13751	<	}
13752	<	if (!ptr) {
13753	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
13754	<	}
13755	<	arg3 = ptr;
13756	<	}
13757	<	{
13758	<	std::string *ptr = (std::string *)0;
13759	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
13760	<	if (!SWIG_IsOK(res4)) {
13761	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
13762	<	}
13763	<	if (!ptr) {
13764	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
13765	<	}
13766	<	arg4 = ptr;
13767	<	}
13768	<	{
13769	<	std::string *ptr = (std::string *)0;
13770	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
13771	<	if (!SWIG_IsOK(res5)) {
13772	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
13773	<	}
13774	<	if (!ptr) {
13775	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
13776	<	}
13777	<	arg5 = ptr;
13778	<	}
13779	<	{
13780	<	std::string *ptr = (std::string *)0;
13781	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
13782	<	if (!SWIG_IsOK(res) || !ptr) {
13783	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "6"" of type '" "std::string""'");
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""'");
3380	>	static PyObject * BossTaskException_swigregister(PyObject *self, PyObject *args) {
3381	>	PyObject *obj;
3382	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3383	>	SWIG_TypeClientData(SWIGTYPE_p_BossTaskException, obj);
3384	>	Py_INCREF(obj);
3385	>	return Py_BuildValue((char *)"");
3386	>	}
3387	>	static PyObject *_wrap_BossTask_appendToPyDict(PyObject *self, PyObject *args) {
3388	>	PyObject *resultobj;
3389	>	BossTask *arg1 = (BossTask *) 0 ;
3390	>	PyObject *arg2 = (PyObject *) 0 ;
3391	>	BossAttributeContainer *arg3 = 0 ;
3392	>	PyObject *result;
3393	>	PyObject * obj0 = 0 ;
3394	>	PyObject * obj1 = 0 ;
3395	>	PyObject * obj2 = 0 ;
3396	>
3397	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_appendToPyDict",&obj0,&obj1,&obj2)) goto fail;
3398	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3399	>	arg2 = obj1;
3400	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_BossAttributeContainer,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3401	>	if (arg3 == NULL) {
3402	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3403		}
3404	<	arg9 = *ptr;
3405	<	if (SWIG_IsNewObj(res)) delete ptr;
3406	<	}
3407	<	ecode10 = SWIG_AsVal_bool(obj9, &val10);
3408	<	if (!SWIG_IsOK(ecode10)) {
3409	<	SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "BossSession_queryTasks" "', argument " "10"" of type '" "bool""'");
3410	<	}
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());
3404	>	{
3405	>	try {
3406	>	result = (PyObject *)BossTask_appendToPyDict((BossTask const *)arg1,arg2,(BossAttributeContainer const &)*arg3);
3407	>
3408	>	}catch (const std::exception& e) {
3409	>	SWIG_exception(SWIG_RuntimeError, e.what());
3410	>	}
3411		}
3412	<	}
3413	<	resultobj = result;
3414	<	if (SWIG_IsNewObj(res3)) delete arg3;
3415	<	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;
3412	>	resultobj = result;
3413	>	return resultobj;
3414	>	fail:
3415	>	return NULL;
3416		}
3417
3418
3419	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3420	<	PyObject *resultobj = 0;
3421	<	BossSession *arg1 = (BossSession *) 0 ;
3422	<	int arg2 ;
3423	<	std::string *arg3 = 0 ;
3424	<	std::string *arg4 = 0 ;
3425	<	std::string *arg5 = 0 ;
3426	<	std::string arg6 ;
3427	<	std::string arg7 ;
3428	<	std::string arg8 ;
3429	<	std::string arg9 ;
3430	<	PyObject *result = 0 ;
3431	<	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	<	if (!ptr) {
13887	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
13888	<	}
13889	<	arg3 = ptr;
13890	<	}
13891	<	{
13892	<	std::string *ptr = (std::string *)0;
13893	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
13894	<	if (!SWIG_IsOK(res4)) {
13895	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
13896	<	}
13897	<	if (!ptr) {
13898	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
13899	<	}
13900	<	arg4 = ptr;
13901	<	}
13902	<	{
13903	<	std::string *ptr = (std::string *)0;
13904	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
13905	<	if (!SWIG_IsOK(res5)) {
13906	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
13907	<	}
13908	<	if (!ptr) {
13909	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
13910	<	}
13911	<	arg5 = ptr;
13912	<	}
13913	<	{
13914	<	std::string *ptr = (std::string *)0;
13915	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
13916	<	if (!SWIG_IsOK(res) || !ptr) {
13917	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "6"" of type '" "std::string""'");
13918	<	}
13919	<	arg6 = *ptr;
13920	<	if (SWIG_IsNewObj(res)) delete ptr;
13921	<	}
13922	<	{
13923	<	std::string *ptr = (std::string *)0;
13924	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
13925	<	if (!SWIG_IsOK(res) || !ptr) {
13926	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "7"" of type '" "std::string""'");
13927	<	}
13928	<	arg7 = *ptr;
13929	<	if (SWIG_IsNewObj(res)) delete ptr;
13930	<	}
13931	<	{
13932	<	std::string *ptr = (std::string *)0;
13933	<	int res = SWIG_AsPtr_std_string(obj7, &ptr);
13934	<	if (!SWIG_IsOK(res) || !ptr) {
13935	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "8"" of type '" "std::string""'");
13936	<	}
13937	<	arg8 = *ptr;
13938	<	if (SWIG_IsNewObj(res)) delete ptr;
13939	<	}
13940	<	{
13941	<	std::string *ptr = (std::string *)0;
13942	<	int res = SWIG_AsPtr_std_string(obj8, &ptr);
13943	<	if (!SWIG_IsOK(res) || !ptr) {
13944	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "9"" of type '" "std::string""'");
3419	>	static PyObject *_wrap_BossTask_jobDict(PyObject *self, PyObject *args) {
3420	>	PyObject *resultobj;
3421	>	BossTask *arg1 = (BossTask *) 0 ;
3422	>	std::vector<BossJob * >::const_iterator *arg2 = 0 ;
3423	>	PyObject *result;
3424	>	PyObject * obj0 = 0 ;
3425	>	PyObject * obj1 = 0 ;
3426	>
3427	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobDict",&obj0,&obj1)) goto fail;
3428	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3429	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3430	>	if (arg2 == NULL) {
3431	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3432		}
3433	<	arg9 = *ptr;
3434	<	if (SWIG_IsNewObj(res)) delete ptr;
3435	<	}
3436	<	{
3437	<	try {
3438	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7,arg8,arg9);
3439	<	} catch (const std::exception& e) {
13953	<	SWIG_exception(SWIG_RuntimeError, e.what());
3433	>	{
3434	>	try {
3435	>	result = (PyObject *)BossTask_jobDict((BossTask const *)arg1,*arg2);
3436	>
3437	>	}catch (const std::exception& e) {
3438	>	SWIG_exception(SWIG_RuntimeError, e.what());
3439	>	}
3440		}
3441	<	}
3442	<	resultobj = result;
3443	<	if (SWIG_IsNewObj(res3)) delete arg3;
3444	<	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;
3441	>	resultobj = result;
3442	>	return resultobj;
3443	>	fail:
3444	>	return NULL;
3445		}
3446
3447
3448	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3449	<	PyObject *resultobj = 0;
3450	<	BossSession *arg1 = (BossSession *) 0 ;
3451	<	int arg2 ;
3452	<	std::string *arg3 = 0 ;
3453	<	std::string *arg4 = 0 ;
3454	<	std::string *arg5 = 0 ;
3455	<	std::string arg6 ;
3456	<	std::string arg7 ;
3457	<	std::string arg8 ;
3458	<	PyObject *result = 0 ;
3459	<	void *argp1 = 0 ;
3460	<	int res1 = 0 ;
3461	<	int val2 ;
3462	<	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	<	if (!ptr) {
14014	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14015	<	}
14016	<	arg3 = ptr;
14017	<	}
14018	<	{
14019	<	std::string *ptr = (std::string *)0;
14020	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
14021	<	if (!SWIG_IsOK(res4)) {
14022	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14023	<	}
14024	<	if (!ptr) {
14025	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14026	<	}
14027	<	arg4 = ptr;
14028	<	}
14029	<	{
14030	<	std::string *ptr = (std::string *)0;
14031	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
14032	<	if (!SWIG_IsOK(res5)) {
14033	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14034	<	}
14035	<	if (!ptr) {
14036	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14037	<	}
14038	<	arg5 = ptr;
14039	<	}
14040	<	{
14041	<	std::string *ptr = (std::string *)0;
14042	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
14043	<	if (!SWIG_IsOK(res) || !ptr) {
14044	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "6"" of type '" "std::string""'");
14045	<	}
14046	<	arg6 = *ptr;
14047	<	if (SWIG_IsNewObj(res)) delete ptr;
14048	<	}
14049	<	{
14050	<	std::string *ptr = (std::string *)0;
14051	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
14052	<	if (!SWIG_IsOK(res) || !ptr) {
14053	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "7"" of type '" "std::string""'");
14054	<	}
14055	<	arg7 = *ptr;
14056	<	if (SWIG_IsNewObj(res)) delete ptr;
14057	<	}
14058	<	{
14059	<	std::string *ptr = (std::string *)0;
14060	<	int res = SWIG_AsPtr_std_string(obj7, &ptr);
14061	<	if (!SWIG_IsOK(res) || !ptr) {
14062	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "8"" of type '" "std::string""'");
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());
3448	>	static PyObject *_wrap_BossTask_jobsDict(PyObject *self, PyObject *args) {
3449	>	PyObject *resultobj;
3450	>	BossTask *arg1 = (BossTask *) 0 ;
3451	>	PyObject *result;
3452	>	PyObject * obj0 = 0 ;
3453	>
3454	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsDict",&obj0)) goto fail;
3455	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3456	>	{
3457	>	try {
3458	>	result = (PyObject *)BossTask_jobsDict((BossTask const *)arg1);
3459	>
3460	>	}catch (const std::exception& e) {
3461	>	SWIG_exception(SWIG_RuntimeError, e.what());
3462	>	}
3463		}
3464	<	}
3465	<	resultobj = result;
3466	<	if (SWIG_IsNewObj(res3)) delete arg3;
3467	<	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;
3464	>	resultobj = result;
3465	>	return resultobj;
3466	>	fail:
3467	>	return NULL;
3468		}
3469
3470
3471	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3472	<	PyObject *resultobj = 0;
3473	<	BossSession *arg1 = (BossSession *) 0 ;
3474	<	int arg2 ;
3475	<	std::string *arg3 = 0 ;
3476	<	std::string *arg4 = 0 ;
3477	<	std::string *arg5 = 0 ;
3478	<	std::string arg6 ;
3479	<	std::string arg7 ;
3480	<	PyObject *result = 0 ;
3481	<	void *argp1 = 0 ;
3482	<	int res1 = 0 ;
3483	<	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	<	if (!ptr) {
14130	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14131	<	}
14132	<	arg3 = ptr;
14133	<	}
14134	<	{
14135	<	std::string *ptr = (std::string *)0;
14136	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
14137	<	if (!SWIG_IsOK(res4)) {
14138	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14139	<	}
14140	<	if (!ptr) {
14141	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14142	<	}
14143	<	arg4 = ptr;
14144	<	}
14145	<	{
14146	<	std::string *ptr = (std::string *)0;
14147	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
14148	<	if (!SWIG_IsOK(res5)) {
14149	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14150	<	}
14151	<	if (!ptr) {
14152	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14153	<	}
14154	<	arg5 = ptr;
14155	<	}
14156	<	{
14157	<	std::string *ptr = (std::string *)0;
14158	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
14159	<	if (!SWIG_IsOK(res) || !ptr) {
14160	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "6"" of type '" "std::string""'");
14161	<	}
14162	<	arg6 = *ptr;
14163	<	if (SWIG_IsNewObj(res)) delete ptr;
14164	<	}
14165	<	{
14166	<	std::string *ptr = (std::string *)0;
14167	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
14168	<	if (!SWIG_IsOK(res) || !ptr) {
14169	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "7"" of type '" "std::string""'");
3471	>	static PyObject *_wrap_BossTask_progDict(PyObject *self, PyObject *args) {
3472	>	PyObject *resultobj;
3473	>	BossTask *arg1 = (BossTask *) 0 ;
3474	>	std::vector<std::pair<BossProgram,BossProgramExec > >::const_iterator *arg2 = 0 ;
3475	>	PyObject *result;
3476	>	PyObject * obj0 = 0 ;
3477	>	PyObject * obj1 = 0 ;
3478	>
3479	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_progDict",&obj0,&obj1)) goto fail;
3480	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3481	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3482	>	if (arg2 == NULL) {
3483	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3484		}
3485	<	arg7 = *ptr;
3486	<	if (SWIG_IsNewObj(res)) delete ptr;
3487	<	}
3488	<	{
3489	<	try {
3490	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7);
3491	<	} catch (const std::exception& e) {
14178	<	SWIG_exception(SWIG_RuntimeError, e.what());
3485	>	{
3486	>	try {
3487	>	result = (PyObject *)BossTask_progDict((BossTask const *)arg1,*arg2);
3488	>
3489	>	}catch (const std::exception& e) {
3490	>	SWIG_exception(SWIG_RuntimeError, e.what());
3491	>	}
3492		}
3493	<	}
3494	<	resultobj = result;
3495	<	if (SWIG_IsNewObj(res3)) delete arg3;
3496	<	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;
3493	>	resultobj = result;
3494	>	return resultobj;
3495	>	fail:
3496	>	return NULL;
3497		}
3498
3499
3500	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3501	<	PyObject *resultobj = 0;
3502	<	BossSession *arg1 = (BossSession *) 0 ;
3503	<	int arg2 ;
3504	<	std::string *arg3 = 0 ;
3505	<	std::string *arg4 = 0 ;
3506	<	std::string *arg5 = 0 ;
3507	<	std::string arg6 ;
3508	<	PyObject *result = 0 ;
3509	<	void *argp1 = 0 ;
3510	<	int res1 = 0 ;
3511	<	int val2 ;
3512	<	int ecode2 = 0 ;
3513	<	int res3 = SWIG_OLDOBJ ;
3514	<	int res4 = SWIG_OLDOBJ ;
3515	<	int res5 = SWIG_OLDOBJ ;
3516	<	PyObject * obj0 = 0 ;
3517	<	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	<	if (!ptr) {
14235	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14236	<	}
14237	<	arg3 = ptr;
14238	<	}
14239	<	{
14240	<	std::string *ptr = (std::string *)0;
14241	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
14242	<	if (!SWIG_IsOK(res4)) {
14243	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14244	<	}
14245	<	if (!ptr) {
14246	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14247	<	}
14248	<	arg4 = ptr;
14249	<	}
14250	<	{
14251	<	std::string *ptr = (std::string *)0;
14252	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
14253	<	if (!SWIG_IsOK(res5)) {
14254	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14255	<	}
14256	<	if (!ptr) {
14257	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14258	<	}
14259	<	arg5 = ptr;
14260	<	}
14261	<	{
14262	<	std::string *ptr = (std::string *)0;
14263	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
14264	<	if (!SWIG_IsOK(res) || !ptr) {
14265	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossSession_queryTasks" "', argument " "6"" of type '" "std::string""'");
3500	>	static PyObject *_wrap_BossTask_jobPrograms(PyObject *self, PyObject *args) {
3501	>	PyObject *resultobj;
3502	>	BossTask *arg1 = (BossTask *) 0 ;
3503	>	std::string *arg2 = 0 ;
3504	>	PyObject *result;
3505	>	std::string temp2 ;
3506	>	PyObject * obj0 = 0 ;
3507	>	PyObject * obj1 = 0 ;
3508	>
3509	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobPrograms",&obj0,&obj1)) goto fail;
3510	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3511	>	{
3512	>	if (PyString_Check(obj1)) {
3513	>	temp2 = std::string(PyString_AsString(obj1));
3514	>	arg2 = &temp2;
3515	>	}else {
3516	>	SWIG_exception(SWIG_TypeError, "string expected");
3517	>	}
3518		}
3519	<	arg6 = *ptr;
3520	<	if (SWIG_IsNewObj(res)) delete ptr;
3521	<	}
3522	<	{
3523	<	try {
3524	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6);
3525	<	} catch (const std::exception& e) {
14274	<	SWIG_exception(SWIG_RuntimeError, e.what());
3519	>	{
3520	>	try {
3521	>	result = (PyObject *)BossTask_jobPrograms((BossTask const *)arg1,(std::string const &)*arg2);
3522	>
3523	>	}catch (const std::exception& e) {
3524	>	SWIG_exception(SWIG_RuntimeError, e.what());
3525	>	}
3526		}
3527	<	}
3528	<	resultobj = result;
3529	<	if (SWIG_IsNewObj(res3)) delete arg3;
3530	<	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;
3527	>	resultobj = result;
3528	>	return resultobj;
3529	>	fail:
3530	>	return NULL;
3531		}
3532
3533
3534	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3535	<	PyObject *resultobj = 0;
3536	<	BossSession *arg1 = (BossSession *) 0 ;
3537	<	int arg2 ;
3538	<	std::string *arg3 = 0 ;
3539	<	std::string *arg4 = 0 ;
3540	<	std::string *arg5 = 0 ;
3541	<	PyObject *result = 0 ;
3542	<	void *argp1 = 0 ;
3543	<	int res1 = 0 ;
3544	<	int val2 ;
3545	<	int ecode2 = 0 ;
3546	<	int res3 = SWIG_OLDOBJ ;
3547	<	int res4 = SWIG_OLDOBJ ;
3548	<	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	<	if (!ptr) {
14329	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14330	<	}
14331	<	arg3 = ptr;
14332	<	}
14333	<	{
14334	<	std::string *ptr = (std::string *)0;
14335	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
14336	<	if (!SWIG_IsOK(res4)) {
14337	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14338	<	}
14339	<	if (!ptr) {
14340	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14341	<	}
14342	<	arg4 = ptr;
14343	<	}
14344	<	{
14345	<	std::string *ptr = (std::string *)0;
14346	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
14347	<	if (!SWIG_IsOK(res5)) {
14348	<	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
14349	<	}
14350	<	if (!ptr) {
14351	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "5"" of type '" "std::string const &""'");
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());
3534	>	static PyObject *_wrap_new_BossTask__SWIG_0(PyObject *self, PyObject *args) {
3535	>	PyObject *resultobj;
3536	>	BossDatabase *arg1 = (BossDatabase *) 0 ;
3537	>	BossTask *result;
3538	>	PyObject * obj0 = 0 ;
3539	>
3540	>	if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
3541	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3542	>	{
3543	>	try {
3544	>	result = (BossTask *)new BossTask(arg1);
3545	>
3546	>	}catch (const std::exception& e) {
3547	>	SWIG_exception(SWIG_RuntimeError, e.what());
3548	>	}
3549		}
3550	<	}
3551	<	resultobj = result;
3552	<	if (SWIG_IsNewObj(res3)) delete arg3;
3553	<	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;
3550	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3551	>	return resultobj;
3552	>	fail:
3553	>	return NULL;
3554		}
3555
3556
3557	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3558	<	PyObject *resultobj = 0;
3559	<	BossSession *arg1 = (BossSession *) 0 ;
3560	<	int arg2 ;
3561	<	std::string *arg3 = 0 ;
3562	<	std::string *arg4 = 0 ;
3563	<	PyObject *result = 0 ;
3564	<	void *argp1 = 0 ;
3565	<	int res1 = 0 ;
3566	<	int val2 ;
3567	<	int ecode2 = 0 ;
3568	<	int res3 = SWIG_OLDOBJ ;
3569	<	int res4 = SWIG_OLDOBJ ;
3570	<	PyObject * obj0 = 0 ;
3571	<	PyObject * obj1 = 0 ;
3572	<	PyObject * obj2 = 0 ;
3573	<	PyObject * obj3 = 0 ;
3574	<
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	<	if (!ptr) {
14411	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14412	<	}
14413	<	arg3 = ptr;
14414	<	}
14415	<	{
14416	<	std::string *ptr = (std::string *)0;
14417	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
14418	<	if (!SWIG_IsOK(res4)) {
14419	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
14420	<	}
14421	<	if (!ptr) {
14422	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "4"" of type '" "std::string const &""'");
3557	>	static PyObject *_wrap_new_BossTask__SWIG_1(PyObject *self, PyObject *args) {
3558	>	PyObject *resultobj;
3559	>	BossDatabase *arg1 = (BossDatabase *) 0 ;
3560	>	std::string *arg2 = 0 ;
3561	>	BossTask *result;
3562	>	std::string temp2 ;
3563	>	PyObject * obj0 = 0 ;
3564	>	PyObject * obj1 = 0 ;
3565	>
3566	>	if(!PyArg_ParseTuple(args,(char *)"OO:new_BossTask",&obj0,&obj1)) goto fail;
3567	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossDatabase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3568	>	{
3569	>	if (PyString_Check(obj1)) {
3570	>	temp2 = std::string(PyString_AsString(obj1));
3571	>	arg2 = &temp2;
3572	>	}else {
3573	>	SWIG_exception(SWIG_TypeError, "string expected");
3574	>	}
3575		}
3576	<	arg4 = ptr;
3577	<	}
3578	<	{
3579	<	try {
3580	<	result = (PyObject *)BossSession_queryTasks__SWIG_0(arg1,arg2,(std::string const &)*arg3,(std::string const &)*arg4);
3581	<	} catch (const std::exception& e) {
3582	<	SWIG_exception(SWIG_RuntimeError, e.what());
3576	>	{
3577	>	try {
3578	>	result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
3579	>
3580	>	}catch (const std::exception& e) {
3581	>	SWIG_exception(SWIG_RuntimeError, e.what());
3582	>	}
3583		}
3584	<	}
3585	<	resultobj = result;
3586	<	if (SWIG_IsNewObj(res3)) delete arg3;
3587	<	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;
3584	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3585	>	return resultobj;
3586	>	fail:
3587	>	return NULL;
3588		}
3589
3590
3591	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3592	<	PyObject *resultobj = 0;
3593	<	BossSession *arg1 = (BossSession *) 0 ;
3594	<	int arg2 ;
3595	<	std::string *arg3 = 0 ;
3596	<	PyObject *result = 0 ;
3597	<	void *argp1 = 0 ;
3598	<	int res1 = 0 ;
3599	<	int val2 ;
3600	<	int ecode2 = 0 ;
3601	<	int res3 = SWIG_OLDOBJ ;
3602	<	PyObject * obj0 = 0 ;
3603	<	PyObject * obj1 = 0 ;
3604	<	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	<	if (!ptr) {
14477	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossSession_queryTasks" "', argument " "3"" of type '" "std::string const &""'");
14478	<	}
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());
3591	>	static PyObject *_wrap_delete_BossTask(PyObject *self, PyObject *args) {
3592	>	PyObject *resultobj;
3593	>	BossTask *arg1 = (BossTask *) 0 ;
3594	>	PyObject * obj0 = 0 ;
3595	>
3596	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossTask",&obj0)) goto fail;
3597	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3598	>	{
3599	>	try {
3600	>	delete arg1;
3601	>
3602	>	}catch (const std::exception& e) {
3603	>	SWIG_exception(SWIG_RuntimeError, e.what());
3604	>	}
3605		}
3606	<	}
3607	<	resultobj = result;
3608	<	if (SWIG_IsNewObj(res3)) delete arg3;
3609	<	return resultobj;
14491	<	fail:
14492	<	if (SWIG_IsNewObj(res3)) delete arg3;
14493	<	return NULL;
3606	>	Py_INCREF(Py_None); resultobj = Py_None;
3607	>	return resultobj;
3608	>	fail:
3609	>	return NULL;
3610		}
3611
3612
3613	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3614	<	PyObject *resultobj = 0;
3615	<	BossSession *arg1 = (BossSession *) 0 ;
3616	<	int arg2 ;
3617	<	PyObject *result = 0 ;
3618	<	void *argp1 = 0 ;
3619	<	int res1 = 0 ;
3620	<	int val2 ;
3621	<	int ecode2 = 0 ;
3622	<	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());
3613	>	static PyObject *_wrap_new_BossTask__SWIG_2(PyObject *self, PyObject *args) {
3614	>	PyObject *resultobj;
3615	>	BossTask *arg1 = 0 ;
3616	>	BossTask *result;
3617	>	PyObject * obj0 = 0 ;
3618	>
3619	>	if(!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) goto fail;
3620	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3621	>	if (arg1 == NULL) {
3622	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3623		}
3624	<	}
3625	<	resultobj = result;
3626	<	return resultobj;
3627	<	fail:
3628	<	return NULL;
3629	<	}
3630	<
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());
3624	>	{
3625	>	try {
3626	>	result = (BossTask *)new BossTask((BossTask const &)*arg1);
3627	>
3628	>	}catch (const std::exception& e) {
3629	>	SWIG_exception(SWIG_RuntimeError, e.what());
3630	>	}
3631		}
3632	<	}
3633	<	resultobj = result;
3634	<	return resultobj;
3635	<	fail:
14558	<	return NULL;
3632	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossTask, 1);
3633	>	return resultobj;
3634	>	fail:
3635	>	return NULL;
3636		}
3637
3638
3639	<	SWIGINTERN PyObject *_wrap_BossSession_queryTasks(PyObject *self, PyObject *args) {
3640	<	int argc;
3641	<	PyObject *argv[11];
3642	<	int ii;
3643	<
3644	<	if (!PyTuple_Check(args)) SWIG_fail;
3645	<	argc = PyObject_Length(args);
3646	<	for (ii = 0; (ii < argc) && (ii < 10); ii++) {
14570	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
14571	<	}
14572	<	if (argc == 1) {
14573	<	int _v;
14574	<	void *vptr = 0;
14575	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14576	<	_v = SWIG_CheckState(res);
14577	<	if (_v) {
14578	<	return _wrap_BossSession_queryTasks__SWIG_9(self, args);
14579	<	}
14580	<	}
14581	<	if (argc == 2) {
14582	<	int _v;
14583	<	void *vptr = 0;
14584	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14585	<	_v = SWIG_CheckState(res);
14586	<	if (_v) {
14587	<	{
14588	<	int res = SWIG_AsVal_int(argv[1], NULL);
14589	<	_v = SWIG_CheckState(res);
14590	<	}
14591	<	if (_v) {
14592	<	return _wrap_BossSession_queryTasks__SWIG_8(self, args);
14593	<	}
14594	<	}
14595	<	}
14596	<	if (argc == 3) {
14597	<	int _v;
14598	<	void *vptr = 0;
14599	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14600	<	_v = SWIG_CheckState(res);
14601	<	if (_v) {
14602	<	{
14603	<	int res = SWIG_AsVal_int(argv[1], NULL);
14604	<	_v = SWIG_CheckState(res);
14605	<	}
14606	<	if (_v) {
14607	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
14608	<	_v = SWIG_CheckState(res);
14609	<	if (_v) {
14610	<	return _wrap_BossSession_queryTasks__SWIG_7(self, args);
14611	<	}
14612	<	}
14613	<	}
14614	<	}
14615	<	if (argc == 4) {
14616	<	int _v;
14617	<	void *vptr = 0;
14618	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
14619	<	_v = SWIG_CheckState(res);
14620	<	if (_v) {
14621	<	{
14622	<	int res = SWIG_AsVal_int(argv[1], NULL);
14623	<	_v = SWIG_CheckState(res);
14624	<	}
14625	<	if (_v) {
14626	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
14627	<	_v = SWIG_CheckState(res);
14628	<	if (_v) {
14629	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
14630	<	_v = SWIG_CheckState(res);
14631	<	if (_v) {
14632	<	return _wrap_BossSession_queryTasks__SWIG_6(self, args);
14633	<	}
14634	<	}
14635	<	}
3639	>	static PyObject *_wrap_new_BossTask(PyObject *self, PyObject *args) {
3640	>	int argc;
3641	>	PyObject *argv[3];
3642	>	int ii;
3643	>
3644	>	argc = PyObject_Length(args);
3645	>	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
3646	>	argv[ii] = PyTuple_GetItem(args,ii);
3647		}
3648	<	}
3649	<	if (argc == 5) {
3650	<	int _v;
3651	<	void *vptr = 0;
3652	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3653	<	_v = SWIG_CheckState(res);
3654	<	if (_v) {
3655	<	{
3656	<	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);
3648	>	if (argc == 1) {
3649	>	int _v;
3650	>	{
3651	>	void *ptr;
3652	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
3653	>	_v = 0;
3654	>	PyErr_Clear();
3655	>	}else {
3656	>	_v = 1;
3657		}
14660	–	}
3658		}
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);
3659		if (_v) {
3660	<	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	<	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	<	}
3660	>	return _wrap_new_BossTask__SWIG_0(self,args);
3661		}
14693	–	}
3662		}
3663	<	}
3664	<	if (argc == 7) {
3665	<	int _v;
3666	<	void *vptr = 0;
3667	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3668	<	_v = SWIG_CheckState(res);
3669	<	if (_v) {
3670	<	{
3671	<	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	<	}
3663	>	if (argc == 1) {
3664	>	int _v;
3665	>	{
3666	>	void *ptr;
3667	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3668	>	_v = 0;
3669	>	PyErr_Clear();
3670	>	}else {
3671	>	_v = 1;
3672		}
14726	–	}
3673		}
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);
3674		if (_v) {
3675	<	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	<	}
3675	>	return _wrap_new_BossTask__SWIG_2(self,args);
3676		}
14767	–	}
3677		}
3678	<	}
3679	<	if (argc == 9) {
3680	<	int _v;
3681	<	void *vptr = 0;
3682	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossSession, 0);
3683	<	_v = SWIG_CheckState(res);
3684	<	if (_v) {
3685	<	{
3686	<	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	<	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	<	}
3678	>	if (argc == 2) {
3679	>	int _v;
3680	>	{
3681	>	void *ptr;
3682	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossDatabase, 0) == -1) {
3683	>	_v = 0;
3684	>	PyErr_Clear();
3685	>	}else {
3686	>	_v = 1;
3687		}
14808	–	}
3688		}
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);
3689		if (_v) {
3690	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
3691	<	_v = SWIG_CheckState(res);
3692	<	if (_v) {
14830	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
14831	<	_v = SWIG_CheckState(res);
3690	>	{
3691	>	_v = PyString_Check(argv[1]) ? 1 : 0;
3692	>	}
3693		if (_v) {
3694	<	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	<	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	<	}
3694	>	return _wrap_new_BossTask__SWIG_1(self,args);
3695		}
14857	–	}
3696		}
14859	–	}
14860	–	}
14861	–	}
14862	–
14863	–	fail:
14864	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossSession_queryTasks'");
14865	–	return NULL;
14866	–	}
14867	–
14868	–
14869	–	SWIGINTERN PyObject *BossSession_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14870	–	PyObject *obj;
14871	–	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
14872	–	SWIG_TypeNewClientData(SWIGTYPE_p_BossSession, SWIG_NewClientData(obj));
14873	–	return SWIG_Py_Void();
14874	–	}
14875	–
14876	–	SWIGINTERN PyObject *_wrap_BossTaskException_key_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14877	–	PyObject *resultobj = 0;
14878	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
14879	–	char *arg2 = (char *) 0 ;
14880	–	void *argp1 = 0 ;
14881	–	int res1 = 0 ;
14882	–	int res2 ;
14883	–	char *buf2 = 0 ;
14884	–	int alloc2 = 0 ;
14885	–	PyObject * obj0 = 0 ;
14886	–	PyObject * obj1 = 0 ;
14887	–
14888	–	if (!PyArg_ParseTuple(args,(char *)"OO:BossTaskException_key_set",&obj0,&obj1)) SWIG_fail;
14889	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTaskException, 0 |  0 );
14890	–	if (!SWIG_IsOK(res1)) {
14891	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTaskException_key_set" "', argument " "1"" of type '" "BossTaskException *""'");
14892	–	}
14893	–	arg1 = reinterpret_cast< BossTaskException * >(argp1);
14894	–	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
14895	–	if (!SWIG_IsOK(res2)) {
14896	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTaskException_key_set" "', argument " "2"" of type '" "char const *""'");
14897	–	}
14898	–	arg2 = buf2;
14899	–	if (arg2) {
14900	–	size_t size = strlen(arg2) + 1;
14901	–	arg1->key = reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
14902	–	} else {
14903	–	arg1->key = 0;
14904	–	}
14905	–	resultobj = SWIG_Py_Void();
14906	–	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
14907	–	return resultobj;
14908	–	fail:
14909	–	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
14910	–	return NULL;
14911	–	}
14912	–
14913	–
14914	–	SWIGINTERN PyObject *_wrap_BossTaskException_key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14915	–	PyObject *resultobj = 0;
14916	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
14917	–	char *result = 0 ;
14918	–	void *argp1 = 0 ;
14919	–	int res1 = 0 ;
14920	–	PyObject * obj0 = 0 ;
14921	–
14922	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTaskException_key_get",&obj0)) SWIG_fail;
14923	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTaskException, 0 |  0 );
14924	–	if (!SWIG_IsOK(res1)) {
14925	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTaskException_key_get" "', argument " "1"" of type '" "BossTaskException *""'");
14926	–	}
14927	–	arg1 = reinterpret_cast< BossTaskException * >(argp1);
14928	–	result = (char *) ((arg1)->key);
14929	–	resultobj = SWIG_FromCharPtr(result);
14930	–	return resultobj;
14931	–	fail:
14932	–	return NULL;
14933	–	}
14934	–
14935	–
14936	–	SWIGINTERN PyObject *_wrap_new_BossTaskException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14937	–	PyObject *resultobj = 0;
14938	–	char *arg1 = (char *) 0 ;
14939	–	BossTaskException *result = 0 ;
14940	–	int res1 ;
14941	–	char *buf1 = 0 ;
14942	–	int alloc1 = 0 ;
14943	–	PyObject * obj0 = 0 ;
14944	–
14945	–	if (!PyArg_ParseTuple(args,(char *)"O:new_BossTaskException",&obj0)) SWIG_fail;
14946	–	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
14947	–	if (!SWIG_IsOK(res1)) {
14948	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BossTaskException" "', argument " "1"" of type '" "char const *""'");
14949	–	}
14950	–	arg1 = buf1;
14951	–	{
14952	–	try {
14953	–	result = (BossTaskException *)new BossTaskException((char const *)arg1);
14954	–	} catch (const std::exception& e) {
14955	–	SWIG_exception(SWIG_RuntimeError, e.what());
14956	–	}
14957	–	}
14958	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTaskException, SWIG_POINTER_NEW |  0 );
14959	–	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
14960	–	return resultobj;
14961	–	fail:
14962	–	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
14963	–	return NULL;
14964	–	}
14965	–
14966	–
14967	–	SWIGINTERN PyObject *_wrap_BossTaskException_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14968	–	PyObject *resultobj = 0;
14969	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
14970	–	char *result = 0 ;
14971	–	void *argp1 = 0 ;
14972	–	int res1 = 0 ;
14973	–	PyObject * obj0 = 0 ;
14974	–
14975	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTaskException_what",&obj0)) SWIG_fail;
14976	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTaskException, 0 |  0 );
14977	–	if (!SWIG_IsOK(res1)) {
14978	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTaskException_what" "', argument " "1"" of type '" "BossTaskException const *""'");
14979	–	}
14980	–	arg1 = reinterpret_cast< BossTaskException * >(argp1);
14981	–	{
14982	–	try {
14983	–	result = (char *)((BossTaskException const *)arg1)->what();
14984	–	} catch (const std::exception& e) {
14985	–	SWIG_exception(SWIG_RuntimeError, e.what());
14986	–	}
14987	–	}
14988	–	resultobj = SWIG_FromCharPtr(result);
14989	–	return resultobj;
14990	–	fail:
14991	–	return NULL;
14992	–	}
14993	–
14994	–
14995	–	SWIGINTERN PyObject *_wrap_delete_BossTaskException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14996	–	PyObject *resultobj = 0;
14997	–	BossTaskException *arg1 = (BossTaskException *) 0 ;
14998	–	void *argp1 = 0 ;
14999	–	int res1 = 0 ;
15000	–	PyObject * obj0 = 0 ;
15001	–
15002	–	if (!PyArg_ParseTuple(args,(char *)"O:delete_BossTaskException",&obj0)) SWIG_fail;
15003	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTaskException, SWIG_POINTER_DISOWN |  0 );
15004	–	if (!SWIG_IsOK(res1)) {
15005	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BossTaskException" "', argument " "1"" of type '" "BossTaskException *""'");
15006	–	}
15007	–	arg1 = reinterpret_cast< BossTaskException * >(argp1);
15008	–	{
15009	–	try {
15010	–	delete arg1;
15011	–
15012	–	} catch (const std::exception& e) {
15013	–	SWIG_exception(SWIG_RuntimeError, e.what());
15014	–	}
15015	–	}
15016	–	resultobj = SWIG_Py_Void();
15017	–	return resultobj;
15018	–	fail:
15019	–	return NULL;
15020	–	}
15021	–
15022	–
15023	–	SWIGINTERN PyObject *BossTaskException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15024	–	PyObject *obj;
15025	–	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
15026	–	SWIG_TypeNewClientData(SWIGTYPE_p_BossTaskException, SWIG_NewClientData(obj));
15027	–	return SWIG_Py_Void();
15028	–	}
15029	–
15030	–	SWIGINTERN PyObject *_wrap_new_BossTask__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15031	–	PyObject *resultobj = 0;
15032	–	BossDatabase *arg1 = (BossDatabase *) 0 ;
15033	–	BossTask *result = 0 ;
15034	–	void *argp1 = 0 ;
15035	–	int res1 = 0 ;
15036	–	PyObject * obj0 = 0 ;
15037	–
15038	–	if (!PyArg_ParseTuple(args,(char *)"O:new_BossTask",&obj0)) SWIG_fail;
15039	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossDatabase, 0 |  0 );
15040	–	if (!SWIG_IsOK(res1)) {
15041	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BossTask" "', argument " "1"" of type '" "BossDatabase *""'");
15042	–	}
15043	–	arg1 = reinterpret_cast< BossDatabase * >(argp1);
15044	–	{
15045	–	try {
15046	–	result = (BossTask *)new BossTask(arg1);
15047	–	} catch (const std::exception& e) {
15048	–	SWIG_exception(SWIG_RuntimeError, e.what());
15049	–	}
15050	–	}
15051	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, SWIG_POINTER_NEW |  0 );
15052	–	return resultobj;
15053	–	fail:
15054	–	return NULL;
15055	–	}
15056	–
15057	–
15058	–	SWIGINTERN PyObject *_wrap_new_BossTask__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15059	–	PyObject *resultobj = 0;
15060	–	BossDatabase *arg1 = (BossDatabase *) 0 ;
15061	–	std::string *arg2 = 0 ;
15062	–	BossTask *result = 0 ;
15063	–	void *argp1 = 0 ;
15064	–	int res1 = 0 ;
15065	–	int res2 = SWIG_OLDOBJ ;
15066	–	PyObject * obj0 = 0 ;
15067	–	PyObject * obj1 = 0 ;
15068	–
15069	–	if (!PyArg_ParseTuple(args,(char *)"OO:new_BossTask",&obj0,&obj1)) SWIG_fail;
15070	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossDatabase, 0 |  0 );
15071	–	if (!SWIG_IsOK(res1)) {
15072	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BossTask" "', argument " "1"" of type '" "BossDatabase *""'");
15073	–	}
15074	–	arg1 = reinterpret_cast< BossDatabase * >(argp1);
15075	–	{
15076	–	std::string *ptr = (std::string *)0;
15077	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
15078	–	if (!SWIG_IsOK(res2)) {
15079	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BossTask" "', argument " "2"" of type '" "std::string const &""'");
15080	–	}
15081	–	if (!ptr) {
15082	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BossTask" "', argument " "2"" of type '" "std::string const &""'");
15083	–	}
15084	–	arg2 = ptr;
15085	–	}
15086	–	{
15087	–	try {
15088	–	result = (BossTask *)new BossTask(arg1,(std::string const &)*arg2);
15089	–	} catch (const std::exception& e) {
15090	–	SWIG_exception(SWIG_RuntimeError, e.what());
15091	–	}
15092	–	}
15093	–	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BossTask, SWIG_POINTER_NEW |  0 );
15094	–	if (SWIG_IsNewObj(res2)) delete arg2;
15095	–	return resultobj;
15096	–	fail:
15097	–	if (SWIG_IsNewObj(res2)) delete arg2;
15098	–	return NULL;
15099	–	}
15100	–
15101	–
15102	–	SWIGINTERN PyObject *_wrap_delete_BossTask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15103	–	PyObject *resultobj = 0;
15104	–	BossTask *arg1 = (BossTask *) 0 ;
15105	–	void *argp1 = 0 ;
15106	–	int res1 = 0 ;
15107	–	PyObject * obj0 = 0 ;
15108	–
15109	–	if (!PyArg_ParseTuple(args,(char *)"O:delete_BossTask",&obj0)) SWIG_fail;
15110	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, SWIG_POINTER_DISOWN |  0 );
15111	–	if (!SWIG_IsOK(res1)) {
15112	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BossTask" "', argument " "1"" of type '" "BossTask *""'");
15113	–	}
15114	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15115	–	{
15116	–	try {
15117	–	delete arg1;
15118	–
15119	–	} catch (const std::exception& e) {
15120	–	SWIG_exception(SWIG_RuntimeError, e.what());
3697		}
3698	<	}
3699	<	resultobj = SWIG_Py_Void();
3700	<	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;
3698	>
3699	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'new_BossTask'");
3700	>	return NULL;
3701		}
3702
3703
3704	<	SWIGINTERN PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
3705	<	int argc;
3706	<	PyObject *argv[4];
3707	<	int ii;
3708	<
3709	<	if (!PyTuple_Check(args)) SWIG_fail;
3710	<	argc = PyObject_Length(args);
3711	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3712	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3713	<	}
3714	<	if (argc == 2) {
3715	<	int _v;
3716	<	void *vptr = 0;
3717	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
3718	<	_v = SWIG_CheckState(res);
3719	<	if (_v) {
3720	<	{
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);
3704	>	static PyObject *_wrap_BossTask_id(PyObject *self, PyObject *args) {
3705	>	PyObject *resultobj;
3706	>	BossTask *arg1 = (BossTask *) 0 ;
3707	>	std::string *result;
3708	>	PyObject * obj0 = 0 ;
3709	>
3710	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_id",&obj0)) goto fail;
3711	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3712	>	{
3713	>	try {
3714	>	{
3715	>	std::string const &_result_ref = ((BossTask const *)arg1)->id();
3716	>	result = (std::string *) &_result_ref;
3717	>	}
3718	>
3719	>	}catch (const std::exception& e) {
3720	>	SWIG_exception(SWIG_RuntimeError, e.what());
3721		}
15516	–	}
15517	–	}
15518	–	}
15519	–
15520	–	fail:
15521	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_jobMap'");
15522	–	return NULL;
15523	–	}
15524	–
15525	–
15526	–	SWIGINTERN PyObject *_wrap_BossTask_programsMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15527	–	PyObject *resultobj = 0;
15528	–	BossTask *arg1 = (BossTask *) 0 ;
15529	–	BossJob *arg2 = (BossJob *) 0 ;
15530	–	SwigValueWrapper<std::map<std::string,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > >,std::less<std::string >,std::allocator<std::pair<std::string const,std::map<std::string,std::string,std::less<std::string >,std::allocator<std::pair<std::string const,std::string > > > > > > > result;
15531	–	void *argp1 = 0 ;
15532	–	int res1 = 0 ;
15533	–	void *argp2 = 0 ;
15534	–	int res2 = 0 ;
15535	–	PyObject * obj0 = 0 ;
15536	–	PyObject * obj1 = 0 ;
15537	–
15538	–	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) SWIG_fail;
15539	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15540	–	if (!SWIG_IsOK(res1)) {
15541	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_programsMap" "', argument " "1"" of type '" "BossTask const *""'");
15542	–	}
15543	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15544	–	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_BossJob, 0 |  0 );
15545	–	if (!SWIG_IsOK(res2)) {
15546	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_programsMap" "', argument " "2"" of type '" "BossJob const *""'");
15547	–	}
15548	–	arg2 = reinterpret_cast< BossJob * >(argp2);
15549	–	{
15550	–	try {
15551	–	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
15552	–	} catch (const std::exception& e) {
15553	–	SWIG_exception(SWIG_RuntimeError, e.what());
3722		}
3723	<	}
3724	<	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());
3723	>	{
3724	>	resultobj = PyString_FromStringAndSize(result->data(),result->size());
3725		}
3726	<	}
3727	<	resultobj = SWIG_Py_Void();
3728	<	if (SWIG_IsNewObj(res2)) delete arg2;
15695	<	return resultobj;
15696	<	fail:
15697	<	if (SWIG_IsNewObj(res2)) delete arg2;
15698	<	return NULL;
3726	>	return resultobj;
3727	>	fail:
3728	>	return NULL;
3729		}
3730
3731
3732	<	SWIGINTERN PyObject *_wrap_BossTask_declare__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3733	<	PyObject *resultobj = 0;
3734	<	BossTask *arg1 = (BossTask *) 0 ;
3735	<	XMLDoc *arg2 = (XMLDoc *) 0 ;
3736	<	std::string *arg3 = 0 ;
3737	<	void *argp1 = 0 ;
3738	<	int res1 = 0 ;
3739	<	void *argp2 = 0 ;
3740	<	int res2 = 0 ;
3741	<	int res3 = SWIG_OLDOBJ ;
3742	<	PyObject * obj0 = 0 ;
3743	<	PyObject * obj1 = 0 ;
3744	<	PyObject * obj2 = 0 ;
3745	<
3746	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_declare",&obj0,&obj1,&obj2)) SWIG_fail;
3747	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
3748	<	if (!SWIG_IsOK(res1)) {
3749	<	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());
3732	>	static PyObject *_wrap_BossTask_name(PyObject *self, PyObject *args) {
3733	>	PyObject *resultobj;
3734	>	BossTask *arg1 = (BossTask *) 0 ;
3735	>	std::string *result;
3736	>	PyObject * obj0 = 0 ;
3737	>
3738	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_name",&obj0)) goto fail;
3739	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3740	>	{
3741	>	try {
3742	>	{
3743	>	std::string const &_result_ref = ((BossTask const *)arg1)->name();
3744	>	result = (std::string *) &_result_ref;
3745	>	}
3746	>
3747	>	}catch (const std::exception& e) {
3748	>	SWIG_exception(SWIG_RuntimeError, e.what());
3749	>	}
3750		}
3751	<	}
3752	<	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());
3751	>	{
3752	>	resultobj = PyString_FromStringAndSize(result->data(),result->size());
3753		}
3754	<	}
3755	<	resultobj = SWIG_Py_Void();
3756	<	return resultobj;
15785	<	fail:
15786	<	return NULL;
3754	>	return resultobj;
3755	>	fail:
3756	>	return NULL;
3757		}
3758
3759
3760	<	SWIGINTERN PyObject *_wrap_BossTask_declare(PyObject *self, PyObject *args) {
3761	<	int argc;
3762	<	PyObject *argv[4];
3763	<	int ii;
3764	<
3765	<	if (!PyTuple_Check(args)) SWIG_fail;
3766	<	argc = PyObject_Length(args);
3767	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3768	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
3769	<	}
3770	<	if (argc == 2) {
3771	<	int _v;
3772	<	void *vptr = 0;
3773	<	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);
3760	>	static PyObject *_wrap_BossTask_taskMap(PyObject *self, PyObject *args) {
3761	>	PyObject *resultobj;
3762	>	BossTask *arg1 = (BossTask *) 0 ;
3763	>	std::map<std::string,std::string > result;
3764	>	PyObject * obj0 = 0 ;
3765	>
3766	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_taskMap",&obj0)) goto fail;
3767	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3768	>	{
3769	>	try {
3770	>	result = ((BossTask const *)arg1)->taskMap();
3771	>
3772	>	}catch (const std::exception& e) {
3773	>	SWIG_exception(SWIG_RuntimeError, e.what());
3774		}
15842	–	}
3775		}
3776	<	}
3777	<	if (argc == 3) {
3778	<	int _v;
3779	<	void *vptr = 0;
3780	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
3781	<	_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);
3776	>	{
3777	>	resultobj = PyDict_New();
3778	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3779	>	PyDict_SetItem(resultobj,
3780	>	SwigString_FromString(i->first),
3781	>	SwigString_FromString(i->second));
3782		}
15859	–	}
15860	–	}
15861	–	}
15862	–
15863	–	fail:
15864	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_declare'");
15865	–	return NULL;
15866	–	}
15867	–
15868	–
15869	–	SWIGINTERN PyObject *_wrap_BossTask_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15870	–	PyObject *resultobj = 0;
15871	–	BossTask *arg1 = (BossTask *) 0 ;
15872	–	void *argp1 = 0 ;
15873	–	int res1 = 0 ;
15874	–	PyObject * obj0 = 0 ;
15875	–
15876	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_remove",&obj0)) SWIG_fail;
15877	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15878	–	if (!SWIG_IsOK(res1)) {
15879	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_remove" "', argument " "1"" of type '" "BossTask *""'");
15880	–	}
15881	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15882	–	{
15883	–	try {
15884	–	(arg1)->remove();
15885	–	} catch (const std::exception& e) {
15886	–	SWIG_exception(SWIG_RuntimeError, e.what());
15887	–	}
15888	–	}
15889	–	resultobj = SWIG_Py_Void();
15890	–	return resultobj;
15891	–	fail:
15892	–	return NULL;
15893	–	}
15894	–
15895	–
15896	–	SWIGINTERN PyObject *_wrap_BossTask_archive__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15897	–	PyObject *resultobj = 0;
15898	–	BossTask *arg1 = (BossTask *) 0 ;
15899	–	std::string *arg2 = 0 ;
15900	–	void *argp1 = 0 ;
15901	–	int res1 = 0 ;
15902	–	int res2 = SWIG_OLDOBJ ;
15903	–	PyObject * obj0 = 0 ;
15904	–	PyObject * obj1 = 0 ;
15905	–
15906	–	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_archive",&obj0,&obj1)) SWIG_fail;
15907	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15908	–	if (!SWIG_IsOK(res1)) {
15909	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_archive" "', argument " "1"" of type '" "BossTask *""'");
15910	–	}
15911	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15912	–	{
15913	–	std::string *ptr = (std::string *)0;
15914	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
15915	–	if (!SWIG_IsOK(res2)) {
15916	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_archive" "', argument " "2"" of type '" "std::string const &""'");
15917	–	}
15918	–	if (!ptr) {
15919	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_archive" "', argument " "2"" of type '" "std::string const &""'");
15920	–	}
15921	–	arg2 = ptr;
15922	–	}
15923	–	{
15924	–	try {
15925	–	(arg1)->archive((std::string const &)*arg2);
15926	–	} catch (const std::exception& e) {
15927	–	SWIG_exception(SWIG_RuntimeError, e.what());
15928	–	}
15929	–	}
15930	–	resultobj = SWIG_Py_Void();
15931	–	if (SWIG_IsNewObj(res2)) delete arg2;
15932	–	return resultobj;
15933	–	fail:
15934	–	if (SWIG_IsNewObj(res2)) delete arg2;
15935	–	return NULL;
15936	–	}
15937	–
15938	–
15939	–	SWIGINTERN PyObject *_wrap_BossTask_archive__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15940	–	PyObject *resultobj = 0;
15941	–	BossTask *arg1 = (BossTask *) 0 ;
15942	–	void *argp1 = 0 ;
15943	–	int res1 = 0 ;
15944	–	PyObject * obj0 = 0 ;
15945	–
15946	–	if (!PyArg_ParseTuple(args,(char *)"O:BossTask_archive",&obj0)) SWIG_fail;
15947	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
15948	–	if (!SWIG_IsOK(res1)) {
15949	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_archive" "', argument " "1"" of type '" "BossTask *""'");
15950	–	}
15951	–	arg1 = reinterpret_cast< BossTask * >(argp1);
15952	–	{
15953	–	try {
15954	–	(arg1)->archive();
15955	–	} catch (const std::exception& e) {
15956	–	SWIG_exception(SWIG_RuntimeError, e.what());
15957	–	}
15958	–	}
15959	–	resultobj = SWIG_Py_Void();
15960	–	return resultobj;
15961	–	fail:
15962	–	return NULL;
15963	–	}
15964	–
15965	–
15966	–	SWIGINTERN PyObject *_wrap_BossTask_archive(PyObject *self, PyObject *args) {
15967	–	int argc;
15968	–	PyObject *argv[3];
15969	–	int ii;
15970	–
15971	–	if (!PyTuple_Check(args)) SWIG_fail;
15972	–	argc = PyObject_Length(args);
15973	–	for (ii = 0; (ii < argc) && (ii < 2); ii++) {
15974	–	argv[ii] = PyTuple_GET_ITEM(args,ii);
15975	–	}
15976	–	if (argc == 1) {
15977	–	int _v;
15978	–	void *vptr = 0;
15979	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15980	–	_v = SWIG_CheckState(res);
15981	–	if (_v) {
15982	–	return _wrap_BossTask_archive__SWIG_1(self, args);
15983	–	}
15984	–	}
15985	–	if (argc == 2) {
15986	–	int _v;
15987	–	void *vptr = 0;
15988	–	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
15989	–	_v = SWIG_CheckState(res);
15990	–	if (_v) {
15991	–	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
15992	–	_v = SWIG_CheckState(res);
15993	–	if (_v) {
15994	–	return _wrap_BossTask_archive__SWIG_0(self, args);
15995	–	}
15996	–	}
15997	–	}
15998	–
15999	–	fail:
16000	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_archive'");
16001	–	return NULL;
16002	–	}
16003	–
16004	–
16005	–	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16006	–	PyObject *resultobj = 0;
16007	–	BossTask *arg1 = (BossTask *) 0 ;
16008	–	std::string *arg2 = 0 ;
16009	–	std::string *arg3 = 0 ;
16010	–	std::string *arg4 = 0 ;
16011	–	std::string *arg5 = 0 ;
16012	–	std::string *arg6 = 0 ;
16013	–	bool arg7 ;
16014	–	int result;
16015	–	void *argp1 = 0 ;
16016	–	int res1 = 0 ;
16017	–	int res2 = SWIG_OLDOBJ ;
16018	–	int res3 = SWIG_OLDOBJ ;
16019	–	int res4 = SWIG_OLDOBJ ;
16020	–	int res5 = SWIG_OLDOBJ ;
16021	–	int res6 = SWIG_OLDOBJ ;
16022	–	bool val7 ;
16023	–	int ecode7 = 0 ;
16024	–	PyObject * obj0 = 0 ;
16025	–	PyObject * obj1 = 0 ;
16026	–	PyObject * obj2 = 0 ;
16027	–	PyObject * obj3 = 0 ;
16028	–	PyObject * obj4 = 0 ;
16029	–	PyObject * obj5 = 0 ;
16030	–	PyObject * obj6 = 0 ;
16031	–
16032	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16033	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16034	–	if (!SWIG_IsOK(res1)) {
16035	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
16036	–	}
16037	–	arg1 = reinterpret_cast< BossTask * >(argp1);
16038	–	{
16039	–	std::string *ptr = (std::string *)0;
16040	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16041	–	if (!SWIG_IsOK(res2)) {
16042	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
3783		}
3784	<	if (!ptr) {
3785	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "2"" of type '" "std::string const &""'");
3786	<	}
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;
3784	>	return resultobj;
3785	>	fail:
3786	>	return NULL;
3787		}
3788
3789
3790	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3791	<	PyObject *resultobj = 0;
3792	<	BossTask *arg1 = (BossTask *) 0 ;
3793	<	std::string *arg2 = 0 ;
3794	<	std::string *arg3 = 0 ;
3795	<	std::string *arg4 = 0 ;
3796	<	std::string *arg5 = 0 ;
3797	<	std::string *arg6 = 0 ;
3798	<	int result;
3799	<	void *argp1 = 0 ;
3800	<	int res1 = 0 ;
3801	<	int res2 = SWIG_OLDOBJ ;
3802	<	int res3 = SWIG_OLDOBJ ;
3803	<	int res4 = SWIG_OLDOBJ ;
3804	<	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 &""'");
3790	>	static PyObject *_wrap_BossTask_job_begin(PyObject *self, PyObject *args) {
3791	>	PyObject *resultobj;
3792	>	BossTask *arg1 = (BossTask *) 0 ;
3793	>	BossTask::job_iterator result;
3794	>	PyObject * obj0 = 0 ;
3795	>
3796	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_begin",&obj0)) goto fail;
3797	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3798	>	{
3799	>	try {
3800	>	result = ((BossTask const *)arg1)->job_begin();
3801	>
3802	>	}catch (const std::exception& e) {
3803	>	SWIG_exception(SWIG_RuntimeError, e.what());
3804	>	}
3805		}
3806	<	arg6 = ptr;
3807	<	}
3808	<	{
3809	<	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());
3806	>	{
3807	>	BossTask::job_iterator * resultptr;
3808	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3809	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3810		}
3811	<	}
3812	<	resultobj = SWIG_From_int(static_cast< int >(result));
3813	<	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;
3811	>	return resultobj;
3812	>	fail:
3813	>	return NULL;
3814		}
3815
3816
3817	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3818	<	PyObject *resultobj = 0;
3819	<	BossTask *arg1 = (BossTask *) 0 ;
3820	<	std::string *arg2 = 0 ;
3821	<	std::string *arg3 = 0 ;
3822	<	std::string *arg4 = 0 ;
3823	<	std::string *arg5 = 0 ;
3824	<	int result;
3825	<	void *argp1 = 0 ;
3826	<	int res1 = 0 ;
3827	<	int res2 = SWIG_OLDOBJ ;
3828	<	int res3 = SWIG_OLDOBJ ;
3829	<	int res4 = SWIG_OLDOBJ ;
3830	<	int res5 = SWIG_OLDOBJ ;
3831	<	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 &""'");
3817	>	static PyObject *_wrap_BossTask_job_end(PyObject *self, PyObject *args) {
3818	>	PyObject *resultobj;
3819	>	BossTask *arg1 = (BossTask *) 0 ;
3820	>	BossTask::job_iterator result;
3821	>	PyObject * obj0 = 0 ;
3822	>
3823	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_job_end",&obj0)) goto fail;
3824	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3825	>	{
3826	>	try {
3827	>	result = ((BossTask const *)arg1)->job_end();
3828	>
3829	>	}catch (const std::exception& e) {
3830	>	SWIG_exception(SWIG_RuntimeError, e.what());
3831	>	}
3832		}
3833	<	arg5 = ptr;
3834	<	}
3835	<	{
3836	<	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());
3833	>	{
3834	>	BossTask::job_iterator * resultptr;
3835	>	resultptr = new BossTask::job_iterator((BossTask::job_iterator &) result);
3836	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BossTask__job_iterator, 1);
3837		}
3838	<	}
3839	<	resultobj = SWIG_From_int(static_cast< int >(result));
3840	<	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;
3838	>	return resultobj;
3839	>	fail:
3840	>	return NULL;
3841		}
3842
3843
3844	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3845	<	PyObject *resultobj = 0;
3846	<	BossTask *arg1 = (BossTask *) 0 ;
3847	<	std::string *arg2 = 0 ;
3848	<	std::string *arg3 = 0 ;
3849	<	std::string *arg4 = 0 ;
3850	<	int result;
3851	<	void *argp1 = 0 ;
3852	<	int res1 = 0 ;
3853	<	int res2 = SWIG_OLDOBJ ;
3854	<	int res3 = SWIG_OLDOBJ ;
3855	<	int res4 = SWIG_OLDOBJ ;
3856	<	PyObject * obj0 = 0 ;
3857	<	PyObject * obj1 = 0 ;
3858	<	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 &""'");
3844	>	static PyObject *_wrap_BossTask_jobsMap(PyObject *self, PyObject *args) {
3845	>	PyObject *resultobj;
3846	>	BossTask *arg1 = (BossTask *) 0 ;
3847	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
3848	>	PyObject * obj0 = 0 ;
3849	>
3850	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_jobsMap",&obj0)) goto fail;
3851	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3852	>	{
3853	>	try {
3854	>	result = ((BossTask const *)arg1)->jobsMap();
3855	>
3856	>	}catch (const std::exception& e) {
3857	>	SWIG_exception(SWIG_RuntimeError, e.what());
3858	>	}
3859		}
3860	<	arg4 = ptr;
3861	<	}
3862	<	{
3863	<	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());
3860	>	{
3861	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
3862	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
3863	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
3864		}
3865	<	}
3866	<	resultobj = SWIG_From_int(static_cast< int >(result));
3867	<	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;
3865	>	return resultobj;
3866	>	fail:
3867	>	return NULL;
3868		}
3869
3870
3871	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3872	<	PyObject *resultobj = 0;
3873	<	BossTask *arg1 = (BossTask *) 0 ;
3874	<	std::string *arg2 = 0 ;
3875	<	std::string *arg3 = 0 ;
3876	<	int result;
3877	<	void *argp1 = 0 ;
3878	<	int res1 = 0 ;
3879	<	int res2 = SWIG_OLDOBJ ;
3880	<	int res3 = SWIG_OLDOBJ ;
3881	<	PyObject * obj0 = 0 ;
3882	<	PyObject * obj1 = 0 ;
3883	<	PyObject * obj2 = 0 ;
3884	<
3885	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_submit",&obj0,&obj1,&obj2)) SWIG_fail;
3886	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
3887	<	if (!SWIG_IsOK(res1)) {
3888	<	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 &""'");
3871	>	static PyObject *_wrap_BossTask_jobMap__SWIG_0(PyObject *self, PyObject *args) {
3872	>	PyObject *resultobj;
3873	>	BossTask *arg1 = (BossTask *) 0 ;
3874	>	SwigValueWrapper< std::vector<BossJob * >::const_iterator > arg2 ;
3875	>	std::map<std::string,std::string > *arg3 = 0 ;
3876	>	std::string result;
3877	>	std::vector<BossJob * >::const_iterator *argp2 ;
3878	>	PyObject * obj0 = 0 ;
3879	>	PyObject * obj1 = 0 ;
3880	>	PyObject * obj2 = 0 ;
3881	>
3882	>	if(!PyArg_ParseTuple(args,(char *)"OOO:BossTask_jobMap",&obj0,&obj1,&obj2)) goto fail;
3883	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3884	>	if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3885	>	arg2 = *argp2;
3886	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_std__mapTstd__string_std__string_t,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3887	>	if (arg3 == NULL) {
3888	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
3889		}
3890	<	if (!ptr) {
3891	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_submit" "', argument " "3"" of type '" "std::string const &""'");
3890	>	{
3891	>	try {
3892	>	result = ((BossTask const *)arg1)->jobMap(arg2,*arg3);
3893	>
3894	>	}catch (const std::exception& e) {
3895	>	SWIG_exception(SWIG_RuntimeError, e.what());
3896	>	}
3897		}
3898	<	arg3 = ptr;
3899	<	}
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());
3898	>	{
3899	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
3900		}
3901	<	}
3902	<	resultobj = SWIG_From_int(static_cast< int >(result));
3903	<	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;
3901	>	return resultobj;
3902	>	fail:
3903	>	return NULL;
3904		}
3905
3906
3907	<	SWIGINTERN PyObject *_wrap_BossTask_submit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3908	<	PyObject *resultobj = 0;
3909	<	BossTask *arg1 = (BossTask *) 0 ;
3910	<	std::string *arg2 = 0 ;
3911	<	int result;
3912	<	void *argp1 = 0 ;
3913	<	int res1 = 0 ;
3914	<	int res2 = SWIG_OLDOBJ ;
3915	<	PyObject * obj0 = 0 ;
3916	<	PyObject * obj1 = 0 ;
3917	<
3918	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_submit",&obj0,&obj1)) SWIG_fail;
3919	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
3920	<	if (!SWIG_IsOK(res1)) {
3921	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_submit" "', argument " "1"" of type '" "BossTask *""'");
3922	<	}
3923	<	arg1 = reinterpret_cast< BossTask * >(argp1);
3924	<	{
3925	<	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());
3907	>	static PyObject *_wrap_BossTask_jobMap__SWIG_1(PyObject *self, PyObject *args) {
3908	>	PyObject *resultobj;
3909	>	BossTask *arg1 = (BossTask *) 0 ;
3910	>	unsigned int arg2 ;
3911	>	std::map<std::string,std::string > result;
3912	>	PyObject * obj0 = 0 ;
3913	>	PyObject * obj1 = 0 ;
3914	>
3915	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_jobMap",&obj0,&obj1)) goto fail;
3916	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
3917	>	arg2 = (unsigned int) PyInt_AsLong(obj1);
3918	>	if (PyErr_Occurred()) SWIG_fail;
3919	>	{
3920	>	try {
3921	>	result = ((BossTask const *)arg1)->jobMap(arg2);
3922	>
3923	>	}catch (const std::exception& e) {
3924	>	SWIG_exception(SWIG_RuntimeError, e.what());
3925	>	}
3926		}
3927	<	}
3928	<	resultobj = SWIG_From_int(static_cast< int >(result));
3929	<	if (SWIG_IsNewObj(res2)) delete arg2;
3930	<	return resultobj;
3931	<	fail:
3932	<	if (SWIG_IsNewObj(res2)) delete arg2;
3933	<	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());
3927	>	{
3928	>	resultobj = PyDict_New();
3929	>	for (std::map<std::string,std::string >::iterator i=(&result)->begin(); i!=(&result)->end(); ++i) {
3930	>	PyDict_SetItem(resultobj,
3931	>	SwigString_FromString(i->first),
3932	>	SwigString_FromString(i->second));
3933	>	}
3934		}
3935	<	}
3936	<	resultobj = SWIG_From_int(static_cast< int >(result));
3937	<	return resultobj;
16525	<	fail:
16526	<	return NULL;
3935	>	return resultobj;
3936	>	fail:
3937	>	return NULL;
3938		}
3939
3940
3941	<	SWIGINTERN PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
3942	<	int argc;
3943	<	PyObject *argv[8];
3944	<	int ii;
3945	<
3946	<	if (!PyTuple_Check(args)) SWIG_fail;
3947	<	argc = PyObject_Length(args);
3948	<	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	<	}
3941	>	static PyObject *_wrap_BossTask_jobMap(PyObject *self, PyObject *args) {
3942	>	int argc;
3943	>	PyObject *argv[4];
3944	>	int ii;
3945	>
3946	>	argc = PyObject_Length(args);
3947	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3948	>	argv[ii] = PyTuple_GetItem(args,ii);
3949		}
3950	<	}
3951	<	if (argc == 4) {
3952	<	int _v;
3953	<	void *vptr = 0;
3954	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
3955	<	_v = SWIG_CheckState(res);
3956	<	if (_v) {
3957	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3958	<	_v = SWIG_CheckState(res);
3959	<	if (_v) {
16588	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
16589	<	_v = SWIG_CheckState(res);
16590	<	if (_v) {
16591	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
16592	<	_v = SWIG_CheckState(res);
16593	<	if (_v) {
16594	<	return _wrap_BossTask_submit__SWIG_3(self, args);
16595	<	}
3950	>	if (argc == 2) {
3951	>	int _v;
3952	>	{
3953	>	void *ptr;
3954	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3955	>	_v = 0;
3956	>	PyErr_Clear();
3957	>	}else {
3958	>	_v = 1;
3959	>	}
3960		}
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);
3961		if (_v) {
3962	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
3963	<	_v = SWIG_CheckState(res);
3964	<	if (_v) {
16615	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
16616	<	_v = SWIG_CheckState(res);
3962	>	{
3963	>	_v = (PyInt_Check(argv[1]) || PyLong_Check(argv[1])) ? 1 : 0;
3964	>	}
3965		if (_v) {
3966	<	return _wrap_BossTask_submit__SWIG_2(self, args);
3966	>	return _wrap_BossTask_jobMap__SWIG_1(self,args);
3967		}
16620	–	}
3968		}
16622	–	}
3969		}
3970	<	}
3971	<	if (argc == 6) {
3972	<	int _v;
3973	<	void *vptr = 0;
3974	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
3975	<	_v = SWIG_CheckState(res);
3976	<	if (_v) {
3977	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
3978	<	_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	<	}
3970	>	if (argc == 3) {
3971	>	int _v;
3972	>	{
3973	>	void *ptr;
3974	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
3975	>	_v = 0;
3976	>	PyErr_Clear();
3977	>	}else {
3978	>	_v = 1;
3979		}
16649	–	}
3980		}
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);
3981		if (_v) {
3982	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
3983	<	_v = SWIG_CheckState(res);
3984	<	if (_v) {
3985	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
3986	<	_v = SWIG_CheckState(res);
3982	>	{
3983	>	void *ptr;
3984	>	if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorTBossJob_p_t__const_iterator, 0) == -1) {
3985	>	_v = 0;
3986	>	PyErr_Clear();
3987	>	}else {
3988	>	_v = 1;
3989	>	}
3990	>	}
3991		if (_v) {
16672	–	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
16673	–	_v = SWIG_CheckState(res);
16674	–	if (_v) {
3992		{
3993	<	int res = SWIG_AsVal_bool(argv[6], NULL);
3994	<	_v = SWIG_CheckState(res);
3993	>	void *ptr;
3994	>	if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_std__mapTstd__string_std__string_t, 0) == -1) {
3995	>	_v = 0;
3996	>	PyErr_Clear();
3997	>	}else {
3998	>	_v = 1;
3999	>	}
4000		}
4001		if (_v) {
4002	<	return _wrap_BossTask_submit__SWIG_0(self, args);
4002	>	return _wrap_BossTask_jobMap__SWIG_0(self,args);
4003		}
16682	–	}
4004		}
16684	–	}
4005		}
16686	–	}
4006		}
4007	<	}
4008	<
4009	<	fail:
16691	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_submit'");
16692	<	return NULL;
16693	<	}
16694	<
16695	<
16696	<	SWIGINTERN PyObject *_wrap_BossTask_reSubmit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16697	<	PyObject *resultobj = 0;
16698	<	BossTask *arg1 = (BossTask *) 0 ;
16699	<	std::string *arg2 = 0 ;
16700	<	bool arg3 ;
16701	<	int result;
16702	<	void *argp1 = 0 ;
16703	<	int res1 = 0 ;
16704	<	int res2 = SWIG_OLDOBJ ;
16705	<	bool val3 ;
16706	<	int ecode3 = 0 ;
16707	<	PyObject * obj0 = 0 ;
16708	<	PyObject * obj1 = 0 ;
16709	<	PyObject * obj2 = 0 ;
16710	<
16711	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_reSubmit",&obj0,&obj1,&obj2)) SWIG_fail;
16712	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16713	<	if (!SWIG_IsOK(res1)) {
16714	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_reSubmit" "', argument " "1"" of type '" "BossTask *""'");
16715	<	}
16716	<	arg1 = reinterpret_cast< BossTask * >(argp1);
16717	<	{
16718	<	std::string *ptr = (std::string *)0;
16719	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16720	<	if (!SWIG_IsOK(res2)) {
16721	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_reSubmit" "', argument " "2"" of type '" "std::string const &""'");
16722	<	}
16723	<	if (!ptr) {
16724	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_reSubmit" "', argument " "2"" of type '" "std::string const &""'");
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	<	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	<	if (!ptr) {
16773	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_reSubmit" "', argument " "2"" of type '" "std::string const &""'");
16774	<	}
16775	<	arg2 = ptr;
16776	<	}
16777	<	{
16778	<	try {
16779	<	result = (int)(arg1)->reSubmit((std::string const &)*arg2);
16780	<	} catch (const std::exception& e) {
16781	<	SWIG_exception(SWIG_RuntimeError, e.what());
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;
4007	>
4008	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_jobMap'");
4009	>	return NULL;
4010		}
4011
4012
4013	<	SWIGINTERN PyObject *_wrap_BossTask_reSubmit(PyObject *self, PyObject *args) {
4014	<	int argc;
4015	<	PyObject *argv[4];
4016	<	int ii;
4017	<
4018	<	if (!PyTuple_Check(args)) SWIG_fail;
4019	<	argc = PyObject_Length(args);
4020	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4021	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4022	<	}
4023	<	if (argc == 2) {
4024	<	int _v;
4025	<	void *vptr = 0;
4026	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4027	<	_v = SWIG_CheckState(res);
4028	<	if (_v) {
4029	<	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	<	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);
4013	>	static PyObject *_wrap_BossTask_programsMap(PyObject *self, PyObject *args) {
4014	>	PyObject *resultobj;
4015	>	BossTask *arg1 = (BossTask *) 0 ;
4016	>	BossJob *arg2 = (BossJob *) 0 ;
4017	>	SwigValueWrapper< std::map<std::string,std::map<std::string,std::string > > > result;
4018	>	PyObject * obj0 = 0 ;
4019	>	PyObject * obj1 = 0 ;
4020	>
4021	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_programsMap",&obj0,&obj1)) goto fail;
4022	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4023	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4024	>	{
4025	>	try {
4026	>	result = ((BossTask const *)arg1)->programsMap((BossJob const *)arg2);
4027	>
4028	>	}catch (const std::exception& e) {
4029	>	SWIG_exception(SWIG_RuntimeError, e.what());
4030		}
16832	–	}
16833	–	}
16834	–	}
16835	–
16836	–	fail:
16837	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_reSubmit'");
16838	–	return NULL;
16839	–	}
16840	–
16841	–
16842	–	SWIGINTERN PyObject *_wrap_BossTask_kill__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16843	–	PyObject *resultobj = 0;
16844	–	BossTask *arg1 = (BossTask *) 0 ;
16845	–	std::string *arg2 = 0 ;
16846	–	bool arg3 ;
16847	–	int result;
16848	–	void *argp1 = 0 ;
16849	–	int res1 = 0 ;
16850	–	int res2 = SWIG_OLDOBJ ;
16851	–	bool val3 ;
16852	–	int ecode3 = 0 ;
16853	–	PyObject * obj0 = 0 ;
16854	–	PyObject * obj1 = 0 ;
16855	–	PyObject * obj2 = 0 ;
16856	–
16857	–	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_kill",&obj0,&obj1,&obj2)) SWIG_fail;
16858	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
16859	–	if (!SWIG_IsOK(res1)) {
16860	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_kill" "', argument " "1"" of type '" "BossTask *""'");
16861	–	}
16862	–	arg1 = reinterpret_cast< BossTask * >(argp1);
16863	–	{
16864	–	std::string *ptr = (std::string *)0;
16865	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
16866	–	if (!SWIG_IsOK(res2)) {
16867	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_kill" "', argument " "2"" of type '" "std::string const &""'");
16868	–	}
16869	–	if (!ptr) {
16870	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_kill" "', argument " "2"" of type '" "std::string const &""'");
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 &""'");
4031		}
4032	<	if (!ptr) {
4033	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_kill" "', argument " "2"" of type '" "std::string const &""'");
4034	<	}
4035	<	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());
4032	>	{
4033	>	std::map<std::string,std::map<std::string,std::string > > * resultptr;
4034	>	resultptr = new std::map<std::string,std::map<std::string,std::string > >((std::map<std::string,std::map<std::string,std::string > > &) result);
4035	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__mapTstd__string_std__mapTstd__string_std__string_t_t, 1);
4036		}
4037	<	}
4038	<	resultobj = SWIG_From_int(static_cast< int >(result));
4039	<	if (SWIG_IsNewObj(res2)) delete arg2;
16932	<	return resultobj;
16933	<	fail:
16934	<	if (SWIG_IsNewObj(res2)) delete arg2;
16935	<	return NULL;
4037	>	return resultobj;
4038	>	fail:
4039	>	return NULL;
4040		}
4041
4042
4043	<	SWIGINTERN PyObject *_wrap_BossTask_kill(PyObject *self, PyObject *args) {
4044	<	int argc;
4045	<	PyObject *argv[4];
4046	<	int ii;
4047	<
4048	<	if (!PyTuple_Check(args)) SWIG_fail;
4049	<	argc = PyObject_Length(args);
4050	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4051	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4052	<	}
4053	<	if (argc == 2) {
4054	<	int _v;
4055	<	void *vptr = 0;
4056	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4057	<	_v = SWIG_CheckState(res);
4058	<	if (_v) {
4059	<	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	<	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);
4043	>	static PyObject *_wrap_BossTask_queryJobPrograms(PyObject *self, PyObject *args) {
4044	>	PyObject *resultobj;
4045	>	BossTask *arg1 = (BossTask *) 0 ;
4046	>	BossJob *arg2 = (BossJob *) 0 ;
4047	>	SwigValueWrapper< std::vector<std::pair<BossProgram,BossProgramExec > > > result;
4048	>	PyObject * obj0 = 0 ;
4049	>	PyObject * obj1 = 0 ;
4050	>
4051	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossTask_queryJobPrograms",&obj0,&obj1)) goto fail;
4052	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4053	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_BossJob,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4054	>	{
4055	>	try {
4056	>	result = ((BossTask const *)arg1)->queryJobPrograms((BossJob const *)arg2);
4057	>
4058	>	}catch (const std::exception& e) {
4059	>	SWIG_exception(SWIG_RuntimeError, e.what());
4060		}
16978	–	}
16979	–	}
16980	–	}
16981	–
16982	–	fail:
16983	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_kill'");
16984	–	return NULL;
16985	–	}
16986	–
16987	–
16988	–	SWIGINTERN PyObject *_wrap_BossTask_getOutput__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16989	–	PyObject *resultobj = 0;
16990	–	BossTask *arg1 = (BossTask *) 0 ;
16991	–	std::string *arg2 = 0 ;
16992	–	std::string *arg3 = 0 ;
16993	–	bool arg4 ;
16994	–	bool arg5 ;
16995	–	int result;
16996	–	void *argp1 = 0 ;
16997	–	int res1 = 0 ;
16998	–	int res2 = SWIG_OLDOBJ ;
16999	–	int res3 = SWIG_OLDOBJ ;
17000	–	bool val4 ;
17001	–	int ecode4 = 0 ;
17002	–	bool val5 ;
17003	–	int ecode5 = 0 ;
17004	–	PyObject * obj0 = 0 ;
17005	–	PyObject * obj1 = 0 ;
17006	–	PyObject * obj2 = 0 ;
17007	–	PyObject * obj3 = 0 ;
17008	–	PyObject * obj4 = 0 ;
17009	–
17010	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17011	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17012	–	if (!SWIG_IsOK(res1)) {
17013	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getOutput" "', argument " "1"" of type '" "BossTask *""'");
17014	–	}
17015	–	arg1 = reinterpret_cast< BossTask * >(argp1);
17016	–	{
17017	–	std::string *ptr = (std::string *)0;
17018	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17019	–	if (!SWIG_IsOK(res2)) {
17020	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17021	–	}
17022	–	if (!ptr) {
17023	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
17024	–	}
17025	–	arg2 = ptr;
17026	–	}
17027	–	{
17028	–	std::string *ptr = (std::string *)0;
17029	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17030	–	if (!SWIG_IsOK(res3)) {
17031	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
17032	–	}
17033	–	if (!ptr) {
17034	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "3"" of type '" "std::string const &""'");
17035	–	}
17036	–	arg3 = ptr;
17037	–	}
17038	–	ecode4 = SWIG_AsVal_bool(obj3, &val4);
17039	–	if (!SWIG_IsOK(ecode4)) {
17040	–	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_getOutput" "', argument " "4"" of type '" "bool""'");
17041	–	}
17042	–	arg4 = static_cast< bool >(val4);
17043	–	ecode5 = SWIG_AsVal_bool(obj4, &val5);
17044	–	if (!SWIG_IsOK(ecode5)) {
17045	–	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BossTask_getOutput" "', argument " "5"" of type '" "bool""'");
17046	–	}
17047	–	arg5 = static_cast< bool >(val5);
17048	–	{
17049	–	try {
17050	–	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
17051	–	} catch (const std::exception& e) {
17052	–	SWIG_exception(SWIG_RuntimeError, e.what());
17053	–	}
17054	–	}
17055	–	resultobj = SWIG_From_int(static_cast< int >(result));
17056	–	if (SWIG_IsNewObj(res2)) delete arg2;
17057	–	if (SWIG_IsNewObj(res3)) delete arg3;
17058	–	return resultobj;
17059	–	fail:
17060	–	if (SWIG_IsNewObj(res2)) delete arg2;
17061	–	if (SWIG_IsNewObj(res3)) delete arg3;
17062	–	return NULL;
17063	–	}
17064	–
17065	–
17066	–	SWIGINTERN PyObject *_wrap_BossTask_getOutput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17067	–	PyObject *resultobj = 0;
17068	–	BossTask *arg1 = (BossTask *) 0 ;
17069	–	std::string *arg2 = 0 ;
17070	–	std::string *arg3 = 0 ;
17071	–	bool arg4 ;
17072	–	int result;
17073	–	void *argp1 = 0 ;
17074	–	int res1 = 0 ;
17075	–	int res2 = SWIG_OLDOBJ ;
17076	–	int res3 = SWIG_OLDOBJ ;
17077	–	bool val4 ;
17078	–	int ecode4 = 0 ;
17079	–	PyObject * obj0 = 0 ;
17080	–	PyObject * obj1 = 0 ;
17081	–	PyObject * obj2 = 0 ;
17082	–	PyObject * obj3 = 0 ;
17083	–
17084	–	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17085	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17086	–	if (!SWIG_IsOK(res1)) {
17087	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_getOutput" "', argument " "1"" of type '" "BossTask *""'");
17088	–	}
17089	–	arg1 = reinterpret_cast< BossTask * >(argp1);
17090	–	{
17091	–	std::string *ptr = (std::string *)0;
17092	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
17093	–	if (!SWIG_IsOK(res2)) {
17094	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
4061		}
4062	<	if (!ptr) {
4063	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getOutput" "', argument " "2"" of type '" "std::string const &""'");
4064	<	}
4065	<	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());
4062	>	{
4063	>	std::vector<std::pair<BossProgram,BossProgramExec > > * resultptr;
4064	>	resultptr = new std::vector<std::pair<BossProgram,BossProgramExec > >((std::vector<std::pair<BossProgram,BossProgramExec > > &) result);
4065	>	resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t, 1);
4066		}
4067	<	}
4068	<	resultobj = SWIG_From_int(static_cast< int >(result));
4069	<	return resultobj;
17262	<	fail:
17263	<	return NULL;
4067	>	return resultobj;
4068	>	fail:
4069	>	return NULL;
4070		}
4071
4072
4073	<	SWIGINTERN PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4074	<	int argc;
4075	<	PyObject *argv[6];
4076	<	int ii;
4077	<
4078	<	if (!PyTuple_Check(args)) SWIG_fail;
4079	<	argc = PyObject_Length(args);
4080	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
4081	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4082	<	}
4083	<	if (argc == 1) {
4084	<	int _v;
4085	<	void *vptr = 0;
4086	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4087	<	_v = SWIG_CheckState(res);
4088	<	if (_v) {
4089	<	return _wrap_BossTask_getOutput__SWIG_4(self, args);
4090	<	}
4091	<	}
4092	<	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	<	}
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	<	}
4073	>	static PyObject *_wrap_BossTask_declare__SWIG_0(PyObject *self, PyObject *args) {
4074	>	PyObject *resultobj;
4075	>	BossTask *arg1 = (BossTask *) 0 ;
4076	>	std::string *arg2 = 0 ;
4077	>	std::string const &arg3_defvalue = "" ;
4078	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4079	>	std::string temp2 ;
4080	>	std::string temp3 ;
4081	>	PyObject * obj0 = 0 ;
4082	>	PyObject * obj1 = 0 ;
4083	>	PyObject * obj2 = 0 ;
4084	>
4085	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
4086	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4087	>	{
4088	>	if (PyString_Check(obj1)) {
4089	>	temp2 = std::string(PyString_AsString(obj1));
4090	>	arg2 = &temp2;
4091	>	}else {
4092	>	SWIG_exception(SWIG_TypeError, "string expected");
4093		}
17336	–	}
4094		}
4095	<	}
4096	<	if (argc == 5) {
4097	<	int _v;
4098	<	void *vptr = 0;
4099	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4100	<	_v = SWIG_CheckState(res);
4101	<	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);
4095	>	if (obj2) {
4096	>	{
4097	>	if (PyString_Check(obj2)) {
4098	>	temp3 = std::string(PyString_AsString(obj2));
4099	>	arg3 = &temp3;
4100	>	}else {
4101	>	SWIG_exception(SWIG_TypeError, "string expected");
4102		}
17363	–	}
4103		}
17365	–	}
4104		}
4105	<	}
4106	<
4107	<	fail:
4108	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_getOutput'");
4109	<	return NULL;
4110	<	}
4111	<
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	<	if (!ptr) {
17407	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
17408	<	}
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	<	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 (!ptr) {
17465	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
17466	<	}
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	<	}
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	<	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 (!ptr) {
17514	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_getAllOutput" "', argument " "2"" of type '" "std::string const &""'");
17515	<	}
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	<	}
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	<	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());
4105	>	{
4106	>	try {
4107	>	(arg1)->declare((std::string const &)*arg2,(std::string const &)*arg3);
4108	>
4109	>	}catch (const std::exception& e) {
4110	>	SWIG_exception(SWIG_RuntimeError, e.what());
4111	>	}
4112		}
4113	<	}
4114	<	resultobj = SWIG_From_int(static_cast< int >(result));
4115	<	return resultobj;
4116	<	fail:
17558	<	return NULL;
4113	>	Py_INCREF(Py_None); resultobj = Py_None;
4114	>	return resultobj;
4115	>	fail:
4116	>	return NULL;
4117		}
4118
4119
4120	<	SWIGINTERN PyObject *_wrap_BossTask_getAllOutput(PyObject *self, PyObject *args) {
4121	<	int argc;
4122	<	PyObject *argv[5];
4123	<	int ii;
4124	<
4125	<	if (!PyTuple_Check(args)) SWIG_fail;
4126	<	argc = PyObject_Length(args);
4127	<	for (ii = 0; (ii < argc) && (ii < 4); ii++) {
4128	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4129	<	}
4130	<	if (argc == 1) {
4131	<	int _v;
4132	<	void *vptr = 0;
4133	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4134	<	_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) {
4120	>	static PyObject *_wrap_BossTask_declare__SWIG_1(PyObject *self, PyObject *args) {
4121	>	PyObject *resultobj;
4122	>	BossTask *arg1 = (BossTask *) 0 ;
4123	>	XMLDoc *arg2 = (XMLDoc *) 0 ;
4124	>	std::string const &arg3_defvalue = "" ;
4125	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4126	>	std::string temp3 ;
4127	>	PyObject * obj0 = 0 ;
4128	>	PyObject * obj1 = 0 ;
4129	>	PyObject * obj2 = 0 ;
4130	>
4131	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_declare",&obj0,&obj1,&obj2)) goto fail;
4132	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4133	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_XMLDoc,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4134	>	if (obj2) {
4135		{
4136	<	int res = SWIG_AsVal_bool(argv[2], NULL);
4137	<	_v = SWIG_CheckState(res);
4138	<	}
4139	<	if (_v) {
4140	<	return _wrap_BossTask_getAllOutput__SWIG_1(self, args);
4136	>	if (PyString_Check(obj2)) {
4137	>	temp3 = std::string(PyString_AsString(obj2));
4138	>	arg3 = &temp3;
4139	>	}else {
4140	>	SWIG_exception(SWIG_TypeError, "string expected");
4141	>	}
4142		}
17610	–	}
4143		}
4144	<	}
4145	<	if (argc == 4) {
4146	<	int _v;
4147	<	void *vptr = 0;
4148	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4149	<	_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	<	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	<	}
4144	>	{
4145	>	try {
4146	>	(arg1)->declare(arg2,(std::string const &)*arg3);
4147	>
4148	>	}catch (const std::exception& e) {
4149	>	SWIG_exception(SWIG_RuntimeError, e.what());
4150		}
17635	–	}
17636	–	}
17637	–	}
17638	–
17639	–	fail:
17640	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_getAllOutput'");
17641	–	return NULL;
17642	–	}
17643	–
17644	–
17645	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17646	–	PyObject *resultobj = 0;
17647	–	BossTask *arg1 = (BossTask *) 0 ;
17648	–	int arg2 ;
17649	–	std::string *arg3 = 0 ;
17650	–	std::string *arg4 = 0 ;
17651	–	std::string arg5 ;
17652	–	std::string arg6 ;
17653	–	std::string arg7 ;
17654	–	std::string arg8 ;
17655	–	bool arg9 ;
17656	–	int result;
17657	–	void *argp1 = 0 ;
17658	–	int res1 = 0 ;
17659	–	int val2 ;
17660	–	int ecode2 = 0 ;
17661	–	int res3 = SWIG_OLDOBJ ;
17662	–	int res4 = SWIG_OLDOBJ ;
17663	–	bool val9 ;
17664	–	int ecode9 = 0 ;
17665	–	PyObject * obj0 = 0 ;
17666	–	PyObject * obj1 = 0 ;
17667	–	PyObject * obj2 = 0 ;
17668	–	PyObject * obj3 = 0 ;
17669	–	PyObject * obj4 = 0 ;
17670	–	PyObject * obj5 = 0 ;
17671	–	PyObject * obj6 = 0 ;
17672	–	PyObject * obj7 = 0 ;
17673	–	PyObject * obj8 = 0 ;
17674	–
17675	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
17676	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17677	–	if (!SWIG_IsOK(res1)) {
17678	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
17679	–	}
17680	–	arg1 = reinterpret_cast< BossTask * >(argp1);
17681	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
17682	–	if (!SWIG_IsOK(ecode2)) {
17683	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
17684	–	}
17685	–	arg2 = static_cast< int >(val2);
17686	–	{
17687	–	std::string *ptr = (std::string *)0;
17688	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17689	–	if (!SWIG_IsOK(res3)) {
17690	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17691	–	}
17692	–	if (!ptr) {
17693	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17694	–	}
17695	–	arg3 = ptr;
17696	–	}
17697	–	{
17698	–	std::string *ptr = (std::string *)0;
17699	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
17700	–	if (!SWIG_IsOK(res4)) {
17701	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17702	–	}
17703	–	if (!ptr) {
17704	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17705	–	}
17706	–	arg4 = ptr;
17707	–	}
17708	–	{
17709	–	std::string *ptr = (std::string *)0;
17710	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
17711	–	if (!SWIG_IsOK(res) || !ptr) {
17712	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
17713	–	}
17714	–	arg5 = *ptr;
17715	–	if (SWIG_IsNewObj(res)) delete ptr;
17716	–	}
17717	–	{
17718	–	std::string *ptr = (std::string *)0;
17719	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
17720	–	if (!SWIG_IsOK(res) || !ptr) {
17721	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "6"" of type '" "std::string""'");
17722	–	}
17723	–	arg6 = *ptr;
17724	–	if (SWIG_IsNewObj(res)) delete ptr;
17725	–	}
17726	–	{
17727	–	std::string *ptr = (std::string *)0;
17728	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
17729	–	if (!SWIG_IsOK(res) || !ptr) {
17730	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "7"" of type '" "std::string""'");
17731	–	}
17732	–	arg7 = *ptr;
17733	–	if (SWIG_IsNewObj(res)) delete ptr;
17734	–	}
17735	–	{
17736	–	std::string *ptr = (std::string *)0;
17737	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
17738	–	if (!SWIG_IsOK(res) || !ptr) {
17739	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "8"" of type '" "std::string""'");
17740	–	}
17741	–	arg8 = *ptr;
17742	–	if (SWIG_IsNewObj(res)) delete ptr;
17743	–	}
17744	–	ecode9 = SWIG_AsVal_bool(obj8, &val9);
17745	–	if (!SWIG_IsOK(ecode9)) {
17746	–	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BossTask_query" "', argument " "9"" of type '" "bool""'");
17747	–	}
17748	–	arg9 = static_cast< bool >(val9);
17749	–	{
17750	–	try {
17751	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
17752	–	} catch (const std::exception& e) {
17753	–	SWIG_exception(SWIG_RuntimeError, e.what());
17754	–	}
17755	–	}
17756	–	resultobj = SWIG_From_int(static_cast< int >(result));
17757	–	if (SWIG_IsNewObj(res3)) delete arg3;
17758	–	if (SWIG_IsNewObj(res4)) delete arg4;
17759	–	return resultobj;
17760	–	fail:
17761	–	if (SWIG_IsNewObj(res3)) delete arg3;
17762	–	if (SWIG_IsNewObj(res4)) delete arg4;
17763	–	return NULL;
17764	–	}
17765	–
17766	–
17767	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17768	–	PyObject *resultobj = 0;
17769	–	BossTask *arg1 = (BossTask *) 0 ;
17770	–	int arg2 ;
17771	–	std::string *arg3 = 0 ;
17772	–	std::string *arg4 = 0 ;
17773	–	std::string arg5 ;
17774	–	std::string arg6 ;
17775	–	std::string arg7 ;
17776	–	std::string arg8 ;
17777	–	int result;
17778	–	void *argp1 = 0 ;
17779	–	int res1 = 0 ;
17780	–	int val2 ;
17781	–	int ecode2 = 0 ;
17782	–	int res3 = SWIG_OLDOBJ ;
17783	–	int res4 = SWIG_OLDOBJ ;
17784	–	PyObject * obj0 = 0 ;
17785	–	PyObject * obj1 = 0 ;
17786	–	PyObject * obj2 = 0 ;
17787	–	PyObject * obj3 = 0 ;
17788	–	PyObject * obj4 = 0 ;
17789	–	PyObject * obj5 = 0 ;
17790	–	PyObject * obj6 = 0 ;
17791	–	PyObject * obj7 = 0 ;
17792	–
17793	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
17794	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17795	–	if (!SWIG_IsOK(res1)) {
17796	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
17797	–	}
17798	–	arg1 = reinterpret_cast< BossTask * >(argp1);
17799	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
17800	–	if (!SWIG_IsOK(ecode2)) {
17801	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
17802	–	}
17803	–	arg2 = static_cast< int >(val2);
17804	–	{
17805	–	std::string *ptr = (std::string *)0;
17806	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17807	–	if (!SWIG_IsOK(res3)) {
17808	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17809	–	}
17810	–	if (!ptr) {
17811	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17812	–	}
17813	–	arg3 = ptr;
17814	–	}
17815	–	{
17816	–	std::string *ptr = (std::string *)0;
17817	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
17818	–	if (!SWIG_IsOK(res4)) {
17819	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17820	–	}
17821	–	if (!ptr) {
17822	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17823	–	}
17824	–	arg4 = ptr;
17825	–	}
17826	–	{
17827	–	std::string *ptr = (std::string *)0;
17828	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
17829	–	if (!SWIG_IsOK(res) || !ptr) {
17830	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
17831	–	}
17832	–	arg5 = *ptr;
17833	–	if (SWIG_IsNewObj(res)) delete ptr;
17834	–	}
17835	–	{
17836	–	std::string *ptr = (std::string *)0;
17837	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
17838	–	if (!SWIG_IsOK(res) || !ptr) {
17839	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "6"" of type '" "std::string""'");
17840	–	}
17841	–	arg6 = *ptr;
17842	–	if (SWIG_IsNewObj(res)) delete ptr;
17843	–	}
17844	–	{
17845	–	std::string *ptr = (std::string *)0;
17846	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
17847	–	if (!SWIG_IsOK(res) || !ptr) {
17848	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "7"" of type '" "std::string""'");
17849	–	}
17850	–	arg7 = *ptr;
17851	–	if (SWIG_IsNewObj(res)) delete ptr;
17852	–	}
17853	–	{
17854	–	std::string *ptr = (std::string *)0;
17855	–	int res = SWIG_AsPtr_std_string(obj7, &ptr);
17856	–	if (!SWIG_IsOK(res) || !ptr) {
17857	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "8"" of type '" "std::string""'");
17858	–	}
17859	–	arg8 = *ptr;
17860	–	if (SWIG_IsNewObj(res)) delete ptr;
17861	–	}
17862	–	{
17863	–	try {
17864	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8);
17865	–	} catch (const std::exception& e) {
17866	–	SWIG_exception(SWIG_RuntimeError, e.what());
17867	–	}
17868	–	}
17869	–	resultobj = SWIG_From_int(static_cast< int >(result));
17870	–	if (SWIG_IsNewObj(res3)) delete arg3;
17871	–	if (SWIG_IsNewObj(res4)) delete arg4;
17872	–	return resultobj;
17873	–	fail:
17874	–	if (SWIG_IsNewObj(res3)) delete arg3;
17875	–	if (SWIG_IsNewObj(res4)) delete arg4;
17876	–	return NULL;
17877	–	}
17878	–
17879	–
17880	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17881	–	PyObject *resultobj = 0;
17882	–	BossTask *arg1 = (BossTask *) 0 ;
17883	–	int arg2 ;
17884	–	std::string *arg3 = 0 ;
17885	–	std::string *arg4 = 0 ;
17886	–	std::string arg5 ;
17887	–	std::string arg6 ;
17888	–	std::string arg7 ;
17889	–	int result;
17890	–	void *argp1 = 0 ;
17891	–	int res1 = 0 ;
17892	–	int val2 ;
17893	–	int ecode2 = 0 ;
17894	–	int res3 = SWIG_OLDOBJ ;
17895	–	int res4 = SWIG_OLDOBJ ;
17896	–	PyObject * obj0 = 0 ;
17897	–	PyObject * obj1 = 0 ;
17898	–	PyObject * obj2 = 0 ;
17899	–	PyObject * obj3 = 0 ;
17900	–	PyObject * obj4 = 0 ;
17901	–	PyObject * obj5 = 0 ;
17902	–	PyObject * obj6 = 0 ;
17903	–
17904	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
17905	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
17906	–	if (!SWIG_IsOK(res1)) {
17907	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
17908	–	}
17909	–	arg1 = reinterpret_cast< BossTask * >(argp1);
17910	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
17911	–	if (!SWIG_IsOK(ecode2)) {
17912	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
17913	–	}
17914	–	arg2 = static_cast< int >(val2);
17915	–	{
17916	–	std::string *ptr = (std::string *)0;
17917	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
17918	–	if (!SWIG_IsOK(res3)) {
17919	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17920	–	}
17921	–	if (!ptr) {
17922	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
17923	–	}
17924	–	arg3 = ptr;
17925	–	}
17926	–	{
17927	–	std::string *ptr = (std::string *)0;
17928	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
17929	–	if (!SWIG_IsOK(res4)) {
17930	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17931	–	}
17932	–	if (!ptr) {
17933	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
17934	–	}
17935	–	arg4 = ptr;
17936	–	}
17937	–	{
17938	–	std::string *ptr = (std::string *)0;
17939	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
17940	–	if (!SWIG_IsOK(res) || !ptr) {
17941	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
17942	–	}
17943	–	arg5 = *ptr;
17944	–	if (SWIG_IsNewObj(res)) delete ptr;
17945	–	}
17946	–	{
17947	–	std::string *ptr = (std::string *)0;
17948	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
17949	–	if (!SWIG_IsOK(res) || !ptr) {
17950	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "6"" of type '" "std::string""'");
17951	–	}
17952	–	arg6 = *ptr;
17953	–	if (SWIG_IsNewObj(res)) delete ptr;
17954	–	}
17955	–	{
17956	–	std::string *ptr = (std::string *)0;
17957	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
17958	–	if (!SWIG_IsOK(res) || !ptr) {
17959	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "7"" of type '" "std::string""'");
17960	–	}
17961	–	arg7 = *ptr;
17962	–	if (SWIG_IsNewObj(res)) delete ptr;
17963	–	}
17964	–	{
17965	–	try {
17966	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7);
17967	–	} catch (const std::exception& e) {
17968	–	SWIG_exception(SWIG_RuntimeError, e.what());
17969	–	}
17970	–	}
17971	–	resultobj = SWIG_From_int(static_cast< int >(result));
17972	–	if (SWIG_IsNewObj(res3)) delete arg3;
17973	–	if (SWIG_IsNewObj(res4)) delete arg4;
17974	–	return resultobj;
17975	–	fail:
17976	–	if (SWIG_IsNewObj(res3)) delete arg3;
17977	–	if (SWIG_IsNewObj(res4)) delete arg4;
17978	–	return NULL;
17979	–	}
17980	–
17981	–
17982	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17983	–	PyObject *resultobj = 0;
17984	–	BossTask *arg1 = (BossTask *) 0 ;
17985	–	int arg2 ;
17986	–	std::string *arg3 = 0 ;
17987	–	std::string *arg4 = 0 ;
17988	–	std::string arg5 ;
17989	–	std::string arg6 ;
17990	–	int result;
17991	–	void *argp1 = 0 ;
17992	–	int res1 = 0 ;
17993	–	int val2 ;
17994	–	int ecode2 = 0 ;
17995	–	int res3 = SWIG_OLDOBJ ;
17996	–	int res4 = SWIG_OLDOBJ ;
17997	–	PyObject * obj0 = 0 ;
17998	–	PyObject * obj1 = 0 ;
17999	–	PyObject * obj2 = 0 ;
18000	–	PyObject * obj3 = 0 ;
18001	–	PyObject * obj4 = 0 ;
18002	–	PyObject * obj5 = 0 ;
18003	–
18004	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18005	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18006	–	if (!SWIG_IsOK(res1)) {
18007	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
18008	–	}
18009	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18010	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
18011	–	if (!SWIG_IsOK(ecode2)) {
18012	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
18013	–	}
18014	–	arg2 = static_cast< int >(val2);
18015	–	{
18016	–	std::string *ptr = (std::string *)0;
18017	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
18018	–	if (!SWIG_IsOK(res3)) {
18019	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18020	–	}
18021	–	if (!ptr) {
18022	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18023	–	}
18024	–	arg3 = ptr;
18025	–	}
18026	–	{
18027	–	std::string *ptr = (std::string *)0;
18028	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
18029	–	if (!SWIG_IsOK(res4)) {
18030	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18031	–	}
18032	–	if (!ptr) {
18033	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18034	–	}
18035	–	arg4 = ptr;
18036	–	}
18037	–	{
18038	–	std::string *ptr = (std::string *)0;
18039	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
18040	–	if (!SWIG_IsOK(res) || !ptr) {
18041	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
18042	–	}
18043	–	arg5 = *ptr;
18044	–	if (SWIG_IsNewObj(res)) delete ptr;
18045	–	}
18046	–	{
18047	–	std::string *ptr = (std::string *)0;
18048	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
18049	–	if (!SWIG_IsOK(res) || !ptr) {
18050	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "6"" of type '" "std::string""'");
18051	–	}
18052	–	arg6 = *ptr;
18053	–	if (SWIG_IsNewObj(res)) delete ptr;
18054	–	}
18055	–	{
18056	–	try {
18057	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6);
18058	–	} catch (const std::exception& e) {
18059	–	SWIG_exception(SWIG_RuntimeError, e.what());
18060	–	}
18061	–	}
18062	–	resultobj = SWIG_From_int(static_cast< int >(result));
18063	–	if (SWIG_IsNewObj(res3)) delete arg3;
18064	–	if (SWIG_IsNewObj(res4)) delete arg4;
18065	–	return resultobj;
18066	–	fail:
18067	–	if (SWIG_IsNewObj(res3)) delete arg3;
18068	–	if (SWIG_IsNewObj(res4)) delete arg4;
18069	–	return NULL;
18070	–	}
18071	–
18072	–
18073	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18074	–	PyObject *resultobj = 0;
18075	–	BossTask *arg1 = (BossTask *) 0 ;
18076	–	int arg2 ;
18077	–	std::string *arg3 = 0 ;
18078	–	std::string *arg4 = 0 ;
18079	–	std::string arg5 ;
18080	–	int result;
18081	–	void *argp1 = 0 ;
18082	–	int res1 = 0 ;
18083	–	int val2 ;
18084	–	int ecode2 = 0 ;
18085	–	int res3 = SWIG_OLDOBJ ;
18086	–	int res4 = SWIG_OLDOBJ ;
18087	–	PyObject * obj0 = 0 ;
18088	–	PyObject * obj1 = 0 ;
18089	–	PyObject * obj2 = 0 ;
18090	–	PyObject * obj3 = 0 ;
18091	–	PyObject * obj4 = 0 ;
18092	–
18093	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18094	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18095	–	if (!SWIG_IsOK(res1)) {
18096	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
18097	–	}
18098	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18099	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
18100	–	if (!SWIG_IsOK(ecode2)) {
18101	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
18102	–	}
18103	–	arg2 = static_cast< int >(val2);
18104	–	{
18105	–	std::string *ptr = (std::string *)0;
18106	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
18107	–	if (!SWIG_IsOK(res3)) {
18108	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18109	–	}
18110	–	if (!ptr) {
18111	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18112	–	}
18113	–	arg3 = ptr;
18114	–	}
18115	–	{
18116	–	std::string *ptr = (std::string *)0;
18117	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
18118	–	if (!SWIG_IsOK(res4)) {
18119	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18120	–	}
18121	–	if (!ptr) {
18122	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18123	–	}
18124	–	arg4 = ptr;
18125	–	}
18126	–	{
18127	–	std::string *ptr = (std::string *)0;
18128	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
18129	–	if (!SWIG_IsOK(res) || !ptr) {
18130	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query" "', argument " "5"" of type '" "std::string""'");
18131	–	}
18132	–	arg5 = *ptr;
18133	–	if (SWIG_IsNewObj(res)) delete ptr;
18134	–	}
18135	–	{
18136	–	try {
18137	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
18138	–	} catch (const std::exception& e) {
18139	–	SWIG_exception(SWIG_RuntimeError, e.what());
18140	–	}
18141	–	}
18142	–	resultobj = SWIG_From_int(static_cast< int >(result));
18143	–	if (SWIG_IsNewObj(res3)) delete arg3;
18144	–	if (SWIG_IsNewObj(res4)) delete arg4;
18145	–	return resultobj;
18146	–	fail:
18147	–	if (SWIG_IsNewObj(res3)) delete arg3;
18148	–	if (SWIG_IsNewObj(res4)) delete arg4;
18149	–	return NULL;
18150	–	}
18151	–
18152	–
18153	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18154	–	PyObject *resultobj = 0;
18155	–	BossTask *arg1 = (BossTask *) 0 ;
18156	–	int arg2 ;
18157	–	std::string *arg3 = 0 ;
18158	–	std::string *arg4 = 0 ;
18159	–	int result;
18160	–	void *argp1 = 0 ;
18161	–	int res1 = 0 ;
18162	–	int val2 ;
18163	–	int ecode2 = 0 ;
18164	–	int res3 = SWIG_OLDOBJ ;
18165	–	int res4 = SWIG_OLDOBJ ;
18166	–	PyObject * obj0 = 0 ;
18167	–	PyObject * obj1 = 0 ;
18168	–	PyObject * obj2 = 0 ;
18169	–	PyObject * obj3 = 0 ;
18170	–
18171	–	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossTask_query",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18172	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18173	–	if (!SWIG_IsOK(res1)) {
18174	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
18175	–	}
18176	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18177	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
18178	–	if (!SWIG_IsOK(ecode2)) {
18179	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
18180	–	}
18181	–	arg2 = static_cast< int >(val2);
18182	–	{
18183	–	std::string *ptr = (std::string *)0;
18184	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
18185	–	if (!SWIG_IsOK(res3)) {
18186	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18187	–	}
18188	–	if (!ptr) {
18189	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
18190	–	}
18191	–	arg3 = ptr;
18192	–	}
18193	–	{
18194	–	std::string *ptr = (std::string *)0;
18195	–	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
18196	–	if (!SWIG_IsOK(res4)) {
18197	–	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18198	–	}
18199	–	if (!ptr) {
18200	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query" "', argument " "4"" of type '" "std::string const &""'");
18201	–	}
18202	–	arg4 = ptr;
18203	–	}
18204	–	{
18205	–	try {
18206	–	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
18207	–	} catch (const std::exception& e) {
18208	–	SWIG_exception(SWIG_RuntimeError, e.what());
18209	–	}
18210	–	}
18211	–	resultobj = SWIG_From_int(static_cast< int >(result));
18212	–	if (SWIG_IsNewObj(res3)) delete arg3;
18213	–	if (SWIG_IsNewObj(res4)) delete arg4;
18214	–	return resultobj;
18215	–	fail:
18216	–	if (SWIG_IsNewObj(res3)) delete arg3;
18217	–	if (SWIG_IsNewObj(res4)) delete arg4;
18218	–	return NULL;
18219	–	}
18220	–
18221	–
18222	–	SWIGINTERN PyObject *_wrap_BossTask_query__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18223	–	PyObject *resultobj = 0;
18224	–	BossTask *arg1 = (BossTask *) 0 ;
18225	–	int arg2 ;
18226	–	std::string *arg3 = 0 ;
18227	–	int result;
18228	–	void *argp1 = 0 ;
18229	–	int res1 = 0 ;
18230	–	int val2 ;
18231	–	int ecode2 = 0 ;
18232	–	int res3 = SWIG_OLDOBJ ;
18233	–	PyObject * obj0 = 0 ;
18234	–	PyObject * obj1 = 0 ;
18235	–	PyObject * obj2 = 0 ;
18236	–
18237	–	if (!PyArg_ParseTuple(args,(char *)"OOO:BossTask_query",&obj0,&obj1,&obj2)) SWIG_fail;
18238	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18239	–	if (!SWIG_IsOK(res1)) {
18240	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query" "', argument " "1"" of type '" "BossTask *""'");
18241	–	}
18242	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18243	–	ecode2 = SWIG_AsVal_int(obj1, &val2);
18244	–	if (!SWIG_IsOK(ecode2)) {
18245	–	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BossTask_query" "', argument " "2"" of type '" "int""'");
18246	–	}
18247	–	arg2 = static_cast< int >(val2);
18248	–	{
18249	–	std::string *ptr = (std::string *)0;
18250	–	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
18251	–	if (!SWIG_IsOK(res3)) {
18252	–	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossTask_query" "', argument " "3"" of type '" "std::string const &""'");
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());
4151		}
4152	<	}
4153	<	resultobj = SWIG_From_int(static_cast< int >(result));
4154	<	return resultobj;
4155	<	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;
4152	>	Py_INCREF(Py_None); resultobj = Py_None;
4153	>	return resultobj;
4154	>	fail:
4155	>	return NULL;
4156		}
4157
4158
4159	<	SWIGINTERN PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
4160	<	int argc;
4161	<	PyObject *argv[10];
4162	<	int ii;
4163	<
4164	<	if (!PyTuple_Check(args)) SWIG_fail;
4165	<	argc = PyObject_Length(args);
4166	<	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	<	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	<	}
4159	>	static PyObject *_wrap_BossTask_declare(PyObject *self, PyObject *args) {
4160	>	int argc;
4161	>	PyObject *argv[4];
4162	>	int ii;
4163	>
4164	>	argc = PyObject_Length(args);
4165	>	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4166	>	argv[ii] = PyTuple_GetItem(args,ii);
4167		}
4168	<	}
4169	<	if (argc == 5) {
4170	<	int _v;
4171	<	void *vptr = 0;
4172	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4173	<	_v = SWIG_CheckState(res);
4174	<	if (_v) {
4175	<	{
4176	<	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);
4168	>	if ((argc >= 2) && (argc <= 3)) {
4169	>	int _v;
4170	>	{
4171	>	void *ptr;
4172	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4173	>	_v = 0;
4174	>	PyErr_Clear();
4175	>	}else {
4176	>	_v = 1;
4177		}
18438	–	}
4178		}
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);
4179		if (_v) {
4180	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
4181	<	_v = SWIG_CheckState(res);
4182	<	if (_v) {
4183	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
4184	<	_v = SWIG_CheckState(res);
4185	<	if (_v) {
4186	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
4187	<	_v = SWIG_CheckState(res);
18465	<	if (_v) {
18466	<	return _wrap_BossTask_query__SWIG_3(self, args);
18467	<	}
4180	>	{
4181	>	void *ptr;
4182	>	if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_XMLDoc, 0) == -1) {
4183	>	_v = 0;
4184	>	PyErr_Clear();
4185	>	}else {
4186	>	_v = 1;
4187	>	}
4188		}
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);
4189		if (_v) {
4190	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
4191	<	_v = SWIG_CheckState(res);
4192	<	if (_v) {
4193	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
4194	<	_v = SWIG_CheckState(res);
4190	>	if (argc <= 2) {
4191	>	return _wrap_BossTask_declare__SWIG_1(self,args);
4192	>	}
4193	>	{
4194	>	_v = PyString_Check(argv[2]) ? 1 : 0;
4195	>	}
4196		if (_v) {
4197	<	return _wrap_BossTask_query__SWIG_2(self, args);
4197	>	return _wrap_BossTask_declare__SWIG_1(self,args);
4198		}
18502	–	}
4199		}
18504	–	}
4200		}
18506	–	}
4201		}
4202	<	}
4203	<	if (argc == 8) {
4204	<	int _v;
4205	<	void *vptr = 0;
4206	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4207	<	_v = SWIG_CheckState(res);
4208	<	if (_v) {
4209	<	{
4210	<	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	<	}
4202	>	if ((argc >= 2) && (argc <= 3)) {
4203	>	int _v;
4204	>	{
4205	>	void *ptr;
4206	>	if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BossTask, 0) == -1) {
4207	>	_v = 0;
4208	>	PyErr_Clear();
4209	>	}else {
4210	>	_v = 1;
4211		}
18543	–	}
4212		}
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);
4213		if (_v) {
4214	<	int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
4215	<	_v = SWIG_CheckState(res);
4216	<	if (_v) {
18565	<	int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
18566	<	_v = SWIG_CheckState(res);
4214	>	{
4215	>	_v = PyString_Check(argv[1]) ? 1 : 0;
4216	>	}
4217		if (_v) {
4218	<	int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
4219	<	_v = SWIG_CheckState(res);
4220	<	if (_v) {
4221	<	int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
4222	<	_v = SWIG_CheckState(res);
4218	>	if (argc <= 2) {
4219	>	return _wrap_BossTask_declare__SWIG_0(self,args);
4220	>	}
4221	>	{
4222	>	_v = PyString_Check(argv[2]) ? 1 : 0;
4223	>	}
4224		if (_v) {
4225	<	int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
18575	<	_v = SWIG_CheckState(res);
18576	<	if (_v) {
18577	<	{
18578	<	int res = SWIG_AsVal_bool(argv[8], NULL);
18579	<	_v = SWIG_CheckState(res);
18580	<	}
18581	<	if (_v) {
18582	<	return _wrap_BossTask_query__SWIG_0(self, args);
18583	<	}
18584	<	}
4225	>	return _wrap_BossTask_declare__SWIG_0(self,args);
4226		}
18586	–	}
4227		}
18588	–	}
4228		}
18590	–	}
18591	–	}
18592	–	}
18593	–
18594	–	fail:
18595	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossTask_query'");
18596	–	return NULL;
18597	–	}
18598	–
18599	–
18600	–	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18601	–	PyObject *resultobj = 0;
18602	–	BossTask *arg1 = (BossTask *) 0 ;
18603	–	std::ostream *arg2 = 0 ;
18604	–	jobStates *arg3 = 0 ;
18605	–	printOption *arg4 = 0 ;
18606	–	std::string arg5 ;
18607	–	void *argp1 = 0 ;
18608	–	int res1 = 0 ;
18609	–	void *argp2 = 0 ;
18610	–	int res2 = 0 ;
18611	–	int val3 ;
18612	–	int ecode3 ;
18613	–	jobStates temp3 ;
18614	–	int val4 ;
18615	–	int ecode4 ;
18616	–	printOption temp4 ;
18617	–	PyObject * obj0 = 0 ;
18618	–	PyObject * obj1 = 0 ;
18619	–	PyObject * obj2 = 0 ;
18620	–	PyObject * obj3 = 0 ;
18621	–	PyObject * obj4 = 0 ;
18622	–
18623	–	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossTask_query_out",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18624	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18625	–	if (!SWIG_IsOK(res1)) {
18626	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query_out" "', argument " "1"" of type '" "BossTask const *""'");
18627	–	}
18628	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18629	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream,  0 );
18630	–	if (!SWIG_IsOK(res2)) {
18631	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18632	–	}
18633	–	if (!argp2) {
18634	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18635	–	}
18636	–	arg2 = reinterpret_cast< std::ostream * >(argp2);
18637	–	ecode3 = SWIG_AsVal_int (obj2, &val3);
18638	–	if (!SWIG_IsOK(ecode3)) {
18639	–	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_query_out" "', argument " "3"" of type '" "jobStates const &""'");
18640	–	} else {
18641	–	temp3 = static_cast< jobStates >(val3);
18642	–	arg3 = &temp3;
18643	–	}
18644	–	ecode4 = SWIG_AsVal_int (obj3, &val4);
18645	–	if (!SWIG_IsOK(ecode4)) {
18646	–	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_query_out" "', argument " "4"" of type '" "printOption const &""'");
18647	–	} else {
18648	–	temp4 = static_cast< printOption >(val4);
18649	–	arg4 = &temp4;
18650	–	}
18651	–	{
18652	–	std::string *ptr = (std::string *)0;
18653	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
18654	–	if (!SWIG_IsOK(res) || !ptr) {
18655	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossTask_query_out" "', argument " "5"" of type '" "std::string""'");
18656	–	}
18657	–	arg5 = *ptr;
18658	–	if (SWIG_IsNewObj(res)) delete ptr;
18659	–	}
18660	–	{
18661	–	try {
18662	–	((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
18663	–	} catch (const std::exception& e) {
18664	–	SWIG_exception(SWIG_RuntimeError, e.what());
18665	–	}
18666	–	}
18667	–	resultobj = SWIG_Py_Void();
18668	–	return resultobj;
18669	–	fail:
18670	–	return NULL;
18671	–	}
18672	–
18673	–
18674	–	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18675	–	PyObject *resultobj = 0;
18676	–	BossTask *arg1 = (BossTask *) 0 ;
18677	–	std::ostream *arg2 = 0 ;
18678	–	jobStates *arg3 = 0 ;
18679	–	printOption *arg4 = 0 ;
18680	–	void *argp1 = 0 ;
18681	–	int res1 = 0 ;
18682	–	void *argp2 = 0 ;
18683	–	int res2 = 0 ;
18684	–	int val3 ;
18685	–	int ecode3 ;
18686	–	jobStates temp3 ;
18687	–	int val4 ;
18688	–	int ecode4 ;
18689	–	printOption temp4 ;
18690	–	PyObject * obj0 = 0 ;
18691	–	PyObject * obj1 = 0 ;
18692	–	PyObject * obj2 = 0 ;
18693	–	PyObject * obj3 = 0 ;
18694	–
18695	–	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossTask_query_out",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18696	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
18697	–	if (!SWIG_IsOK(res1)) {
18698	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query_out" "', argument " "1"" of type '" "BossTask const *""'");
18699	–	}
18700	–	arg1 = reinterpret_cast< BossTask * >(argp1);
18701	–	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream,  0 );
18702	–	if (!SWIG_IsOK(res2)) {
18703	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18704	–	}
18705	–	if (!argp2) {
18706	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_query_out" "', argument " "2"" of type '" "std::ostream &""'");
18707	–	}
18708	–	arg2 = reinterpret_cast< std::ostream * >(argp2);
18709	–	ecode3 = SWIG_AsVal_int (obj2, &val3);
18710	–	if (!SWIG_IsOK(ecode3)) {
18711	–	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BossTask_query_out" "', argument " "3"" of type '" "jobStates const &""'");
18712	–	} else {
18713	–	temp3 = static_cast< jobStates >(val3);
18714	–	arg3 = &temp3;
18715	–	}
18716	–	ecode4 = SWIG_AsVal_int (obj3, &val4);
18717	–	if (!SWIG_IsOK(ecode4)) {
18718	–	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BossTask_query_out" "', argument " "4"" of type '" "printOption const &""'");
18719	–	} else {
18720	–	temp4 = static_cast< printOption >(val4);
18721	–	arg4 = &temp4;
18722	–	}
18723	–	{
18724	–	try {
18725	–	((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4);
18726	–	} catch (const std::exception& e) {
18727	–	SWIG_exception(SWIG_RuntimeError, e.what());
4229		}
4230	<	}
4231	<	resultobj = SWIG_Py_Void();
4232	<	return resultobj;
18732	<	fail:
18733	<	return NULL;
4230	>
4231	>	PyErr_SetString(PyExc_TypeError,"No matching function for overloaded 'BossTask_declare'");
4232	>	return NULL;
4233		}
4234
4235
4236	<	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4237	<	PyObject *resultobj = 0;
4238	<	BossTask *arg1 = (BossTask *) 0 ;
4239	<	std::ostream *arg2 = 0 ;
4240	<	jobStates *arg3 = 0 ;
4241	<	void *argp1 = 0 ;
4242	<	int res1 = 0 ;
4243	<	void *argp2 = 0 ;
4244	<	int res2 = 0 ;
4245	<	int val3 ;
4246	<	int ecode3 ;
4247	<	jobStates temp3 ;
4248	<	PyObject * obj0 = 0 ;
4249	<	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());
4236	>	static PyObject *_wrap_BossTask_remove(PyObject *self, PyObject *args) {
4237	>	PyObject *resultobj;
4238	>	BossTask *arg1 = (BossTask *) 0 ;
4239	>	PyObject * obj0 = 0 ;
4240	>
4241	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_remove",&obj0)) goto fail;
4242	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4243	>	{
4244	>	try {
4245	>	(arg1)->remove();
4246	>
4247	>	}catch (const std::exception& e) {
4248	>	SWIG_exception(SWIG_RuntimeError, e.what());
4249	>	}
4250		}
4251	<	}
4252	<	resultobj = SWIG_Py_Void();
4253	<	return resultobj;
4254	<	fail:
18784	<	return NULL;
4251	>	Py_INCREF(Py_None); resultobj = Py_None;
4252	>	return resultobj;
4253	>	fail:
4254	>	return NULL;
4255		}
4256
4257
4258	<	SWIGINTERN PyObject *_wrap_BossTask_query_out__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4259	<	PyObject *resultobj = 0;
4260	<	BossTask *arg1 = (BossTask *) 0 ;
4261	<	std::ostream *arg2 = 0 ;
4262	<	void *argp1 = 0 ;
4263	<	int res1 = 0 ;
4264	<	void *argp2 = 0 ;
4265	<	int res2 = 0 ;
4266	<	PyObject * obj0 = 0 ;
4267	<	PyObject * obj1 = 0 ;
4268	<
4269	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossTask_query_out",&obj0,&obj1)) SWIG_fail;
4270	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossTask, 0 |  0 );
4271	<	if (!SWIG_IsOK(res1)) {
4272	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossTask_query_out" "', argument " "1"" of type '" "BossTask const *""'");
4273	<	}
4274	<	arg1 = reinterpret_cast< BossTask * >(argp1);
4275	<	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream,  0 );
4276	<	if (!SWIG_IsOK(res2)) {
4277	<	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());
4258	>	static PyObject *_wrap_BossTask_archive(PyObject *self, PyObject *args) {
4259	>	PyObject *resultobj;
4260	>	BossTask *arg1 = (BossTask *) 0 ;
4261	>	std::string const &arg2_defvalue = "all" ;
4262	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4263	>	std::string temp2 ;
4264	>	PyObject * obj0 = 0 ;
4265	>	PyObject * obj1 = 0 ;
4266	>
4267	>	if(!PyArg_ParseTuple(args,(char *)"O|O:BossTask_archive",&obj0,&obj1)) goto fail;
4268	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4269	>	if (obj1) {
4270	>	{
4271	>	if (PyString_Check(obj1)) {
4272	>	temp2 = std::string(PyString_AsString(obj1));
4273	>	arg2 = &temp2;
4274	>	}else {
4275	>	SWIG_exception(SWIG_TypeError, "string expected");
4276	>	}
4277	>	}
4278		}
4279	<	}
4280	<	resultobj = SWIG_Py_Void();
4281	<	return resultobj;
4282	<	fail:
4283	<	return NULL;
4284	<	}
4285	<
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());
4279	>	{
4280	>	try {
4281	>	(arg1)->archive((std::string const &)*arg2);
4282	>
4283	>	}catch (const std::exception& e) {
4284	>	SWIG_exception(SWIG_RuntimeError, e.what());
4285	>	}
4286		}
4287	<	}
4288	<	resultobj = SWIG_Py_Void();
4289	<	return resultobj;
4290	<	fail:
18850	<	return NULL;
4287	>	Py_INCREF(Py_None); resultobj = Py_None;
4288	>	return resultobj;
4289	>	fail:
4290	>	return NULL;
4291		}
4292
4293
4294	<	SWIGINTERN PyObject *_wrap_BossTask_query_out(PyObject *self, PyObject *args) {
4295	<	int argc;
4296	<	PyObject *argv[6];
4297	<	int ii;
4298	<
4299	<	if (!PyTuple_Check(args)) SWIG_fail;
4300	<	argc = PyObject_Length(args);
4301	<	for (ii = 0; (ii < argc) && (ii < 5); ii++) {
4302	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4303	<	}
4304	<	if (argc == 1) {
4305	<	int _v;
4306	<	void *vptr = 0;
4307	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4308	<	_v = SWIG_CheckState(res);
4309	<	if (_v) {
4310	<	return _wrap_BossTask_query_out__SWIG_4(self, args);
4311	<	}
4312	<	}
4313	<	if (argc == 2) {
4314	<	int _v;
4315	<	void *vptr = 0;
4316	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossTask, 0);
4317	<	_v = SWIG_CheckState(res);
4318	<	if (_v) {
4319	<	void *vptr = 0;
4320	<	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, 0);
4321	<	_v = SWIG_CheckState(res);
4322	<	if (_v) {
4323	<	return _wrap_BossTask_query_out__SWIG_3(self, args);
4324	<	}
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) {
4294	>	static PyObject *_wrap_BossTask_submit(PyObject *self, PyObject *args) {
4295	>	PyObject *resultobj;
4296	>	BossTask *arg1 = (BossTask *) 0 ;
4297	>	std::string const &arg2_defvalue = "all" ;
4298	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4299	>	std::string const &arg3_defvalue = "" ;
4300	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4301	>	std::string const &arg4_defvalue = "" ;
4302	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4303	>	std::string const &arg5_defvalue = "" ;
4304	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
4305	>	std::string const &arg6_defvalue = "" ;
4306	>	std::string *arg6 = (std::string *) &arg6_defvalue ;
4307	>	bool arg7 = (bool) false ;
4308	>	int result;
4309	>	std::string temp2 ;
4310	>	std::string temp3 ;
4311	>	std::string temp4 ;
4312	>	std::string temp5 ;
4313	>	std::string temp6 ;
4314	>	PyObject * obj0 = 0 ;
4315	>	PyObject * obj1 = 0 ;
4316	>	PyObject * obj2 = 0 ;
4317	>	PyObject * obj3 = 0 ;
4318	>	PyObject * obj4 = 0 ;
4319	>	PyObject * obj5 = 0 ;
4320	>	PyObject * obj6 = 0 ;
4321	>
4322	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOOOO:BossTask_submit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4323	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4324	>	if (obj1) {
4325		{
4326	<	int res = SWIG_AsVal_int(argv[2], NULL);
4327	<	_v = SWIG_CheckState(res);
4328	<	}
4329	<	if (_v) {
4330	<	return _wrap_BossTask_query_out__SWIG_2(self, args);
4326	>	if (PyString_Check(obj1)) {
4327	>	temp2 = std::string(PyString_AsString(obj1));
4328	>	arg2 = &temp2;
4329	>	}else {
4330	>	SWIG_exception(SWIG_TypeError, "string expected");
4331	>	}
4332		}
18904	–	}
4333		}
4334	<	}
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) {
4334	>	if (obj2) {
4335		{
4336	<	int res = SWIG_AsVal_int(argv[2], NULL);
4337	<	_v = SWIG_CheckState(res);
4338	<	}
4339	<	if (_v) {
4340	<	{
4341	<	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	<	}
4336	>	if (PyString_Check(obj2)) {
4337	>	temp3 = std::string(PyString_AsString(obj2));
4338	>	arg3 = &temp3;
4339	>	}else {
4340	>	SWIG_exception(SWIG_TypeError, "string expected");
4341	>	}
4342		}
18930	–	}
4343		}
4344	<	}
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) {
4344	>	if (obj3) {
4345		{
4346	<	int res = SWIG_AsVal_int(argv[2], NULL);
4347	<	_v = SWIG_CheckState(res);
4348	<	}
4349	<	if (_v) {
4350	<	{
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);
4346	>	if (PyString_Check(obj3)) {
4347	>	temp4 = std::string(PyString_AsString(obj3));
4348	>	arg4 = &temp4;
4349	>	}else {
4350	>	SWIG_exception(SWIG_TypeError, "string expected");
4351		}
18958	–	}
18959	–	}
18960	–	}
18961	–	}
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	–	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	–	}
19033	–	resultobj = result;
19034	–	return resultobj;
19035	–	fail:
19036	–	return NULL;
19037	–	}
19038	–
19039	–
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	–	}
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	–	}
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	–	}
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	–	if (!ptr) {
19172	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossTask_jobPrograms" "', argument " "2"" of type '" "std::string const &""'");
19173	–	}
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	–	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	–	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	–	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	–	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	–	}
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	–	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	–	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	–	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	–	}
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	–	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	–	}
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	–	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	–	}
19385	–	resultobj = SWIG_Py_Void();
19386	–	return resultobj;
19387	–	fail:
19388	–	return NULL;
19389	–	}
19390	–
19391	–
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	–	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	–	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	–	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	–	if (!ptr) {
19488	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteCHTool" "', argument " "2"" of type '" "std::string const &""'");
19489	–	}
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	–	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	–	if (!ptr) {
19532	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteProgramType" "', argument " "2"" of type '" "std::string const &""'");
19533	–	}
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	–	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	–	if (!ptr) {
19576	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteRTMon" "', argument " "2"" of type '" "std::string const &""'");
19577	–	}
19578	–	arg2 = ptr;
19579	–	}
19580	–	{
19581	–	try {
19582	–	result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
19583	–	} catch (const std::exception& e) {
19584	–	SWIG_exception(SWIG_RuntimeError, e.what());
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	–	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	–	if (!ptr) {
19620	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_deleteScheduler" "', argument " "2"" of type '" "std::string const &""'");
19621	–	}
19622	–	arg2 = ptr;
19623	–	}
19624	–	{
19625	–	try {
19626	–	result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
19627	–	} catch (const std::exception& e) {
19628	–	SWIG_exception(SWIG_RuntimeError, e.what());
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	–	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	–	}
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	–	}
4352		}
20022	–	}
4353		}
4354	<	}
4355	<	if (argc == 5) {
4356	<	int _v;
4357	<	void *vptr = 0;
4358	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
4359	<	_v = SWIG_CheckState(res);
4360	<	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);
4354	>	if (obj4) {
4355	>	{
4356	>	if (PyString_Check(obj4)) {
4357	>	temp5 = std::string(PyString_AsString(obj4));
4358	>	arg5 = &temp5;
4359	>	}else {
4360	>	SWIG_exception(SWIG_TypeError, "string expected");
4361		}
20047	–	}
4362		}
20049	–	}
4363		}
4364	<	}
4365	<	if (argc == 6) {
4366	<	int _v;
4367	<	void *vptr = 0;
4368	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
4369	<	_v = SWIG_CheckState(res);
4370	<	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	<	}
4364	>	if (obj5) {
4365	>	{
4366	>	if (PyString_Check(obj5)) {
4367	>	temp6 = std::string(PyString_AsString(obj5));
4368	>	arg6 = &temp6;
4369	>	}else {
4370	>	SWIG_exception(SWIG_TypeError, "string expected");
4371		}
20080	–	}
4372		}
20082	–	}
20083	–	}
20084	–	}
20085	–
20086	–	fail:
20087	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_registerCHTool'");
20088	–	return NULL;
20089	–	}
20090	–
20091	–
20092	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20093	–	PyObject *resultobj = 0;
20094	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20095	–	std::string *arg2 = 0 ;
20096	–	std::string arg3 ;
20097	–	std::string arg4 ;
20098	–	std::string arg5 ;
20099	–	std::string arg6 ;
20100	–	std::string arg7 ;
20101	–	bool arg8 ;
20102	–	int result;
20103	–	void *argp1 = 0 ;
20104	–	int res1 = 0 ;
20105	–	int res2 = SWIG_OLDOBJ ;
20106	–	bool val8 ;
20107	–	int ecode8 = 0 ;
20108	–	PyObject * obj0 = 0 ;
20109	–	PyObject * obj1 = 0 ;
20110	–	PyObject * obj2 = 0 ;
20111	–	PyObject * obj3 = 0 ;
20112	–	PyObject * obj4 = 0 ;
20113	–	PyObject * obj5 = 0 ;
20114	–	PyObject * obj6 = 0 ;
20115	–	PyObject * obj7 = 0 ;
20116	–
20117	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
20118	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20119	–	if (!SWIG_IsOK(res1)) {
20120	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20121	–	}
20122	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20123	–	{
20124	–	std::string *ptr = (std::string *)0;
20125	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20126	–	if (!SWIG_IsOK(res2)) {
20127	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20128	–	}
20129	–	if (!ptr) {
20130	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20131	–	}
20132	–	arg2 = ptr;
20133	–	}
20134	–	{
20135	–	std::string *ptr = (std::string *)0;
20136	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20137	–	if (!SWIG_IsOK(res) || !ptr) {
20138	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "3"" of type '" "std::string""'");
20139	–	}
20140	–	arg3 = *ptr;
20141	–	if (SWIG_IsNewObj(res)) delete ptr;
20142	–	}
20143	–	{
20144	–	std::string *ptr = (std::string *)0;
20145	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20146	–	if (!SWIG_IsOK(res) || !ptr) {
20147	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "4"" of type '" "std::string""'");
20148	–	}
20149	–	arg4 = *ptr;
20150	–	if (SWIG_IsNewObj(res)) delete ptr;
20151	–	}
20152	–	{
20153	–	std::string *ptr = (std::string *)0;
20154	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20155	–	if (!SWIG_IsOK(res) || !ptr) {
20156	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "5"" of type '" "std::string""'");
20157	–	}
20158	–	arg5 = *ptr;
20159	–	if (SWIG_IsNewObj(res)) delete ptr;
20160	–	}
20161	–	{
20162	–	std::string *ptr = (std::string *)0;
20163	–	int res = SWIG_AsPtr_std_string(obj5, &ptr);
20164	–	if (!SWIG_IsOK(res) || !ptr) {
20165	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "6"" of type '" "std::string""'");
20166	–	}
20167	–	arg6 = *ptr;
20168	–	if (SWIG_IsNewObj(res)) delete ptr;
20169	–	}
20170	–	{
20171	–	std::string *ptr = (std::string *)0;
20172	–	int res = SWIG_AsPtr_std_string(obj6, &ptr);
20173	–	if (!SWIG_IsOK(res) || !ptr) {
20174	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "7"" of type '" "std::string""'");
20175	–	}
20176	–	arg7 = *ptr;
20177	–	if (SWIG_IsNewObj(res)) delete ptr;
20178	–	}
20179	–	ecode8 = SWIG_AsVal_bool(obj7, &val8);
20180	–	if (!SWIG_IsOK(ecode8)) {
20181	–	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BossAdministratorSession_registerProgram" "', argument " "8"" of type '" "bool""'");
20182	–	}
20183	–	arg8 = static_cast< bool >(val8);
20184	–	{
20185	–	try {
20186	–	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
20187	–	} catch (const std::exception& e) {
20188	–	SWIG_exception(SWIG_RuntimeError, e.what());
20189	–	}
20190	–	}
20191	–	resultobj = SWIG_From_int(static_cast< int >(result));
20192	–	if (SWIG_IsNewObj(res2)) delete arg2;
20193	–	return resultobj;
20194	–	fail:
20195	–	if (SWIG_IsNewObj(res2)) delete arg2;
20196	–	return NULL;
20197	–	}
20198	–
20199	–
20200	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20201	–	PyObject *resultobj = 0;
20202	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20203	–	std::string *arg2 = 0 ;
20204	–	std::string arg3 ;
20205	–	std::string arg4 ;
20206	–	std::string arg5 ;
20207	–	std::string arg6 ;
20208	–	std::string arg7 ;
20209	–	int result;
20210	–	void *argp1 = 0 ;
20211	–	int res1 = 0 ;
20212	–	int res2 = SWIG_OLDOBJ ;
20213	–	PyObject * obj0 = 0 ;
20214	–	PyObject * obj1 = 0 ;
20215	–	PyObject * obj2 = 0 ;
20216	–	PyObject * obj3 = 0 ;
20217	–	PyObject * obj4 = 0 ;
20218	–	PyObject * obj5 = 0 ;
20219	–	PyObject * obj6 = 0 ;
20220	–
20221	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
20222	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20223	–	if (!SWIG_IsOK(res1)) {
20224	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20225	–	}
20226	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20227	–	{
20228	–	std::string *ptr = (std::string *)0;
20229	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20230	–	if (!SWIG_IsOK(res2)) {
20231	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20232	–	}
20233	–	if (!ptr) {
20234	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
20235	–	}
20236	–	arg2 = ptr;
20237	–	}
20238	–	{
20239	–	std::string *ptr = (std::string *)0;
20240	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20241	–	if (!SWIG_IsOK(res) || !ptr) {
20242	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerProgram" "', argument " "3"" of type '" "std::string""'");
4373		}
4374	<	arg3 = *ptr;
4375	<	if (SWIG_IsNewObj(res)) delete ptr;
4376	<	}
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""'");
4374	>	if (obj6) {
4375	>	arg7 = PyInt_AsLong(obj6) ? true : false;
4376	>	if (PyErr_Occurred()) SWIG_fail;
4377		}
4378	<	arg7 = *ptr;
4379	<	if (SWIG_IsNewObj(res)) delete ptr;
4380	<	}
4381	<	{
4382	<	try {
4383	<	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
4384	<	} catch (const std::exception& e) {
20287	<	SWIG_exception(SWIG_RuntimeError, e.what());
4378	>	{
4379	>	try {
4380	>	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);
4381	>
4382	>	}catch (const std::exception& e) {
4383	>	SWIG_exception(SWIG_RuntimeError, e.what());
4384	>	}
4385		}
4386	<	}
4387	<	resultobj = SWIG_From_int(static_cast< int >(result));
4388	<	if (SWIG_IsNewObj(res2)) delete arg2;
4389	<	return resultobj;
20293	<	fail:
20294	<	if (SWIG_IsNewObj(res2)) delete arg2;
20295	<	return NULL;
4386	>	resultobj = PyInt_FromLong((long)result);
4387	>	return resultobj;
4388	>	fail:
4389	>	return NULL;
4390		}
4391
4392
4393	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4394	<	PyObject *resultobj = 0;
4395	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4396	<	std::string *arg2 = 0 ;
4397	<	std::string arg3 ;
4398	<	std::string arg4 ;
4399	<	std::string arg5 ;
4400	<	std::string arg6 ;
4401	<	int result;
4402	<	void *argp1 = 0 ;
4403	<	int res1 = 0 ;
4404	<	int res2 = SWIG_OLDOBJ ;
4405	<	PyObject * obj0 = 0 ;
4406	<	PyObject * obj1 = 0 ;
4407	<	PyObject * obj2 = 0 ;
4408	<	PyObject * obj3 = 0 ;
4409	<	PyObject * obj4 = 0 ;
4410	<	PyObject * obj5 = 0 ;
4411	<
4412	<	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""'");
4393	>	static PyObject *_wrap_BossTask_reSubmit(PyObject *self, PyObject *args) {
4394	>	PyObject *resultobj;
4395	>	BossTask *arg1 = (BossTask *) 0 ;
4396	>	std::string *arg2 = 0 ;
4397	>	bool arg3 = (bool) false ;
4398	>	int result;
4399	>	std::string temp2 ;
4400	>	PyObject * obj0 = 0 ;
4401	>	PyObject * obj1 = 0 ;
4402	>	PyObject * obj2 = 0 ;
4403	>
4404	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_reSubmit",&obj0,&obj1,&obj2)) goto fail;
4405	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4406	>	{
4407	>	if (PyString_Check(obj1)) {
4408	>	temp2 = std::string(PyString_AsString(obj1));
4409	>	arg2 = &temp2;
4410	>	}else {
4411	>	SWIG_exception(SWIG_TypeError, "string expected");
4412	>	}
4413		}
4414	<	arg4 = *ptr;
4415	<	if (SWIG_IsNewObj(res)) delete ptr;
4416	<	}
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""'");
4414	>	if (obj2) {
4415	>	arg3 = PyInt_AsLong(obj2) ? true : false;
4416	>	if (PyErr_Occurred()) SWIG_fail;
4417		}
4418	<	arg5 = *ptr;
4419	<	if (SWIG_IsNewObj(res)) delete ptr;
4420	<	}
4421	<	{
4422	<	std::string *ptr = (std::string *)0;
4423	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
4424	<	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());
4418	>	{
4419	>	try {
4420	>	result = (int)(arg1)->reSubmit((std::string const &)*arg2,arg3);
4421	>
4422	>	}catch (const std::exception& e) {
4423	>	SWIG_exception(SWIG_RuntimeError, e.what());
4424	>	}
4425		}
4426	<	}
4427	<	resultobj = SWIG_From_int(static_cast< int >(result));
4428	<	if (SWIG_IsNewObj(res2)) delete arg2;
4429	<	return resultobj;
20381	<	fail:
20382	<	if (SWIG_IsNewObj(res2)) delete arg2;
20383	<	return NULL;
4426	>	resultobj = PyInt_FromLong((long)result);
4427	>	return resultobj;
4428	>	fail:
4429	>	return NULL;
4430		}
4431
4432
4433	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4434	<	PyObject *resultobj = 0;
4435	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4436	<	std::string *arg2 = 0 ;
4437	<	std::string arg3 ;
4438	<	std::string arg4 ;
4439	<	std::string arg5 ;
4440	<	int result;
4441	<	void *argp1 = 0 ;
4442	<	int res1 = 0 ;
4443	<	int res2 = SWIG_OLDOBJ ;
4444	<	PyObject * obj0 = 0 ;
4445	<	PyObject * obj1 = 0 ;
4446	<	PyObject * obj2 = 0 ;
4447	<	PyObject * obj3 = 0 ;
4448	<	PyObject * obj4 = 0 ;
4449	<
4450	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
4451	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
4452	<	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""'");
4433	>	static PyObject *_wrap_BossTask_kill(PyObject *self, PyObject *args) {
4434	>	PyObject *resultobj;
4435	>	BossTask *arg1 = (BossTask *) 0 ;
4436	>	std::string *arg2 = 0 ;
4437	>	bool arg3 = (bool) false ;
4438	>	int result;
4439	>	std::string temp2 ;
4440	>	PyObject * obj0 = 0 ;
4441	>	PyObject * obj1 = 0 ;
4442	>	PyObject * obj2 = 0 ;
4443	>
4444	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossTask_kill",&obj0,&obj1,&obj2)) goto fail;
4445	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4446	>	{
4447	>	if (PyString_Check(obj1)) {
4448	>	temp2 = std::string(PyString_AsString(obj1));
4449	>	arg2 = &temp2;
4450	>	}else {
4451	>	SWIG_exception(SWIG_TypeError, "string expected");
4452	>	}
4453		}
4454	<	arg4 = *ptr;
4455	<	if (SWIG_IsNewObj(res)) delete ptr;
4456	<	}
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""'");
4454	>	if (obj2) {
4455	>	arg3 = PyInt_AsLong(obj2) ? true : false;
4456	>	if (PyErr_Occurred()) SWIG_fail;
4457		}
4458	<	arg5 = *ptr;
4459	<	if (SWIG_IsNewObj(res)) delete ptr;
4460	<	}
4461	<	{
4462	<	try {
4463	<	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5);
4464	<	} catch (const std::exception& e) {
20452	<	SWIG_exception(SWIG_RuntimeError, e.what());
4458	>	{
4459	>	try {
4460	>	result = (int)(arg1)->kill((std::string const &)*arg2,arg3);
4461	>
4462	>	}catch (const std::exception& e) {
4463	>	SWIG_exception(SWIG_RuntimeError, e.what());
4464	>	}
4465		}
4466	<	}
4467	<	resultobj = SWIG_From_int(static_cast< int >(result));
4468	<	if (SWIG_IsNewObj(res2)) delete arg2;
4469	<	return resultobj;
20458	<	fail:
20459	<	if (SWIG_IsNewObj(res2)) delete arg2;
20460	<	return NULL;
4466	>	resultobj = PyInt_FromLong((long)result);
4467	>	return resultobj;
4468	>	fail:
4469	>	return NULL;
4470		}
4471
4472
4473	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4474	<	PyObject *resultobj = 0;
4475	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4476	<	std::string *arg2 = 0 ;
4477	<	std::string arg3 ;
4478	<	std::string arg4 ;
4479	<	int result;
4480	<	void *argp1 = 0 ;
4481	<	int res1 = 0 ;
4482	<	int res2 = SWIG_OLDOBJ ;
4483	<	PyObject * obj0 = 0 ;
4484	<	PyObject * obj1 = 0 ;
4485	<	PyObject * obj2 = 0 ;
4486	<	PyObject * obj3 = 0 ;
4487	<
4488	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4489	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
4490	<	if (!SWIG_IsOK(res1)) {
4491	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
4492	<	}
4493	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
4494	<	{
4495	<	std::string *ptr = (std::string *)0;
4496	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
4497	<	if (!SWIG_IsOK(res2)) {
4498	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
4473	>	static PyObject *_wrap_BossTask_getOutput(PyObject *self, PyObject *args) {
4474	>	PyObject *resultobj;
4475	>	BossTask *arg1 = (BossTask *) 0 ;
4476	>	std::string const &arg2_defvalue = "all" ;
4477	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4478	>	std::string const &arg3_defvalue = "" ;
4479	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4480	>	bool arg4 = (bool) false ;
4481	>	bool arg5 = (bool) false ;
4482	>	int result;
4483	>	std::string temp2 ;
4484	>	std::string temp3 ;
4485	>	PyObject * obj0 = 0 ;
4486	>	PyObject * obj1 = 0 ;
4487	>	PyObject * obj2 = 0 ;
4488	>	PyObject * obj3 = 0 ;
4489	>	PyObject * obj4 = 0 ;
4490	>
4491	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_getOutput",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4492	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4493	>	if (obj1) {
4494	>	{
4495	>	if (PyString_Check(obj1)) {
4496	>	temp2 = std::string(PyString_AsString(obj1));
4497	>	arg2 = &temp2;
4498	>	}else {
4499	>	SWIG_exception(SWIG_TypeError, "string expected");
4500	>	}
4501	>	}
4502		}
4503	<	if (!ptr) {
4504	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
4503	>	if (obj2) {
4504	>	{
4505	>	if (PyString_Check(obj2)) {
4506	>	temp3 = std::string(PyString_AsString(obj2));
4507	>	arg3 = &temp3;
4508	>	}else {
4509	>	SWIG_exception(SWIG_TypeError, "string expected");
4510	>	}
4511	>	}
4512		}
4513	<	arg2 = ptr;
4514	<	}
4515	<	{
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""'");
4513	>	if (obj3) {
4514	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4515	>	if (PyErr_Occurred()) SWIG_fail;
4516		}
4517	<	arg3 = *ptr;
4518	<	if (SWIG_IsNewObj(res)) delete ptr;
4519	<	}
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""'");
4517	>	if (obj4) {
4518	>	arg5 = PyInt_AsLong(obj4) ? true : false;
4519	>	if (PyErr_Occurred()) SWIG_fail;
4520		}
4521	<	arg4 = *ptr;
4522	<	if (SWIG_IsNewObj(res)) delete ptr;
4523	<	}
4524	<	{
4525	<	try {
4526	<	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4);
4527	<	} catch (const std::exception& e) {
20518	<	SWIG_exception(SWIG_RuntimeError, e.what());
4521	>	{
4522	>	try {
4523	>	result = (int)(arg1)->getOutput((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
4524	>
4525	>	}catch (const std::exception& e) {
4526	>	SWIG_exception(SWIG_RuntimeError, e.what());
4527	>	}
4528		}
4529	<	}
4530	<	resultobj = SWIG_From_int(static_cast< int >(result));
4531	<	if (SWIG_IsNewObj(res2)) delete arg2;
4532	<	return resultobj;
20524	<	fail:
20525	<	if (SWIG_IsNewObj(res2)) delete arg2;
20526	<	return NULL;
4529	>	resultobj = PyInt_FromLong((long)result);
4530	>	return resultobj;
4531	>	fail:
4532	>	return NULL;
4533		}
4534
4535
4536	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4537	<	PyObject *resultobj = 0;
4538	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4539	<	std::string *arg2 = 0 ;
4540	<	std::string arg3 ;
4541	<	int result;
4542	<	void *argp1 = 0 ;
4543	<	int res1 = 0 ;
4544	<	int res2 = SWIG_OLDOBJ ;
4545	<	PyObject * obj0 = 0 ;
4546	<	PyObject * obj1 = 0 ;
4547	<	PyObject * obj2 = 0 ;
4548	<
4549	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2)) SWIG_fail;
4550	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
4551	<	if (!SWIG_IsOK(res1)) {
4552	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerProgram" "', argument " "1"" of type '" "BossAdministratorSession *""'");
4553	<	}
4554	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
4555	<	{
4556	<	std::string *ptr = (std::string *)0;
4557	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
4558	<	if (!SWIG_IsOK(res2)) {
4559	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
4560	<	}
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());
4536	>	static PyObject *_wrap_BossTask_getAllOutput(PyObject *self, PyObject *args) {
4537	>	PyObject *resultobj;
4538	>	BossTask *arg1 = (BossTask *) 0 ;
4539	>	std::string const &arg2_defvalue = "" ;
4540	>	std::string *arg2 = (std::string *) &arg2_defvalue ;
4541	>	bool arg3 = (bool) false ;
4542	>	bool arg4 = (bool) false ;
4543	>	int result;
4544	>	std::string temp2 ;
4545	>	PyObject * obj0 = 0 ;
4546	>	PyObject * obj1 = 0 ;
4547	>	PyObject * obj2 = 0 ;
4548	>	PyObject * obj3 = 0 ;
4549	>
4550	>	if(!PyArg_ParseTuple(args,(char *)"O|OOO:BossTask_getAllOutput",&obj0,&obj1,&obj2,&obj3)) goto fail;
4551	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4552	>	if (obj1) {
4553	>	{
4554	>	if (PyString_Check(obj1)) {
4555	>	temp2 = std::string(PyString_AsString(obj1));
4556	>	arg2 = &temp2;
4557	>	}else {
4558	>	SWIG_exception(SWIG_TypeError, "string expected");
4559	>	}
4560	>	}
4561		}
4562	<	}
4563	<	resultobj = SWIG_From_int(static_cast< int >(result));
4564	<	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 &""'");
4562	>	if (obj2) {
4563	>	arg3 = PyInt_AsLong(obj2) ? true : false;
4564	>	if (PyErr_Occurred()) SWIG_fail;
4565		}
4566	<	if (!ptr) {
4567	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerProgram" "', argument " "2"" of type '" "std::string const &""'");
4566	>	if (obj3) {
4567	>	arg4 = PyInt_AsLong(obj3) ? true : false;
4568	>	if (PyErr_Occurred()) SWIG_fail;
4569		}
4570	<	arg2 = ptr;
4571	<	}
4572	<	{
4573	<	try {
4574	<	result = (int)(arg1)->registerProgram((std::string const &)*arg2);
4575	<	} catch (const std::exception& e) {
4576	<	SWIG_exception(SWIG_RuntimeError, e.what());
4570	>	{
4571	>	try {
4572	>	result = (int)(arg1)->getAllOutput((std::string const &)*arg2,arg3,arg4);
4573	>
4574	>	}catch (const std::exception& e) {
4575	>	SWIG_exception(SWIG_RuntimeError, e.what());
4576	>	}
4577		}
4578	<	}
4579	<	resultobj = SWIG_From_int(static_cast< int >(result));
4580	<	if (SWIG_IsNewObj(res2)) delete arg2;
4581	<	return resultobj;
20623	<	fail:
20624	<	if (SWIG_IsNewObj(res2)) delete arg2;
20625	<	return NULL;
4578	>	resultobj = PyInt_FromLong((long)result);
4579	>	return resultobj;
4580	>	fail:
4581	>	return NULL;
4582		}
4583
4584
4585	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
4586	<	int argc;
4587	<	PyObject *argv[9];
4588	<	int ii;
4589	<
4590	<	if (!PyTuple_Check(args)) SWIG_fail;
4591	<	argc = PyObject_Length(args);
4592	<	for (ii = 0; (ii < argc) && (ii < 8); ii++) {
4593	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4594	<	}
4595	<	if (argc == 2) {
4596	<	int _v;
4597	<	void *vptr = 0;
4598	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
4599	<	_v = SWIG_CheckState(res);
4600	<	if (_v) {
4601	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4602	<	_v = SWIG_CheckState(res);
4603	<	if (_v) {
4604	<	return _wrap_BossAdministratorSession_registerProgram__SWIG_6(self, args);
4605	<	}
4606	<	}
4607	<	}
4608	<	if (argc == 3) {
4609	<	int _v;
4610	<	void *vptr = 0;
4611	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
4612	<	_v = SWIG_CheckState(res);
4613	<	if (_v) {
4614	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4615	<	_v = SWIG_CheckState(res);
4616	<	if (_v) {
4617	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
4618	<	_v = SWIG_CheckState(res);
20663	<	if (_v) {
20664	<	return _wrap_BossAdministratorSession_registerProgram__SWIG_5(self, args);
20665	<	}
20666	<	}
20667	<	}
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	<	}
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);
4585	>	static PyObject *_wrap_BossTask_query(PyObject *self, PyObject *args) {
4586	>	PyObject *resultobj;
4587	>	BossTask *arg1 = (BossTask *) 0 ;
4588	>	int arg2 = (int) SCHEDULED ;
4589	>	std::string const &arg3_defvalue = "all" ;
4590	>	std::string *arg3 = (std::string *) &arg3_defvalue ;
4591	>	std::string const &arg4_defvalue = "" ;
4592	>	std::string *arg4 = (std::string *) &arg4_defvalue ;
4593	>	std::string arg5 = (std::string) "" ;
4594	>	std::string arg6 = (std::string) "" ;
4595	>	std::string arg7 = (std::string) "" ;
4596	>	std::string arg8 = (std::string) "" ;
4597	>	bool arg9 = (bool) false ;
4598	>	int result;
4599	>	std::string temp3 ;
4600	>	std::string temp4 ;
4601	>	PyObject * obj0 = 0 ;
4602	>	PyObject * obj2 = 0 ;
4603	>	PyObject * obj3 = 0 ;
4604	>	PyObject * obj4 = 0 ;
4605	>	PyObject * obj5 = 0 ;
4606	>	PyObject * obj6 = 0 ;
4607	>	PyObject * obj7 = 0 ;
4608	>	PyObject * obj8 = 0 ;
4609	>
4610	>	if(!PyArg_ParseTuple(args,(char *)"O|iOOOOOOO:BossTask_query",&obj0,&arg2,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4611	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4612	>	if (obj2) {
4613	>	{
4614	>	if (PyString_Check(obj2)) {
4615	>	temp3 = std::string(PyString_AsString(obj2));
4616	>	arg3 = &temp3;
4617	>	}else {
4618	>	SWIG_exception(SWIG_TypeError, "string expected");
4619		}
20710	–	}
4620		}
20712	–	}
4621		}
4622	<	}
4623	<	if (argc == 6) {
4624	<	int _v;
4625	<	void *vptr = 0;
4626	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
4627	<	_v = SWIG_CheckState(res);
4628	<	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	<	}
4622	>	if (obj3) {
4623	>	{
4624	>	if (PyString_Check(obj3)) {
4625	>	temp4 = std::string(PyString_AsString(obj3));
4626	>	arg4 = &temp4;
4627	>	}else {
4628	>	SWIG_exception(SWIG_TypeError, "string expected");
4629		}
20739	–	}
4630		}
20741	–	}
4631		}
4632	<	}
4633	<	if (argc == 7) {
4634	<	int _v;
4635	<	void *vptr = 0;
4636	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
4637	<	_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	<	}
4632	>	if (obj4) {
4633	>	{
4634	>	if (PyString_Check(obj4))
4635	>	arg5 = std::string(PyString_AsString(obj4));
4636	>	else
4637	>	SWIG_exception(SWIG_TypeError, "string expected");
4638		}
20774	–	}
4639		}
4640	<	}
4641	<	if (argc == 8) {
4642	<	int _v;
4643	<	void *vptr = 0;
4644	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
4645	<	_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	<	}
4640	>	if (obj5) {
4641	>	{
4642	>	if (PyString_Check(obj5))
4643	>	arg6 = std::string(PyString_AsString(obj5));
4644	>	else
4645	>	SWIG_exception(SWIG_TypeError, "string expected");
4646		}
20813	–	}
20814	–	}
20815	–	}
20816	–
20817	–	fail:
20818	–	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_registerProgram'");
20819	–	return NULL;
20820	–	}
20821	–
20822	–
20823	–	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20824	–	PyObject *resultobj = 0;
20825	–	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20826	–	std::string *arg2 = 0 ;
20827	–	std::string arg3 ;
20828	–	std::string arg4 ;
20829	–	std::string arg5 ;
20830	–	bool arg6 ;
20831	–	bool arg7 ;
20832	–	int result;
20833	–	void *argp1 = 0 ;
20834	–	int res1 = 0 ;
20835	–	int res2 = SWIG_OLDOBJ ;
20836	–	bool val6 ;
20837	–	int ecode6 = 0 ;
20838	–	bool val7 ;
20839	–	int ecode7 = 0 ;
20840	–	PyObject * obj0 = 0 ;
20841	–	PyObject * obj1 = 0 ;
20842	–	PyObject * obj2 = 0 ;
20843	–	PyObject * obj3 = 0 ;
20844	–	PyObject * obj4 = 0 ;
20845	–	PyObject * obj5 = 0 ;
20846	–	PyObject * obj6 = 0 ;
20847	–
20848	–	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
20849	–	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20850	–	if (!SWIG_IsOK(res1)) {
20851	–	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20852	–	}
20853	–	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20854	–	{
20855	–	std::string *ptr = (std::string *)0;
20856	–	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20857	–	if (!SWIG_IsOK(res2)) {
20858	–	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
20859	–	}
20860	–	if (!ptr) {
20861	–	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
20862	–	}
20863	–	arg2 = ptr;
20864	–	}
20865	–	{
20866	–	std::string *ptr = (std::string *)0;
20867	–	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20868	–	if (!SWIG_IsOK(res) || !ptr) {
20869	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
20870	–	}
20871	–	arg3 = *ptr;
20872	–	if (SWIG_IsNewObj(res)) delete ptr;
20873	–	}
20874	–	{
20875	–	std::string *ptr = (std::string *)0;
20876	–	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20877	–	if (!SWIG_IsOK(res) || !ptr) {
20878	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "4"" of type '" "std::string""'");
20879	–	}
20880	–	arg4 = *ptr;
20881	–	if (SWIG_IsNewObj(res)) delete ptr;
20882	–	}
20883	–	{
20884	–	std::string *ptr = (std::string *)0;
20885	–	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20886	–	if (!SWIG_IsOK(res) || !ptr) {
20887	–	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "5"" of type '" "std::string""'");
20888	–	}
20889	–	arg5 = *ptr;
20890	–	if (SWIG_IsNewObj(res)) delete ptr;
20891	–	}
20892	–	ecode6 = SWIG_AsVal_bool(obj5, &val6);
20893	–	if (!SWIG_IsOK(ecode6)) {
20894	–	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "6"" of type '" "bool""'");
20895	–	}
20896	–	arg6 = static_cast< bool >(val6);
20897	–	ecode7 = SWIG_AsVal_bool(obj6, &val7);
20898	–	if (!SWIG_IsOK(ecode7)) {
20899	–	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "7"" of type '" "bool""'");
20900	–	}
20901	–	arg7 = static_cast< bool >(val7);
20902	–	{
20903	–	try {
20904	–	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
20905	–	} catch (const std::exception& e) {
20906	–	SWIG_exception(SWIG_RuntimeError, e.what());
4647		}
4648	<	}
4649	<	resultobj = SWIG_From_int(static_cast< int >(result));
4650	<	if (SWIG_IsNewObj(res2)) delete arg2;
4651	<	return resultobj;
4652	<	fail:
4653	<	if (SWIG_IsNewObj(res2)) delete arg2;
4654	<	return NULL;
20915	<	}
20916	<
20917	<
20918	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20919	<	PyObject *resultobj = 0;
20920	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
20921	<	std::string *arg2 = 0 ;
20922	<	std::string arg3 ;
20923	<	std::string arg4 ;
20924	<	std::string arg5 ;
20925	<	bool arg6 ;
20926	<	int result;
20927	<	void *argp1 = 0 ;
20928	<	int res1 = 0 ;
20929	<	int res2 = SWIG_OLDOBJ ;
20930	<	bool val6 ;
20931	<	int ecode6 = 0 ;
20932	<	PyObject * obj0 = 0 ;
20933	<	PyObject * obj1 = 0 ;
20934	<	PyObject * obj2 = 0 ;
20935	<	PyObject * obj3 = 0 ;
20936	<	PyObject * obj4 = 0 ;
20937	<	PyObject * obj5 = 0 ;
20938	<
20939	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
20940	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
20941	<	if (!SWIG_IsOK(res1)) {
20942	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
20943	<	}
20944	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
20945	<	{
20946	<	std::string *ptr = (std::string *)0;
20947	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
20948	<	if (!SWIG_IsOK(res2)) {
20949	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
20950	<	}
20951	<	if (!ptr) {
20952	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
20953	<	}
20954	<	arg2 = ptr;
20955	<	}
20956	<	{
20957	<	std::string *ptr = (std::string *)0;
20958	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
20959	<	if (!SWIG_IsOK(res) || !ptr) {
20960	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
20961	<	}
20962	<	arg3 = *ptr;
20963	<	if (SWIG_IsNewObj(res)) delete ptr;
20964	<	}
20965	<	{
20966	<	std::string *ptr = (std::string *)0;
20967	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
20968	<	if (!SWIG_IsOK(res) || !ptr) {
20969	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "4"" of type '" "std::string""'");
20970	<	}
20971	<	arg4 = *ptr;
20972	<	if (SWIG_IsNewObj(res)) delete ptr;
20973	<	}
20974	<	{
20975	<	std::string *ptr = (std::string *)0;
20976	<	int res = SWIG_AsPtr_std_string(obj4, &ptr);
20977	<	if (!SWIG_IsOK(res) || !ptr) {
20978	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "5"" of type '" "std::string""'");
20979	<	}
20980	<	arg5 = *ptr;
20981	<	if (SWIG_IsNewObj(res)) delete ptr;
20982	<	}
20983	<	ecode6 = SWIG_AsVal_bool(obj5, &val6);
20984	<	if (!SWIG_IsOK(ecode6)) {
20985	<	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "6"" of type '" "bool""'");
20986	<	}
20987	<	arg6 = static_cast< bool >(val6);
20988	<	{
20989	<	try {
20990	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6);
20991	<	} catch (const std::exception& e) {
20992	<	SWIG_exception(SWIG_RuntimeError, e.what());
20993	<	}
20994	<	}
20995	<	resultobj = SWIG_From_int(static_cast< int >(result));
20996	<	if (SWIG_IsNewObj(res2)) delete arg2;
20997	<	return resultobj;
20998	<	fail:
20999	<	if (SWIG_IsNewObj(res2)) delete arg2;
21000	<	return NULL;
21001	<	}
21002	<
21003	<
21004	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21005	<	PyObject *resultobj = 0;
21006	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21007	<	std::string *arg2 = 0 ;
21008	<	std::string arg3 ;
21009	<	std::string arg4 ;
21010	<	std::string arg5 ;
21011	<	int result;
21012	<	void *argp1 = 0 ;
21013	<	int res1 = 0 ;
21014	<	int res2 = SWIG_OLDOBJ ;
21015	<	PyObject * obj0 = 0 ;
21016	<	PyObject * obj1 = 0 ;
21017	<	PyObject * obj2 = 0 ;
21018	<	PyObject * obj3 = 0 ;
21019	<	PyObject * obj4 = 0 ;
21020	<
21021	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21022	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21023	<	if (!SWIG_IsOK(res1)) {
21024	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21025	<	}
21026	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21027	<	{
21028	<	std::string *ptr = (std::string *)0;
21029	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21030	<	if (!SWIG_IsOK(res2)) {
21031	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21032	<	}
21033	<	if (!ptr) {
21034	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21035	<	}
21036	<	arg2 = ptr;
21037	<	}
21038	<	{
21039	<	std::string *ptr = (std::string *)0;
21040	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21041	<	if (!SWIG_IsOK(res) || !ptr) {
21042	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
21043	<	}
21044	<	arg3 = *ptr;
21045	<	if (SWIG_IsNewObj(res)) delete ptr;
21046	<	}
21047	<	{
21048	<	std::string *ptr = (std::string *)0;
21049	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21050	<	if (!SWIG_IsOK(res) || !ptr) {
21051	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "4"" of type '" "std::string""'");
21052	<	}
21053	<	arg4 = *ptr;
21054	<	if (SWIG_IsNewObj(res)) delete ptr;
21055	<	}
21056	<	{
21057	<	std::string *ptr = (std::string *)0;
21058	<	int res = SWIG_AsPtr_std_string(obj4, &ptr);
21059	<	if (!SWIG_IsOK(res) || !ptr) {
21060	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "5"" of type '" "std::string""'");
21061	<	}
21062	<	arg5 = *ptr;
21063	<	if (SWIG_IsNewObj(res)) delete ptr;
21064	<	}
21065	<	{
21066	<	try {
21067	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5);
21068	<	} catch (const std::exception& e) {
21069	<	SWIG_exception(SWIG_RuntimeError, e.what());
21070	<	}
21071	<	}
21072	<	resultobj = SWIG_From_int(static_cast< int >(result));
21073	<	if (SWIG_IsNewObj(res2)) delete arg2;
21074	<	return resultobj;
21075	<	fail:
21076	<	if (SWIG_IsNewObj(res2)) delete arg2;
21077	<	return NULL;
21078	<	}
21079	<
21080	<
21081	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21082	<	PyObject *resultobj = 0;
21083	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21084	<	std::string *arg2 = 0 ;
21085	<	std::string arg3 ;
21086	<	std::string arg4 ;
21087	<	int result;
21088	<	void *argp1 = 0 ;
21089	<	int res1 = 0 ;
21090	<	int res2 = SWIG_OLDOBJ ;
21091	<	PyObject * obj0 = 0 ;
21092	<	PyObject * obj1 = 0 ;
21093	<	PyObject * obj2 = 0 ;
21094	<	PyObject * obj3 = 0 ;
21095	<
21096	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21097	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21098	<	if (!SWIG_IsOK(res1)) {
21099	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21100	<	}
21101	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21102	<	{
21103	<	std::string *ptr = (std::string *)0;
21104	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21105	<	if (!SWIG_IsOK(res2)) {
21106	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21107	<	}
21108	<	if (!ptr) {
21109	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21110	<	}
21111	<	arg2 = ptr;
21112	<	}
21113	<	{
21114	<	std::string *ptr = (std::string *)0;
21115	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21116	<	if (!SWIG_IsOK(res) || !ptr) {
21117	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
21118	<	}
21119	<	arg3 = *ptr;
21120	<	if (SWIG_IsNewObj(res)) delete ptr;
21121	<	}
21122	<	{
21123	<	std::string *ptr = (std::string *)0;
21124	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21125	<	if (!SWIG_IsOK(res) || !ptr) {
21126	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "4"" of type '" "std::string""'");
21127	<	}
21128	<	arg4 = *ptr;
21129	<	if (SWIG_IsNewObj(res)) delete ptr;
21130	<	}
21131	<	{
21132	<	try {
21133	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4);
21134	<	} catch (const std::exception& e) {
21135	<	SWIG_exception(SWIG_RuntimeError, e.what());
21136	<	}
21137	<	}
21138	<	resultobj = SWIG_From_int(static_cast< int >(result));
21139	<	if (SWIG_IsNewObj(res2)) delete arg2;
21140	<	return resultobj;
21141	<	fail:
21142	<	if (SWIG_IsNewObj(res2)) delete arg2;
21143	<	return NULL;
21144	<	}
21145	<
21146	<
21147	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21148	<	PyObject *resultobj = 0;
21149	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
21150	<	std::string *arg2 = 0 ;
21151	<	std::string arg3 ;
21152	<	int result;
21153	<	void *argp1 = 0 ;
21154	<	int res1 = 0 ;
21155	<	int res2 = SWIG_OLDOBJ ;
21156	<	PyObject * obj0 = 0 ;
21157	<	PyObject * obj1 = 0 ;
21158	<	PyObject * obj2 = 0 ;
21159	<
21160	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2)) SWIG_fail;
21161	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21162	<	if (!SWIG_IsOK(res1)) {
21163	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21164	<	}
21165	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21166	<	{
21167	<	std::string *ptr = (std::string *)0;
21168	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21169	<	if (!SWIG_IsOK(res2)) {
21170	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21171	<	}
21172	<	if (!ptr) {
21173	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
21174	<	}
21175	<	arg2 = ptr;
21176	<	}
21177	<	{
21178	<	std::string *ptr = (std::string *)0;
21179	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21180	<	if (!SWIG_IsOK(res) || !ptr) {
21181	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerRTMon" "', argument " "3"" of type '" "std::string""'");
21182	<	}
21183	<	arg3 = *ptr;
21184	<	if (SWIG_IsNewObj(res)) delete ptr;
21185	<	}
21186	<	{
21187	<	try {
21188	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3);
21189	<	} catch (const std::exception& e) {
21190	<	SWIG_exception(SWIG_RuntimeError, e.what());
4648	>	if (obj6) {
4649	>	{
4650	>	if (PyString_Check(obj6))
4651	>	arg7 = std::string(PyString_AsString(obj6));
4652	>	else
4653	>	SWIG_exception(SWIG_TypeError, "string expected");
4654	>	}
4655		}
4656	<	}
4657	<	resultobj = SWIG_From_int(static_cast< int >(result));
4658	<	if (SWIG_IsNewObj(res2)) delete arg2;
4659	<	return resultobj;
4660	<	fail:
4661	<	if (SWIG_IsNewObj(res2)) delete arg2;
4662	<	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 &""'");
4656	>	if (obj7) {
4657	>	{
4658	>	if (PyString_Check(obj7))
4659	>	arg8 = std::string(PyString_AsString(obj7));
4660	>	else
4661	>	SWIG_exception(SWIG_TypeError, "string expected");
4662	>	}
4663		}
4664	<	if (!ptr) {
4665	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerRTMon" "', argument " "2"" of type '" "std::string const &""'");
4664	>	if (obj8) {
4665	>	arg9 = PyInt_AsLong(obj8) ? true : false;
4666	>	if (PyErr_Occurred()) SWIG_fail;
4667		}
4668	<	arg2 = ptr;
4669	<	}
4670	<	{
4671	<	try {
4672	<	result = (int)(arg1)->registerRTMon((std::string const &)*arg2);
4673	<	} catch (const std::exception& e) {
4674	<	SWIG_exception(SWIG_RuntimeError, e.what());
4668	>	{
4669	>	try {
4670	>	result = (int)(arg1)->query(arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7,arg8,arg9);
4671	>
4672	>	}catch (const std::exception& e) {
4673	>	SWIG_exception(SWIG_RuntimeError, e.what());
4674	>	}
4675		}
4676	<	}
4677	<	resultobj = SWIG_From_int(static_cast< int >(result));
4678	<	if (SWIG_IsNewObj(res2)) delete arg2;
4679	<	return resultobj;
21240	<	fail:
21241	<	if (SWIG_IsNewObj(res2)) delete arg2;
21242	<	return NULL;
4676	>	resultobj = PyInt_FromLong((long)result);
4677	>	return resultobj;
4678	>	fail:
4679	>	return NULL;
4680		}
4681
4682
4683	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
4684	<	int argc;
4685	<	PyObject *argv[8];
4686	<	int ii;
4687	<
4688	<	if (!PyTuple_Check(args)) SWIG_fail;
4689	<	argc = PyObject_Length(args);
4690	<	for (ii = 0; (ii < argc) && (ii < 7); ii++) {
4691	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
4692	<	}
4693	<	if (argc == 2) {
4694	<	int _v;
4695	<	void *vptr = 0;
4696	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
4697	<	_v = SWIG_CheckState(res);
4698	<	if (_v) {
4699	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
4700	<	_v = SWIG_CheckState(res);
4701	<	if (_v) {
4702	<	return _wrap_BossAdministratorSession_registerRTMon__SWIG_5(self, args);
4703	<	}
4704	<	}
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);
4683	>	static PyObject *_wrap_BossTask_query_out(PyObject *self, PyObject *args) {
4684	>	PyObject *resultobj;
4685	>	BossTask *arg1 = (BossTask *) 0 ;
4686	>	std::ostream &arg2_defvalue = std::cout ;
4687	>	std::ostream *arg2 = (std::ostream *) &arg2_defvalue ;
4688	>	jobStates const &arg3_defvalue = SCHEDULED ;
4689	>	jobStates *arg3 = (jobStates *) &arg3_defvalue ;
4690	>	printOption const &arg4_defvalue = NORMAL ;
4691	>	printOption *arg4 = (printOption *) &arg4_defvalue ;
4692	>	std::string arg5 = (std::string) "" ;
4693	>	PyObject * obj0 = 0 ;
4694	>	PyObject * obj1 = 0 ;
4695	>	PyObject * obj2 = 0 ;
4696	>	PyObject * obj3 = 0 ;
4697	>	PyObject * obj4 = 0 ;
4698	>
4699	>	if(!PyArg_ParseTuple(args,(char *)"O|OOOO:BossTask_query_out",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4700	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4701	>	if (obj1) {
4702	>	if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_std__ostream,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4703	>	if (arg2 == NULL) {
4704	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
4705		}
21283	–	}
4706		}
4707	<	}
4708	<	if (argc == 4) {
4709	<	int _v;
4710	<	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	<	}
4707	>	if (obj2) {
4708	>	if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_jobStates,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4709	>	if (arg3 == NULL) {
4710	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
4711		}
21304	–	}
4712		}
4713	<	}
4714	<	if (argc == 5) {
4715	<	int _v;
4716	<	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	<	}
4713	>	if (obj3) {
4714	>	if ((SWIG_ConvertPtr(obj3,(void **) &arg4, SWIGTYPE_p_printOption,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4715	>	if (arg4 == NULL) {
4716	>	PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail;
4717		}
21329	–	}
4718		}
4719	<	}
4720	<	if (argc == 6) {
4721	<	int _v;
4722	<	void *vptr = 0;
4723	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
4724	<	_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	<	}
4719	>	if (obj4) {
4720	>	{
4721	>	if (PyString_Check(obj4))
4722	>	arg5 = std::string(PyString_AsString(obj4));
4723	>	else
4724	>	SWIG_exception(SWIG_TypeError, "string expected");
4725		}
21360	–	}
4726		}
4727	<	}
4728	<	if (argc == 7) {
4729	<	int _v;
4730	<	void *vptr = 0;
4731	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
4732	<	_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	<	}
4727	>	{
4728	>	try {
4729	>	((BossTask const *)arg1)->query_out(*arg2,(jobStates const &)*arg3,(printOption const &)*arg4,arg5);
4730	>
4731	>	}catch (const std::exception& e) {
4732	>	SWIG_exception(SWIG_RuntimeError, e.what());
4733		}
21397	–	}
4734		}
4735	<	}
4736	<
4737	<	fail:
4738	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_registerRTMon'");
21403	<	return NULL;
4735	>	Py_INCREF(Py_None); resultobj = Py_None;
4736	>	return resultobj;
4737	>	fail:
4738	>	return NULL;
4739		}
4740
4741
4742	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4743	<	PyObject *resultobj = 0;
4744	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4745	<	std::string *arg2 = 0 ;
4746	<	std::string arg3 ;
4747	<	std::string arg4 ;
4748	<	std::string arg5 ;
4749	<	std::string arg6 ;
4750	<	std::string arg7 ;
4751	<	std::string arg8 ;
4752	<	std::string arg9 ;
4753	<	std::string arg10 ;
4754	<	std::string *arg11 = 0 ;
4755	<	std::string arg12 ;
21421	<	std::string arg13 ;
21422	<	bool arg14 ;
21423	<	bool arg15 ;
21424	<	int result;
21425	<	void *argp1 = 0 ;
21426	<	int res1 = 0 ;
21427	<	int res2 = SWIG_OLDOBJ ;
21428	<	int res11 = SWIG_OLDOBJ ;
21429	<	bool val14 ;
21430	<	int ecode14 = 0 ;
21431	<	bool val15 ;
21432	<	int ecode15 = 0 ;
21433	<	PyObject * obj0 = 0 ;
21434	<	PyObject * obj1 = 0 ;
21435	<	PyObject * obj2 = 0 ;
21436	<	PyObject * obj3 = 0 ;
21437	<	PyObject * obj4 = 0 ;
21438	<	PyObject * obj5 = 0 ;
21439	<	PyObject * obj6 = 0 ;
21440	<	PyObject * obj7 = 0 ;
21441	<	PyObject * obj8 = 0 ;
21442	<	PyObject * obj9 = 0 ;
21443	<	PyObject * obj10 = 0 ;
21444	<	PyObject * obj11 = 0 ;
21445	<	PyObject * obj12 = 0 ;
21446	<	PyObject * obj13 = 0 ;
21447	<	PyObject * obj14 = 0 ;
21448	<
21449	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
21450	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21451	<	if (!SWIG_IsOK(res1)) {
21452	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21453	<	}
21454	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21455	<	{
21456	<	std::string *ptr = (std::string *)0;
21457	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21458	<	if (!SWIG_IsOK(res2)) {
21459	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21460	<	}
21461	<	if (!ptr) {
21462	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21463	<	}
21464	<	arg2 = ptr;
21465	<	}
21466	<	{
21467	<	std::string *ptr = (std::string *)0;
21468	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21469	<	if (!SWIG_IsOK(res) || !ptr) {
21470	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
21471	<	}
21472	<	arg3 = *ptr;
21473	<	if (SWIG_IsNewObj(res)) delete ptr;
21474	<	}
21475	<	{
21476	<	std::string *ptr = (std::string *)0;
21477	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21478	<	if (!SWIG_IsOK(res) || !ptr) {
21479	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
21480	<	}
21481	<	arg4 = *ptr;
21482	<	if (SWIG_IsNewObj(res)) delete ptr;
21483	<	}
21484	<	{
21485	<	std::string *ptr = (std::string *)0;
21486	<	int res = SWIG_AsPtr_std_string(obj4, &ptr);
21487	<	if (!SWIG_IsOK(res) || !ptr) {
21488	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
21489	<	}
21490	<	arg5 = *ptr;
21491	<	if (SWIG_IsNewObj(res)) delete ptr;
21492	<	}
21493	<	{
21494	<	std::string *ptr = (std::string *)0;
21495	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
21496	<	if (!SWIG_IsOK(res) || !ptr) {
21497	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
21498	<	}
21499	<	arg6 = *ptr;
21500	<	if (SWIG_IsNewObj(res)) delete ptr;
21501	<	}
21502	<	{
21503	<	std::string *ptr = (std::string *)0;
21504	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
21505	<	if (!SWIG_IsOK(res) || !ptr) {
21506	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
21507	<	}
21508	<	arg7 = *ptr;
21509	<	if (SWIG_IsNewObj(res)) delete ptr;
21510	<	}
21511	<	{
21512	<	std::string *ptr = (std::string *)0;
21513	<	int res = SWIG_AsPtr_std_string(obj7, &ptr);
21514	<	if (!SWIG_IsOK(res) || !ptr) {
21515	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
21516	<	}
21517	<	arg8 = *ptr;
21518	<	if (SWIG_IsNewObj(res)) delete ptr;
21519	<	}
21520	<	{
21521	<	std::string *ptr = (std::string *)0;
21522	<	int res = SWIG_AsPtr_std_string(obj8, &ptr);
21523	<	if (!SWIG_IsOK(res) || !ptr) {
21524	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
21525	<	}
21526	<	arg9 = *ptr;
21527	<	if (SWIG_IsNewObj(res)) delete ptr;
21528	<	}
21529	<	{
21530	<	std::string *ptr = (std::string *)0;
21531	<	int res = SWIG_AsPtr_std_string(obj9, &ptr);
21532	<	if (!SWIG_IsOK(res) || !ptr) {
21533	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
21534	<	}
21535	<	arg10 = *ptr;
21536	<	if (SWIG_IsNewObj(res)) delete ptr;
21537	<	}
21538	<	{
21539	<	std::string *ptr = (std::string *)0;
21540	<	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
21541	<	if (!SWIG_IsOK(res11)) {
21542	<	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21543	<	}
21544	<	if (!ptr) {
21545	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21546	<	}
21547	<	arg11 = ptr;
21548	<	}
21549	<	{
21550	<	std::string *ptr = (std::string *)0;
21551	<	int res = SWIG_AsPtr_std_string(obj11, &ptr);
21552	<	if (!SWIG_IsOK(res) || !ptr) {
21553	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "12"" of type '" "std::string""'");
21554	<	}
21555	<	arg12 = *ptr;
21556	<	if (SWIG_IsNewObj(res)) delete ptr;
21557	<	}
21558	<	{
21559	<	std::string *ptr = (std::string *)0;
21560	<	int res = SWIG_AsPtr_std_string(obj12, &ptr);
21561	<	if (!SWIG_IsOK(res) || !ptr) {
21562	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "13"" of type '" "std::string""'");
21563	<	}
21564	<	arg13 = *ptr;
21565	<	if (SWIG_IsNewObj(res)) delete ptr;
21566	<	}
21567	<	ecode14 = SWIG_AsVal_bool(obj13, &val14);
21568	<	if (!SWIG_IsOK(ecode14)) {
21569	<	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "14"" of type '" "bool""'");
21570	<	}
21571	<	arg14 = static_cast< bool >(val14);
21572	<	ecode15 = SWIG_AsVal_bool(obj14, &val15);
21573	<	if (!SWIG_IsOK(ecode15)) {
21574	<	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "15"" of type '" "bool""'");
21575	<	}
21576	<	arg15 = static_cast< bool >(val15);
21577	<	{
21578	<	try {
21579	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
21580	<	} catch (const std::exception& e) {
21581	<	SWIG_exception(SWIG_RuntimeError, e.what());
4742	>	static PyObject *_wrap_BossTask_clear(PyObject *self, PyObject *args) {
4743	>	PyObject *resultobj;
4744	>	BossTask *arg1 = (BossTask *) 0 ;
4745	>	PyObject * obj0 = 0 ;
4746	>
4747	>	if(!PyArg_ParseTuple(args,(char *)"O:BossTask_clear",&obj0)) goto fail;
4748	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossTask,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4749	>	{
4750	>	try {
4751	>	(arg1)->clear();
4752	>
4753	>	}catch (const std::exception& e) {
4754	>	SWIG_exception(SWIG_RuntimeError, e.what());
4755	>	}
4756		}
4757	<	}
4758	<	resultobj = SWIG_From_int(static_cast< int >(result));
4759	<	if (SWIG_IsNewObj(res2)) delete arg2;
4760	<	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;
4757	>	Py_INCREF(Py_None); resultobj = Py_None;
4758	>	return resultobj;
4759	>	fail:
4760	>	return NULL;
4761		}
4762
4763
4764	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4765	<	PyObject *resultobj = 0;
4766	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4767	<	std::string *arg2 = 0 ;
4768	<	std::string arg3 ;
4769	<	std::string arg4 ;
4770	<	std::string arg5 ;
4771	<	std::string arg6 ;
4772	<	std::string arg7 ;
4773	<	std::string arg8 ;
4774	<	std::string arg9 ;
4775	<	std::string arg10 ;
4776	<	std::string *arg11 = 0 ;
4777	<	std::string arg12 ;
4778	<	std::string arg13 ;
4779	<	bool arg14 ;
4780	<	int result;
4781	<	void *argp1 = 0 ;
4782	<	int res1 = 0 ;
4783	<	int res2 = SWIG_OLDOBJ ;
4784	<	int res11 = SWIG_OLDOBJ ;
4785	<	bool val14 ;
21617	<	int ecode14 = 0 ;
21618	<	PyObject * obj0 = 0 ;
21619	<	PyObject * obj1 = 0 ;
21620	<	PyObject * obj2 = 0 ;
21621	<	PyObject * obj3 = 0 ;
21622	<	PyObject * obj4 = 0 ;
21623	<	PyObject * obj5 = 0 ;
21624	<	PyObject * obj6 = 0 ;
21625	<	PyObject * obj7 = 0 ;
21626	<	PyObject * obj8 = 0 ;
21627	<	PyObject * obj9 = 0 ;
21628	<	PyObject * obj10 = 0 ;
21629	<	PyObject * obj11 = 0 ;
21630	<	PyObject * obj12 = 0 ;
21631	<	PyObject * obj13 = 0 ;
21632	<
21633	<	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
21634	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
21635	<	if (!SWIG_IsOK(res1)) {
21636	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
21637	<	}
21638	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
21639	<	{
21640	<	std::string *ptr = (std::string *)0;
21641	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
21642	<	if (!SWIG_IsOK(res2)) {
21643	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21644	<	}
21645	<	if (!ptr) {
21646	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
21647	<	}
21648	<	arg2 = ptr;
21649	<	}
21650	<	{
21651	<	std::string *ptr = (std::string *)0;
21652	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
21653	<	if (!SWIG_IsOK(res) || !ptr) {
21654	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
21655	<	}
21656	<	arg3 = *ptr;
21657	<	if (SWIG_IsNewObj(res)) delete ptr;
21658	<	}
21659	<	{
21660	<	std::string *ptr = (std::string *)0;
21661	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
21662	<	if (!SWIG_IsOK(res) || !ptr) {
21663	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "4"" of type '" "std::string""'");
21664	<	}
21665	<	arg4 = *ptr;
21666	<	if (SWIG_IsNewObj(res)) delete ptr;
21667	<	}
21668	<	{
21669	<	std::string *ptr = (std::string *)0;
21670	<	int res = SWIG_AsPtr_std_string(obj4, &ptr);
21671	<	if (!SWIG_IsOK(res) || !ptr) {
21672	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "5"" of type '" "std::string""'");
21673	<	}
21674	<	arg5 = *ptr;
21675	<	if (SWIG_IsNewObj(res)) delete ptr;
21676	<	}
21677	<	{
21678	<	std::string *ptr = (std::string *)0;
21679	<	int res = SWIG_AsPtr_std_string(obj5, &ptr);
21680	<	if (!SWIG_IsOK(res) || !ptr) {
21681	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "6"" of type '" "std::string""'");
21682	<	}
21683	<	arg6 = *ptr;
21684	<	if (SWIG_IsNewObj(res)) delete ptr;
21685	<	}
21686	<	{
21687	<	std::string *ptr = (std::string *)0;
21688	<	int res = SWIG_AsPtr_std_string(obj6, &ptr);
21689	<	if (!SWIG_IsOK(res) || !ptr) {
21690	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "7"" of type '" "std::string""'");
21691	<	}
21692	<	arg7 = *ptr;
21693	<	if (SWIG_IsNewObj(res)) delete ptr;
21694	<	}
21695	<	{
21696	<	std::string *ptr = (std::string *)0;
21697	<	int res = SWIG_AsPtr_std_string(obj7, &ptr);
21698	<	if (!SWIG_IsOK(res) || !ptr) {
21699	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "8"" of type '" "std::string""'");
21700	<	}
21701	<	arg8 = *ptr;
21702	<	if (SWIG_IsNewObj(res)) delete ptr;
21703	<	}
21704	<	{
21705	<	std::string *ptr = (std::string *)0;
21706	<	int res = SWIG_AsPtr_std_string(obj8, &ptr);
21707	<	if (!SWIG_IsOK(res) || !ptr) {
21708	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "9"" of type '" "std::string""'");
21709	<	}
21710	<	arg9 = *ptr;
21711	<	if (SWIG_IsNewObj(res)) delete ptr;
21712	<	}
21713	<	{
21714	<	std::string *ptr = (std::string *)0;
21715	<	int res = SWIG_AsPtr_std_string(obj9, &ptr);
21716	<	if (!SWIG_IsOK(res) || !ptr) {
21717	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "10"" of type '" "std::string""'");
21718	<	}
21719	<	arg10 = *ptr;
21720	<	if (SWIG_IsNewObj(res)) delete ptr;
21721	<	}
21722	<	{
21723	<	std::string *ptr = (std::string *)0;
21724	<	res11 = SWIG_AsPtr_std_string(obj10, &ptr);
21725	<	if (!SWIG_IsOK(res11)) {
21726	<	SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21727	<	}
21728	<	if (!ptr) {
21729	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "11"" of type '" "std::string const &""'");
21730	<	}
21731	<	arg11 = ptr;
21732	<	}
21733	<	{
21734	<	std::string *ptr = (std::string *)0;
21735	<	int res = SWIG_AsPtr_std_string(obj11, &ptr);
21736	<	if (!SWIG_IsOK(res) || !ptr) {
21737	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "12"" of type '" "std::string""'");
21738	<	}
21739	<	arg12 = *ptr;
21740	<	if (SWIG_IsNewObj(res)) delete ptr;
21741	<	}
21742	<	{
21743	<	std::string *ptr = (std::string *)0;
21744	<	int res = SWIG_AsPtr_std_string(obj12, &ptr);
21745	<	if (!SWIG_IsOK(res) || !ptr) {
21746	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "13"" of type '" "std::string""'");
4764	>	static PyObject * BossTask_swigregister(PyObject *self, PyObject *args) {
4765	>	PyObject *obj;
4766	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4767	>	SWIG_TypeClientData(SWIGTYPE_p_BossTask, obj);
4768	>	Py_INCREF(obj);
4769	>	return Py_BuildValue((char *)"");
4770	>	}
4771	>	static PyObject *_wrap_prompt(PyObject *self, PyObject *args) {
4772	>	PyObject *resultobj;
4773	>	std::string *arg1 = 0 ;
4774	>	bool result;
4775	>	std::string temp1 ;
4776	>	PyObject * obj0 = 0 ;
4777	>
4778	>	if(!PyArg_ParseTuple(args,(char *)"O:prompt",&obj0)) goto fail;
4779	>	{
4780	>	if (PyString_Check(obj0)) {
4781	>	temp1 = std::string(PyString_AsString(obj0));
4782	>	arg1 = &temp1;
4783	>	}else {
4784	>	SWIG_exception(SWIG_TypeError, "string expected");
4785	>	}
4786		}
4787	<	arg13 = *ptr;
4788	<	if (SWIG_IsNewObj(res)) delete ptr;
4789	<	}
4790	<	ecode14 = SWIG_AsVal_bool(obj13, &val14);
4791	<	if (!SWIG_IsOK(ecode14)) {
4792	<	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "14"" of type '" "bool""'");
4793	<	}
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());
4787	>	{
4788	>	try {
4789	>	result = (bool)prompt((std::string const &)*arg1);
4790	>
4791	>	}catch (const std::exception& e) {
4792	>	SWIG_exception(SWIG_RuntimeError, e.what());
4793	>	}
4794		}
4795	<	}
4796	<	resultobj = SWIG_From_int(static_cast< int >(result));
4797	<	if (SWIG_IsNewObj(res2)) delete arg2;
4798	<	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;
4795	>	resultobj = PyInt_FromLong((long)result);
4796	>	return resultobj;
4797	>	fail:
4798	>	return NULL;
4799		}
4800
4801
4802	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4803	<	PyObject *resultobj = 0;
4804	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4805	<	std::string *arg2 = 0 ;
4806	<	std::string arg3 ;
4807	<	std::string arg4 ;
4808	<	std::string arg5 ;
4809	<	std::string arg6 ;
4810	<	std::string arg7 ;
4811	<	std::string arg8 ;
4812	<	std::string arg9 ;
4813	<	std::string arg10 ;
4814	<	std::string *arg11 = 0 ;
4815	<	std::string arg12 ;
4816	<	std::string arg13 ;
4817	<	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""'");
4802	>	static PyObject *_wrap_new_BossAdministratorSession(PyObject *self, PyObject *args) {
4803	>	PyObject *resultobj;
4804	>	std::string arg1 = (std::string) "" ;
4805	>	bool arg2 = (bool) false ;
4806	>	BossAdministratorSession *result;
4807	>	PyObject * obj0 = 0 ;
4808	>	PyObject * obj1 = 0 ;
4809	>
4810	>	if(!PyArg_ParseTuple(args,(char *)"|OO:new_BossAdministratorSession",&obj0,&obj1)) goto fail;
4811	>	if (obj0) {
4812	>	{
4813	>	if (PyString_Check(obj0))
4814	>	arg1 = std::string(PyString_AsString(obj0));
4815	>	else
4816	>	SWIG_exception(SWIG_TypeError, "string expected");
4817	>	}
4818		}
4819	<	arg12 = *ptr;
4820	<	if (SWIG_IsNewObj(res)) delete ptr;
4821	<	}
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""'");
4819	>	if (obj1) {
4820	>	arg2 = PyInt_AsLong(obj1) ? true : false;
4821	>	if (PyErr_Occurred()) SWIG_fail;
4822		}
4823	<	arg13 = *ptr;
4824	<	if (SWIG_IsNewObj(res)) delete ptr;
4825	<	}
4826	<	{
4827	<	try {
4828	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13);
4829	<	} catch (const std::exception& e) {
21930	<	SWIG_exception(SWIG_RuntimeError, e.what());
4823	>	{
4824	>	try {
4825	>	result = (BossAdministratorSession *)new BossAdministratorSession(arg1,arg2);
4826	>
4827	>	}catch (const std::exception& e) {
4828	>	SWIG_exception(SWIG_RuntimeError, e.what());
4829	>	}
4830		}
4831	<	}
4832	<	resultobj = SWIG_From_int(static_cast< int >(result));
4833	<	if (SWIG_IsNewObj(res2)) delete arg2;
4834	<	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;
4831	>	resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BossAdministratorSession, 1);
4832	>	return resultobj;
4833	>	fail:
4834	>	return NULL;
4835		}
4836
4837
4838	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4839	<	PyObject *resultobj = 0;
4840	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4841	<	std::string *arg2 = 0 ;
4842	<	std::string arg3 ;
4843	<	std::string arg4 ;
4844	<	std::string arg5 ;
4845	<	std::string arg6 ;
4846	<	std::string arg7 ;
4847	<	std::string arg8 ;
4848	<	std::string arg9 ;
4849	<	std::string arg10 ;
4850	<	std::string *arg11 = 0 ;
4851	<	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());
4838	>	static PyObject *_wrap_delete_BossAdministratorSession(PyObject *self, PyObject *args) {
4839	>	PyObject *resultobj;
4840	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4841	>	PyObject * obj0 = 0 ;
4842	>
4843	>	if(!PyArg_ParseTuple(args,(char *)"O:delete_BossAdministratorSession",&obj0)) goto fail;
4844	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4845	>	{
4846	>	try {
4847	>	delete arg1;
4848	>
4849	>	}catch (const std::exception& e) {
4850	>	SWIG_exception(SWIG_RuntimeError, e.what());
4851	>	}
4852		}
4853	<	}
4854	<	resultobj = SWIG_From_int(static_cast< int >(result));
4855	<	if (SWIG_IsNewObj(res2)) delete arg2;
4856	<	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;
4853	>	Py_INCREF(Py_None); resultobj = Py_None;
4854	>	return resultobj;
4855	>	fail:
4856	>	return NULL;
4857		}
4858
4859
4860	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4861	<	PyObject *resultobj = 0;
4862	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4863	<	std::string *arg2 = 0 ;
4864	<	std::string arg3 ;
4865	<	std::string arg4 ;
4866	<	std::string arg5 ;
4867	<	std::string arg6 ;
4868	<	std::string arg7 ;
4869	<	std::string arg8 ;
4870	<	std::string arg9 ;
4871	<	std::string arg10 ;
4872	<	std::string *arg11 = 0 ;
4873	<	int result;
4874	<	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());
4860	>	static PyObject *_wrap_BossAdministratorSession_configureDB(PyObject *self, PyObject *args) {
4861	>	PyObject *resultobj;
4862	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4863	>	int result;
4864	>	PyObject * obj0 = 0 ;
4865	>
4866	>	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_configureDB",&obj0)) goto fail;
4867	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4868	>	{
4869	>	try {
4870	>	result = (int)(arg1)->configureDB();
4871	>
4872	>	}catch (const std::exception& e) {
4873	>	SWIG_exception(SWIG_RuntimeError, e.what());
4874	>	}
4875		}
4876	<	}
4877	<	resultobj = SWIG_From_int(static_cast< int >(result));
4878	<	if (SWIG_IsNewObj(res2)) delete arg2;
4879	<	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;
4876	>	resultobj = PyInt_FromLong((long)result);
4877	>	return resultobj;
4878	>	fail:
4879	>	return NULL;
4880		}
4881
4882
4883	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4884	<	PyObject *resultobj = 0;
4885	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4886	<	std::string *arg2 = 0 ;
4887	<	std::string arg3 ;
4888	<	std::string arg4 ;
4889	<	std::string arg5 ;
4890	<	std::string arg6 ;
4891	<	std::string arg7 ;
4892	<	std::string arg8 ;
4893	<	std::string arg9 ;
4894	<	std::string arg10 ;
4895	<	int result;
4896	<	void *argp1 = 0 ;
4897	<	int res1 = 0 ;
4898	<	int res2 = SWIG_OLDOBJ ;
4899	<	PyObject * obj0 = 0 ;
4900	<	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""'");
4883	>	static PyObject *_wrap_BossAdministratorSession_configureRTMonDB(PyObject *self, PyObject *args) {
4884	>	PyObject *resultobj;
4885	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4886	>	std::string *arg2 = 0 ;
4887	>	int result;
4888	>	std::string temp2 ;
4889	>	PyObject * obj0 = 0 ;
4890	>	PyObject * obj1 = 0 ;
4891	>
4892	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configureRTMonDB",&obj0,&obj1)) goto fail;
4893	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4894	>	{
4895	>	if (PyString_Check(obj1)) {
4896	>	temp2 = std::string(PyString_AsString(obj1));
4897	>	arg2 = &temp2;
4898	>	}else {
4899	>	SWIG_exception(SWIG_TypeError, "string expected");
4900	>	}
4901		}
4902	<	arg10 = *ptr;
4903	<	if (SWIG_IsNewObj(res)) delete ptr;
4904	<	}
4905	<	{
4906	<	try {
4907	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
4908	<	} catch (const std::exception& e) {
22371	<	SWIG_exception(SWIG_RuntimeError, e.what());
4902	>	{
4903	>	try {
4904	>	result = (int)(arg1)->configureRTMonDB((std::string const &)*arg2);
4905	>
4906	>	}catch (const std::exception& e) {
4907	>	SWIG_exception(SWIG_RuntimeError, e.what());
4908	>	}
4909		}
4910	<	}
4911	<	resultobj = SWIG_From_int(static_cast< int >(result));
4912	<	if (SWIG_IsNewObj(res2)) delete arg2;
4913	<	return resultobj;
22377	<	fail:
22378	<	if (SWIG_IsNewObj(res2)) delete arg2;
22379	<	return NULL;
4910	>	resultobj = PyInt_FromLong((long)result);
4911	>	return resultobj;
4912	>	fail:
4913	>	return NULL;
4914		}
4915
4916
4917	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4918	<	PyObject *resultobj = 0;
4919	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4920	<	std::string *arg2 = 0 ;
4921	<	std::string arg3 ;
4922	<	std::string arg4 ;
4923	<	std::string arg5 ;
4924	<	std::string arg6 ;
4925	<	std::string arg7 ;
4926	<	std::string arg8 ;
4927	<	std::string arg9 ;
4928	<	int result;
4929	<	void *argp1 = 0 ;
4930	<	int res1 = 0 ;
4931	<	int res2 = SWIG_OLDOBJ ;
4932	<	PyObject * obj0 = 0 ;
4933	<	PyObject * obj1 = 0 ;
4934	<	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""'");
4917	>	static PyObject *_wrap_BossAdministratorSession_deleteCHTool(PyObject *self, PyObject *args) {
4918	>	PyObject *resultobj;
4919	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4920	>	std::string *arg2 = 0 ;
4921	>	int result;
4922	>	std::string temp2 ;
4923	>	PyObject * obj0 = 0 ;
4924	>	PyObject * obj1 = 0 ;
4925	>
4926	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteCHTool",&obj0,&obj1)) goto fail;
4927	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4928	>	{
4929	>	if (PyString_Check(obj1)) {
4930	>	temp2 = std::string(PyString_AsString(obj1));
4931	>	arg2 = &temp2;
4932	>	}else {
4933	>	SWIG_exception(SWIG_TypeError, "string expected");
4934	>	}
4935		}
4936	<	arg9 = *ptr;
4937	<	if (SWIG_IsNewObj(res)) delete ptr;
4938	<	}
4939	<	{
4940	<	try {
4941	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
4942	<	} catch (const std::exception& e) {
22492	<	SWIG_exception(SWIG_RuntimeError, e.what());
4936	>	{
4937	>	try {
4938	>	result = (int)(arg1)->deleteCHTool((std::string const &)*arg2);
4939	>
4940	>	}catch (const std::exception& e) {
4941	>	SWIG_exception(SWIG_RuntimeError, e.what());
4942	>	}
4943		}
4944	<	}
4945	<	resultobj = SWIG_From_int(static_cast< int >(result));
4946	<	if (SWIG_IsNewObj(res2)) delete arg2;
4947	<	return resultobj;
22498	<	fail:
22499	<	if (SWIG_IsNewObj(res2)) delete arg2;
22500	<	return NULL;
4944	>	resultobj = PyInt_FromLong((long)result);
4945	>	return resultobj;
4946	>	fail:
4947	>	return NULL;
4948		}
4949
4950
4951	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4952	<	PyObject *resultobj = 0;
4953	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4954	<	std::string *arg2 = 0 ;
4955	<	std::string arg3 ;
4956	<	std::string arg4 ;
4957	<	std::string arg5 ;
4958	<	std::string arg6 ;
4959	<	std::string arg7 ;
4960	<	std::string arg8 ;
4961	<	int result;
4962	<	void *argp1 = 0 ;
4963	<	int res1 = 0 ;
4964	<	int res2 = SWIG_OLDOBJ ;
4965	<	PyObject * obj0 = 0 ;
4966	<	PyObject * obj1 = 0 ;
4967	<	PyObject * obj2 = 0 ;
4968	<	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""'");
4951	>	static PyObject *_wrap_BossAdministratorSession_deleteProgramType(PyObject *self, PyObject *args) {
4952	>	PyObject *resultobj;
4953	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4954	>	std::string *arg2 = 0 ;
4955	>	int result;
4956	>	std::string temp2 ;
4957	>	PyObject * obj0 = 0 ;
4958	>	PyObject * obj1 = 0 ;
4959	>
4960	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteProgramType",&obj0,&obj1)) goto fail;
4961	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4962	>	{
4963	>	if (PyString_Check(obj1)) {
4964	>	temp2 = std::string(PyString_AsString(obj1));
4965	>	arg2 = &temp2;
4966	>	}else {
4967	>	SWIG_exception(SWIG_TypeError, "string expected");
4968	>	}
4969		}
4970	<	arg8 = *ptr;
4971	<	if (SWIG_IsNewObj(res)) delete ptr;
4972	<	}
4973	<	{
4974	<	try {
4975	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4976	<	} catch (const std::exception& e) {
22602	<	SWIG_exception(SWIG_RuntimeError, e.what());
4970	>	{
4971	>	try {
4972	>	result = (int)(arg1)->deleteProgramType((std::string const &)*arg2);
4973	>
4974	>	}catch (const std::exception& e) {
4975	>	SWIG_exception(SWIG_RuntimeError, e.what());
4976	>	}
4977		}
4978	<	}
4979	<	resultobj = SWIG_From_int(static_cast< int >(result));
4980	<	if (SWIG_IsNewObj(res2)) delete arg2;
4981	<	return resultobj;
22608	<	fail:
22609	<	if (SWIG_IsNewObj(res2)) delete arg2;
22610	<	return NULL;
4978	>	resultobj = PyInt_FromLong((long)result);
4979	>	return resultobj;
4980	>	fail:
4981	>	return NULL;
4982		}
4983
4984
4985	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4986	<	PyObject *resultobj = 0;
4987	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4988	<	std::string *arg2 = 0 ;
4989	<	std::string arg3 ;
4990	<	std::string arg4 ;
4991	<	std::string arg5 ;
4992	<	std::string arg6 ;
4993	<	std::string arg7 ;
4994	<	int result;
4995	<	void *argp1 = 0 ;
4996	<	int res1 = 0 ;
4997	<	int res2 = SWIG_OLDOBJ ;
4998	<	PyObject * obj0 = 0 ;
4999	<	PyObject * obj1 = 0 ;
5000	<	PyObject * obj2 = 0 ;
5001	<	PyObject * obj3 = 0 ;
5002	<	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""'");
4985	>	static PyObject *_wrap_BossAdministratorSession_deleteRTMon(PyObject *self, PyObject *args) {
4986	>	PyObject *resultobj;
4987	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
4988	>	std::string *arg2 = 0 ;
4989	>	int result;
4990	>	std::string temp2 ;
4991	>	PyObject * obj0 = 0 ;
4992	>	PyObject * obj1 = 0 ;
4993	>
4994	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteRTMon",&obj0,&obj1)) goto fail;
4995	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
4996	>	{
4997	>	if (PyString_Check(obj1)) {
4998	>	temp2 = std::string(PyString_AsString(obj1));
4999	>	arg2 = &temp2;
5000	>	}else {
5001	>	SWIG_exception(SWIG_TypeError, "string expected");
5002	>	}
5003		}
5004	<	arg7 = *ptr;
5005	<	if (SWIG_IsNewObj(res)) delete ptr;
5006	<	}
5007	<	{
5008	<	try {
5009	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5010	<	} catch (const std::exception& e) {
22701	<	SWIG_exception(SWIG_RuntimeError, e.what());
5004	>	{
5005	>	try {
5006	>	result = (int)(arg1)->deleteRTMon((std::string const &)*arg2);
5007	>
5008	>	}catch (const std::exception& e) {
5009	>	SWIG_exception(SWIG_RuntimeError, e.what());
5010	>	}
5011		}
5012	<	}
5013	<	resultobj = SWIG_From_int(static_cast< int >(result));
5014	<	if (SWIG_IsNewObj(res2)) delete arg2;
5015	<	return resultobj;
22707	<	fail:
22708	<	if (SWIG_IsNewObj(res2)) delete arg2;
22709	<	return NULL;
5012	>	resultobj = PyInt_FromLong((long)result);
5013	>	return resultobj;
5014	>	fail:
5015	>	return NULL;
5016		}
5017
5018
5019	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5020	<	PyObject *resultobj = 0;
5021	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5022	<	std::string *arg2 = 0 ;
5023	<	std::string arg3 ;
5024	<	std::string arg4 ;
5025	<	std::string arg5 ;
5026	<	std::string arg6 ;
5027	<	int result;
5028	<	void *argp1 = 0 ;
5029	<	int res1 = 0 ;
5030	<	int res2 = SWIG_OLDOBJ ;
5031	<	PyObject * obj0 = 0 ;
5032	<	PyObject * obj1 = 0 ;
5033	<	PyObject * obj2 = 0 ;
5034	<	PyObject * obj3 = 0 ;
5035	<	PyObject * obj4 = 0 ;
5036	<	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""'");
5019	>	static PyObject *_wrap_BossAdministratorSession_deleteScheduler(PyObject *self, PyObject *args) {
5020	>	PyObject *resultobj;
5021	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5022	>	std::string *arg2 = 0 ;
5023	>	int result;
5024	>	std::string temp2 ;
5025	>	PyObject * obj0 = 0 ;
5026	>	PyObject * obj1 = 0 ;
5027	>
5028	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_deleteScheduler",&obj0,&obj1)) goto fail;
5029	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5030	>	{
5031	>	if (PyString_Check(obj1)) {
5032	>	temp2 = std::string(PyString_AsString(obj1));
5033	>	arg2 = &temp2;
5034	>	}else {
5035	>	SWIG_exception(SWIG_TypeError, "string expected");
5036	>	}
5037		}
5038	<	arg6 = *ptr;
5039	<	if (SWIG_IsNewObj(res)) delete ptr;
5040	<	}
5041	<	{
5042	<	try {
5043	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5044	<	} catch (const std::exception& e) {
22789	<	SWIG_exception(SWIG_RuntimeError, e.what());
5038	>	{
5039	>	try {
5040	>	result = (int)(arg1)->deleteScheduler((std::string const &)*arg2);
5041	>
5042	>	}catch (const std::exception& e) {
5043	>	SWIG_exception(SWIG_RuntimeError, e.what());
5044	>	}
5045		}
5046	<	}
5047	<	resultobj = SWIG_From_int(static_cast< int >(result));
5048	<	if (SWIG_IsNewObj(res2)) delete arg2;
5049	<	return resultobj;
22795	<	fail:
22796	<	if (SWIG_IsNewObj(res2)) delete arg2;
22797	<	return NULL;
5046	>	resultobj = PyInt_FromLong((long)result);
5047	>	return resultobj;
5048	>	fail:
5049	>	return NULL;
5050		}
5051
5052
5053	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5054	<	PyObject *resultobj = 0;
5055	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5056	<	std::string *arg2 = 0 ;
5057	<	std::string arg3 ;
5058	<	std::string arg4 ;
5059	<	std::string arg5 ;
5060	<	int result;
5061	<	void *argp1 = 0 ;
5062	<	int res1 = 0 ;
5063	<	int res2 = SWIG_OLDOBJ ;
5064	<	PyObject * obj0 = 0 ;
5065	<	PyObject * obj1 = 0 ;
5066	<	PyObject * obj2 = 0 ;
5067	<	PyObject * obj3 = 0 ;
5068	<	PyObject * obj4 = 0 ;
5069	<
5070	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5071	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5072	<	if (!SWIG_IsOK(res1)) {
5073	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5074	<	}
5075	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5076	<	{
5077	<	std::string *ptr = (std::string *)0;
5078	<	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 &""'");
5053	>	static PyObject *_wrap_BossAdministratorSession_registerCHTool(PyObject *self, PyObject *args) {
5054	>	PyObject *resultobj;
5055	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5056	>	std::string *arg2 = 0 ;
5057	>	std::string arg3 = (std::string) "NULL" ;
5058	>	std::string arg4 = (std::string) "NULL" ;
5059	>	bool arg5 = (bool) false ;
5060	>	bool arg6 = (bool) false ;
5061	>	int result;
5062	>	std::string temp2 ;
5063	>	PyObject * obj0 = 0 ;
5064	>	PyObject * obj1 = 0 ;
5065	>	PyObject * obj2 = 0 ;
5066	>	PyObject * obj3 = 0 ;
5067	>	PyObject * obj4 = 0 ;
5068	>	PyObject * obj5 = 0 ;
5069	>
5070	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOO:BossAdministratorSession_registerCHTool",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5071	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5072	>	{
5073	>	if (PyString_Check(obj1)) {
5074	>	temp2 = std::string(PyString_AsString(obj1));
5075	>	arg2 = &temp2;
5076	>	}else {
5077	>	SWIG_exception(SWIG_TypeError, "string expected");
5078	>	}
5079		}
5080	<	if (!ptr) {
5081	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
5080	>	if (obj2) {
5081	>	{
5082	>	if (PyString_Check(obj2))
5083	>	arg3 = std::string(PyString_AsString(obj2));
5084	>	else
5085	>	SWIG_exception(SWIG_TypeError, "string expected");
5086	>	}
5087		}
5088	<	arg2 = ptr;
5089	<	}
5090	<	{
5091	<	std::string *ptr = (std::string *)0;
5092	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
5093	<	if (!SWIG_IsOK(res) || !ptr) {
5094	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
5088	>	if (obj3) {
5089	>	{
5090	>	if (PyString_Check(obj3))
5091	>	arg4 = std::string(PyString_AsString(obj3));
5092	>	else
5093	>	SWIG_exception(SWIG_TypeError, "string expected");
5094	>	}
5095		}
5096	<	arg3 = *ptr;
5097	<	if (SWIG_IsNewObj(res)) delete ptr;
5098	<	}
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""'");
5096	>	if (obj4) {
5097	>	arg5 = PyInt_AsLong(obj4) ? true : false;
5098	>	if (PyErr_Occurred()) SWIG_fail;
5099		}
5100	<	arg4 = *ptr;
5101	<	if (SWIG_IsNewObj(res)) delete ptr;
5102	<	}
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""'");
5100	>	if (obj5) {
5101	>	arg6 = PyInt_AsLong(obj5) ? true : false;
5102	>	if (PyErr_Occurred()) SWIG_fail;
5103		}
5104	<	arg5 = *ptr;
5105	<	if (SWIG_IsNewObj(res)) delete ptr;
5106	<	}
5107	<	{
5108	<	try {
5109	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5);
5110	<	} catch (const std::exception& e) {
22866	<	SWIG_exception(SWIG_RuntimeError, e.what());
5104	>	{
5105	>	try {
5106	>	result = (int)(arg1)->registerCHTool((std::string const &)*arg2,arg3,arg4,arg5,arg6);
5107	>
5108	>	}catch (const std::exception& e) {
5109	>	SWIG_exception(SWIG_RuntimeError, e.what());
5110	>	}
5111		}
5112	<	}
5113	<	resultobj = SWIG_From_int(static_cast< int >(result));
5114	<	if (SWIG_IsNewObj(res2)) delete arg2;
5115	<	return resultobj;
22872	<	fail:
22873	<	if (SWIG_IsNewObj(res2)) delete arg2;
22874	<	return NULL;
5112	>	resultobj = PyInt_FromLong((long)result);
5113	>	return resultobj;
5114	>	fail:
5115	>	return NULL;
5116		}
5117
5118
5119	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5120	<	PyObject *resultobj = 0;
5121	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5122	<	std::string *arg2 = 0 ;
5123	<	std::string arg3 ;
5124	<	std::string arg4 ;
5125	<	int result;
5126	<	void *argp1 = 0 ;
5127	<	int res1 = 0 ;
5128	<	int res2 = SWIG_OLDOBJ ;
5129	<	PyObject * obj0 = 0 ;
5130	<	PyObject * obj1 = 0 ;
5131	<	PyObject * obj2 = 0 ;
5132	<	PyObject * obj3 = 0 ;
5133	<
5134	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5135	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5136	<	if (!SWIG_IsOK(res1)) {
5137	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5138	<	}
5139	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5140	<	{
5141	<	std::string *ptr = (std::string *)0;
5142	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5143	<	if (!SWIG_IsOK(res2)) {
5144	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
5119	>	static PyObject *_wrap_BossAdministratorSession_registerProgram(PyObject *self, PyObject *args) {
5120	>	PyObject *resultobj;
5121	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5122	>	std::string *arg2 = 0 ;
5123	>	std::string arg3 = (std::string) "NULL" ;
5124	>	std::string arg4 = (std::string) "NULL" ;
5125	>	std::string arg5 = (std::string) "NULL" ;
5126	>	std::string arg6 = (std::string) "NULL" ;
5127	>	std::string arg7 = (std::string) "" ;
5128	>	bool arg8 = (bool) false ;
5129	>	int result;
5130	>	std::string temp2 ;
5131	>	PyObject * obj0 = 0 ;
5132	>	PyObject * obj1 = 0 ;
5133	>	PyObject * obj2 = 0 ;
5134	>	PyObject * obj3 = 0 ;
5135	>	PyObject * obj4 = 0 ;
5136	>	PyObject * obj5 = 0 ;
5137	>	PyObject * obj6 = 0 ;
5138	>	PyObject * obj7 = 0 ;
5139	>
5140	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOOO:BossAdministratorSession_registerProgram",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5141	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5142	>	{
5143	>	if (PyString_Check(obj1)) {
5144	>	temp2 = std::string(PyString_AsString(obj1));
5145	>	arg2 = &temp2;
5146	>	}else {
5147	>	SWIG_exception(SWIG_TypeError, "string expected");
5148	>	}
5149		}
5150	<	if (!ptr) {
5151	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
5150	>	if (obj2) {
5151	>	{
5152	>	if (PyString_Check(obj2))
5153	>	arg3 = std::string(PyString_AsString(obj2));
5154	>	else
5155	>	SWIG_exception(SWIG_TypeError, "string expected");
5156	>	}
5157		}
5158	<	arg2 = ptr;
5159	<	}
5160	<	{
5161	<	std::string *ptr = (std::string *)0;
5162	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
5163	<	if (!SWIG_IsOK(res) || !ptr) {
5164	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
5158	>	if (obj3) {
5159	>	{
5160	>	if (PyString_Check(obj3))
5161	>	arg4 = std::string(PyString_AsString(obj3));
5162	>	else
5163	>	SWIG_exception(SWIG_TypeError, "string expected");
5164	>	}
5165		}
5166	<	arg3 = *ptr;
5167	<	if (SWIG_IsNewObj(res)) delete ptr;
5168	<	}
5169	<	{
5170	<	std::string *ptr = (std::string *)0;
5171	<	int res = SWIG_AsPtr_std_string(obj3, &ptr);
5172	<	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""'");
5166	>	if (obj4) {
5167	>	{
5168	>	if (PyString_Check(obj4))
5169	>	arg5 = std::string(PyString_AsString(obj4));
5170	>	else
5171	>	SWIG_exception(SWIG_TypeError, "string expected");
5172	>	}
5173		}
5174	<	arg4 = *ptr;
5175	<	if (SWIG_IsNewObj(res)) delete ptr;
5176	<	}
5177	<	{
5178	<	try {
5179	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4);
5180	<	} catch (const std::exception& e) {
22932	<	SWIG_exception(SWIG_RuntimeError, e.what());
5174	>	if (obj5) {
5175	>	{
5176	>	if (PyString_Check(obj5))
5177	>	arg6 = std::string(PyString_AsString(obj5));
5178	>	else
5179	>	SWIG_exception(SWIG_TypeError, "string expected");
5180	>	}
5181		}
5182	<	}
5183	<	resultobj = SWIG_From_int(static_cast< int >(result));
5184	<	if (SWIG_IsNewObj(res2)) delete arg2;
5185	<	return resultobj;
5186	<	fail:
5187	<	if (SWIG_IsNewObj(res2)) delete arg2;
5188	<	return NULL;
5182	>	if (obj6) {
5183	>	{
5184	>	if (PyString_Check(obj6))
5185	>	arg7 = std::string(PyString_AsString(obj6));
5186	>	else
5187	>	SWIG_exception(SWIG_TypeError, "string expected");
5188	>	}
5189	>	}
5190	>	if (obj7) {
5191	>	arg8 = PyInt_AsLong(obj7) ? true : false;
5192	>	if (PyErr_Occurred()) SWIG_fail;
5193	>	}
5194	>	{
5195	>	try {
5196	>	result = (int)(arg1)->registerProgram((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5197	>
5198	>	}catch (const std::exception& e) {
5199	>	SWIG_exception(SWIG_RuntimeError, e.what());
5200	>	}
5201	>	}
5202	>	resultobj = PyInt_FromLong((long)result);
5203	>	return resultobj;
5204	>	fail:
5205	>	return NULL;
5206		}
5207
5208
5209	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5210	<	PyObject *resultobj = 0;
5211	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5212	<	std::string *arg2 = 0 ;
5213	<	std::string arg3 ;
5214	<	int result;
5215	<	void *argp1 = 0 ;
5216	<	int res1 = 0 ;
5217	<	int res2 = SWIG_OLDOBJ ;
5218	<	PyObject * obj0 = 0 ;
5219	<	PyObject * obj1 = 0 ;
5220	<	PyObject * obj2 = 0 ;
5221	<
5222	<	if (!PyArg_ParseTuple(args,(char *)"OOO:BossAdministratorSession_registerScheduler",&obj0,&obj1,&obj2)) SWIG_fail;
5223	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5224	<	if (!SWIG_IsOK(res1)) {
5225	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5226	<	}
5227	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5228	<	{
5229	<	std::string *ptr = (std::string *)0;
5230	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5231	<	if (!SWIG_IsOK(res2)) {
5232	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
5209	>	static PyObject *_wrap_BossAdministratorSession_registerRTMon(PyObject *self, PyObject *args) {
5210	>	PyObject *resultobj;
5211	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5212	>	std::string *arg2 = 0 ;
5213	>	std::string arg3 = (std::string) "NULL" ;
5214	>	std::string arg4 = (std::string) "NULL" ;
5215	>	std::string arg5 = (std::string) "NULL" ;
5216	>	bool arg6 = (bool) false ;
5217	>	bool arg7 = (bool) false ;
5218	>	int result;
5219	>	std::string temp2 ;
5220	>	PyObject * obj0 = 0 ;
5221	>	PyObject * obj1 = 0 ;
5222	>	PyObject * obj2 = 0 ;
5223	>	PyObject * obj3 = 0 ;
5224	>	PyObject * obj4 = 0 ;
5225	>	PyObject * obj5 = 0 ;
5226	>	PyObject * obj6 = 0 ;
5227	>
5228	>	if(!PyArg_ParseTuple(args,(char *)"OO|OOOOO:BossAdministratorSession_registerRTMon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5229	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5230	>	{
5231	>	if (PyString_Check(obj1)) {
5232	>	temp2 = std::string(PyString_AsString(obj1));
5233	>	arg2 = &temp2;
5234	>	}else {
5235	>	SWIG_exception(SWIG_TypeError, "string expected");
5236	>	}
5237		}
5238	<	if (!ptr) {
5239	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
5238	>	if (obj2) {
5239	>	{
5240	>	if (PyString_Check(obj2))
5241	>	arg3 = std::string(PyString_AsString(obj2));
5242	>	else
5243	>	SWIG_exception(SWIG_TypeError, "string expected");
5244	>	}
5245		}
5246	<	arg2 = ptr;
5247	<	}
5248	<	{
5249	<	std::string *ptr = (std::string *)0;
5250	<	int res = SWIG_AsPtr_std_string(obj2, &ptr);
5251	<	if (!SWIG_IsOK(res) || !ptr) {
5252	<	SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BossAdministratorSession_registerScheduler" "', argument " "3"" of type '" "std::string""'");
5246	>	if (obj3) {
5247	>	{
5248	>	if (PyString_Check(obj3))
5249	>	arg4 = std::string(PyString_AsString(obj3));
5250	>	else
5251	>	SWIG_exception(SWIG_TypeError, "string expected");
5252	>	}
5253		}
5254	<	arg3 = *ptr;
5255	<	if (SWIG_IsNewObj(res)) delete ptr;
5256	<	}
5257	<	{
5258	<	try {
5259	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3);
5260	<	} catch (const std::exception& e) {
22987	<	SWIG_exception(SWIG_RuntimeError, e.what());
5254	>	if (obj4) {
5255	>	{
5256	>	if (PyString_Check(obj4))
5257	>	arg5 = std::string(PyString_AsString(obj4));
5258	>	else
5259	>	SWIG_exception(SWIG_TypeError, "string expected");
5260	>	}
5261		}
5262	<	}
5263	<	resultobj = SWIG_From_int(static_cast< int >(result));
5264	<	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 &""'");
5262	>	if (obj5) {
5263	>	arg6 = PyInt_AsLong(obj5) ? true : false;
5264	>	if (PyErr_Occurred()) SWIG_fail;
5265		}
5266	<	if (!ptr) {
5267	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_registerScheduler" "', argument " "2"" of type '" "std::string const &""'");
5266	>	if (obj6) {
5267	>	arg7 = PyInt_AsLong(obj6) ? true : false;
5268	>	if (PyErr_Occurred()) SWIG_fail;
5269		}
5270	<	arg2 = ptr;
5271	<	}
5272	<	{
5273	<	try {
5274	<	result = (int)(arg1)->registerScheduler((std::string const &)*arg2);
5275	<	} catch (const std::exception& e) {
5276	<	SWIG_exception(SWIG_RuntimeError, e.what());
5270	>	{
5271	>	try {
5272	>	result = (int)(arg1)->registerRTMon((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7);
5273	>
5274	>	}catch (const std::exception& e) {
5275	>	SWIG_exception(SWIG_RuntimeError, e.what());
5276	>	}
5277		}
5278	<	}
5279	<	resultobj = SWIG_From_int(static_cast< int >(result));
5280	<	if (SWIG_IsNewObj(res2)) delete arg2;
5281	<	return resultobj;
23037	<	fail:
23038	<	if (SWIG_IsNewObj(res2)) delete arg2;
23039	<	return NULL;
5278	>	resultobj = PyInt_FromLong((long)result);
5279	>	return resultobj;
5280	>	fail:
5281	>	return NULL;
5282		}
5283
5284
5285	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
5286	<	int argc;
5287	<	PyObject *argv[16];
5288	<	int ii;
5289	<
5290	<	if (!PyTuple_Check(args)) SWIG_fail;
5291	<	argc = PyObject_Length(args);
5292	<	for (ii = 0; (ii < argc) && (ii < 15); ii++) {
5293	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5294	<	}
5295	<	if (argc == 2) {
5296	<	int _v;
5297	<	void *vptr = 0;
5298	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5299	<	_v = SWIG_CheckState(res);
5300	<	if (_v) {
5301	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5302	<	_v = SWIG_CheckState(res);
5303	<	if (_v) {
5304	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_13(self, args);
5305	<	}
5306	<	}
5307	<	}
5308	<	if (argc == 3) {
5309	<	int _v;
5310	<	void *vptr = 0;
5311	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5312	<	_v = SWIG_CheckState(res);
5313	<	if (_v) {
5314	<	int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
5315	<	_v = SWIG_CheckState(res);
5316	<	if (_v) {
5317	<	int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
5318	<	_v = SWIG_CheckState(res);
5319	<	if (_v) {
5320	<	return _wrap_BossAdministratorSession_registerScheduler__SWIG_12(self, args);
5321	<	}
5322	<	}
5323	<	}
5324	<	}
5325	<	if (argc == 4) {
5326	<	int _v;
5327	<	void *vptr = 0;
5328	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5329	<	_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	<	}
5285	>	static PyObject *_wrap_BossAdministratorSession_registerScheduler(PyObject *self, PyObject *args) {
5286	>	PyObject *resultobj;
5287	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5288	>	std::string *arg2 = 0 ;
5289	>	std::string arg3 = (std::string) "NULL" ;
5290	>	std::string arg4 = (std::string) "NULL" ;
5291	>	std::string arg5 = (std::string) "NULL" ;
5292	>	std::string arg6 = (std::string) "NULL" ;
5293	>	std::string arg7 = (std::string) "" ;
5294	>	std::string arg8 = (std::string) "" ;
5295	>	std::string arg9 = (std::string) "" ;
5296	>	std::string arg10 = (std::string) "" ;
5297	>	std::string const &arg11_defvalue = "" ;
5298	>	std::string *arg11 = (std::string *) &arg11_defvalue ;
5299	>	std::string arg12 = (std::string) "" ;
5300	>	std::string arg13 = (std::string) "" ;
5301	>	bool arg14 = (bool) false ;
5302	>	bool arg15 = (bool) false ;
5303	>	int result;
5304	>	std::string temp2 ;
5305	>	std::string temp11 ;
5306	>	PyObject * obj0 = 0 ;
5307	>	PyObject * obj1 = 0 ;
5308	>	PyObject * obj2 = 0 ;
5309	>	PyObject * obj3 = 0 ;
5310	>	PyObject * obj4 = 0 ;
5311	>	PyObject * obj5 = 0 ;
5312	>	PyObject * obj6 = 0 ;
5313	>	PyObject * obj7 = 0 ;
5314	>	PyObject * obj8 = 0 ;
5315	>	PyObject * obj9 = 0 ;
5316	>	PyObject * obj10 = 0 ;
5317	>	PyObject * obj11 = 0 ;
5318	>	PyObject * obj12 = 0 ;
5319	>	PyObject * obj13 = 0 ;
5320	>	PyObject * obj14 = 0 ;
5321	>
5322	>	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;
5323	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5324	>	{
5325	>	if (PyString_Check(obj1)) {
5326	>	temp2 = std::string(PyString_AsString(obj1));
5327	>	arg2 = &temp2;
5328	>	}else {
5329	>	SWIG_exception(SWIG_TypeError, "string expected");
5330		}
23101	–	}
5331		}
5332	<	}
5333	<	if (argc == 5) {
5334	<	int _v;
5335	<	void *vptr = 0;
5336	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5337	<	_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	<	}
5332	>	if (obj2) {
5333	>	{
5334	>	if (PyString_Check(obj2))
5335	>	arg3 = std::string(PyString_AsString(obj2));
5336	>	else
5337	>	SWIG_exception(SWIG_TypeError, "string expected");
5338		}
23126	–	}
5339		}
5340	<	}
5341	<	if (argc == 6) {
5342	<	int _v;
5343	<	void *vptr = 0;
5344	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5345	<	_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	<	}
5340	>	if (obj3) {
5341	>	{
5342	>	if (PyString_Check(obj3))
5343	>	arg4 = std::string(PyString_AsString(obj3));
5344	>	else
5345	>	SWIG_exception(SWIG_TypeError, "string expected");
5346		}
23155	–	}
5347		}
5348	<	}
5349	<	if (argc == 7) {
5350	<	int _v;
5351	<	void *vptr = 0;
5352	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5353	<	_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	<	}
5348	>	if (obj4) {
5349	>	{
5350	>	if (PyString_Check(obj4))
5351	>	arg5 = std::string(PyString_AsString(obj4));
5352	>	else
5353	>	SWIG_exception(SWIG_TypeError, "string expected");
5354		}
23188	–	}
5355		}
5356	<	}
5357	<	if (argc == 8) {
5358	<	int _v;
5359	<	void *vptr = 0;
5360	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5361	<	_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	<	}
5356	>	if (obj5) {
5357	>	{
5358	>	if (PyString_Check(obj5))
5359	>	arg6 = std::string(PyString_AsString(obj5));
5360	>	else
5361	>	SWIG_exception(SWIG_TypeError, "string expected");
5362		}
23225	–	}
5363		}
5364	<	}
5365	<	if (argc == 9) {
5366	<	int _v;
5367	<	void *vptr = 0;
5368	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5369	<	_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	<	}
5364	>	if (obj6) {
5365	>	{
5366	>	if (PyString_Check(obj6))
5367	>	arg7 = std::string(PyString_AsString(obj6));
5368	>	else
5369	>	SWIG_exception(SWIG_TypeError, "string expected");
5370		}
23266	–	}
5371		}
5372	<	}
5373	<	if (argc == 10) {
5374	<	int _v;
5375	<	void *vptr = 0;
5376	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5377	<	_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	<	}
5372	>	if (obj7) {
5373	>	{
5374	>	if (PyString_Check(obj7))
5375	>	arg8 = std::string(PyString_AsString(obj7));
5376	>	else
5377	>	SWIG_exception(SWIG_TypeError, "string expected");
5378		}
23311	–	}
5379		}
5380	<	}
5381	<	if (argc == 11) {
5382	<	int _v;
5383	<	void *vptr = 0;
5384	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5385	<	_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	<	}
5380	>	if (obj8) {
5381	>	{
5382	>	if (PyString_Check(obj8))
5383	>	arg9 = std::string(PyString_AsString(obj8));
5384	>	else
5385	>	SWIG_exception(SWIG_TypeError, "string expected");
5386		}
23360	–	}
5387		}
5388	<	}
5389	<	if (argc == 12) {
5390	<	int _v;
5391	<	void *vptr = 0;
5392	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5393	<	_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	<	}
5388	>	if (obj9) {
5389	>	{
5390	>	if (PyString_Check(obj9))
5391	>	arg10 = std::string(PyString_AsString(obj9));
5392	>	else
5393	>	SWIG_exception(SWIG_TypeError, "string expected");
5394		}
23413	–	}
5395		}
5396	<	}
5397	<	if (argc == 13) {
5398	<	int _v;
5399	<	void *vptr = 0;
5400	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5401	<	_v = SWIG_CheckState(res);
5402	<	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	<	}
5396	>	if (obj10) {
5397	>	{
5398	>	if (PyString_Check(obj10)) {
5399	>	temp11 = std::string(PyString_AsString(obj10));
5400	>	arg11 = &temp11;
5401	>	}else {
5402	>	SWIG_exception(SWIG_TypeError, "string expected");
5403		}
23468	–	}
5404		}
23470	–	}
5405		}
5406	<	}
5407	<	if (argc == 14) {
5408	<	int _v;
5409	<	void *vptr = 0;
5410	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5411	<	_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	<	}
5406	>	if (obj11) {
5407	>	{
5408	>	if (PyString_Check(obj11))
5409	>	arg12 = std::string(PyString_AsString(obj11));
5410	>	else
5411	>	SWIG_exception(SWIG_TypeError, "string expected");
5412		}
23533	–	}
5413		}
5414	<	}
5415	<	if (argc == 15) {
5416	<	int _v;
5417	<	void *vptr = 0;
5418	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5419	<	_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	<	}
5414	>	if (obj12) {
5415	>	{
5416	>	if (PyString_Check(obj12))
5417	>	arg13 = std::string(PyString_AsString(obj12));
5418	>	else
5419	>	SWIG_exception(SWIG_TypeError, "string expected");
5420		}
23602	–	}
5421		}
5422	<	}
5423	<
5424	<	fail:
23607	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_registerScheduler'");
23608	<	return NULL;
23609	<	}
23610	<
23611	<
23612	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_help(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23613	<	PyObject *resultobj = 0;
23614	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
23615	<	std::string result;
23616	<	void *argp1 = 0 ;
23617	<	int res1 = 0 ;
23618	<	PyObject * obj0 = 0 ;
23619	<
23620	<	if (!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_help",&obj0)) SWIG_fail;
23621	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
23622	<	if (!SWIG_IsOK(res1)) {
23623	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_help" "', argument " "1"" of type '" "BossAdministratorSession *""'");
23624	<	}
23625	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
23626	<	{
23627	<	try {
23628	<	result = (arg1)->help();
23629	<	} catch (const std::exception& e) {
23630	<	SWIG_exception(SWIG_RuntimeError, e.what());
5422	>	if (obj13) {
5423	>	arg14 = PyInt_AsLong(obj13) ? true : false;
5424	>	if (PyErr_Occurred()) SWIG_fail;
5425		}
5426	<	}
5427	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
5428	<	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	<	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	<	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""'");
5426	>	if (obj14) {
5427	>	arg15 = PyInt_AsLong(obj14) ? true : false;
5428	>	if (PyErr_Occurred()) SWIG_fail;
5429		}
5430	<	arg2 = *ptr;
5431	<	if (SWIG_IsNewObj(res)) delete ptr;
5432	<	}
5433	<	{
5434	<	try {
5435	<	result = (arg1)->SQL(arg2);
5436	<	} catch (const std::exception& e) {
23717	<	SWIG_exception(SWIG_RuntimeError, e.what());
5430	>	{
5431	>	try {
5432	>	result = (int)(arg1)->registerScheduler((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(std::string const &)*arg11,arg12,arg13,arg14,arg15);
5433	>
5434	>	}catch (const std::exception& e) {
5435	>	SWIG_exception(SWIG_RuntimeError, e.what());
5436	>	}
5437		}
5438	<	}
5439	<	resultobj = SWIG_From_std_string(static_cast< std::string >(result));
5440	<	return resultobj;
5441	<	fail:
23723	<	return NULL;
5438	>	resultobj = PyInt_FromLong((long)result);
5439	>	return resultobj;
5440	>	fail:
5441	>	return NULL;
5442		}
5443
5444
5445	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
5446	<	int argc;
5447	<	PyObject *argv[4];
5448	<	int ii;
5449	<
5450	<	if (!PyTuple_Check(args)) SWIG_fail;
5451	<	argc = PyObject_Length(args);
5452	<	for (ii = 0; (ii < argc) && (ii < 3); ii++) {
5453	<	argv[ii] = PyTuple_GET_ITEM(args,ii);
5454	<	}
5455	<	if (argc == 2) {
5456	<	int _v;
5457	<	void *vptr = 0;
5458	<	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);
5445	>	static PyObject *_wrap_BossAdministratorSession_help(PyObject *self, PyObject *args) {
5446	>	PyObject *resultobj;
5447	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5448	>	std::string result;
5449	>	PyObject * obj0 = 0 ;
5450	>
5451	>	if(!PyArg_ParseTuple(args,(char *)"O:BossAdministratorSession_help",&obj0)) goto fail;
5452	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5453	>	{
5454	>	try {
5455	>	result = (arg1)->help();
5456	>
5457	>	}catch (const std::exception& e) {
5458	>	SWIG_exception(SWIG_RuntimeError, e.what());
5459		}
23766	–	}
5460		}
5461	<	}
5462	<
5463	<	fail:
5464	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_SQL'");
5465	<	return NULL;
5461	>	{
5462	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5463	>	}
5464	>	return resultobj;
5465	>	fail:
5466	>	return NULL;
5467		}
5468
5469
5470	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_purge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5471	<	PyObject *resultobj = 0;
5472	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5473	<	std::string *arg2 = 0 ;
5474	<	std::string *arg3 = 0 ;
5475	<	std::string *arg4 = 0 ;
5476	<	std::string *arg5 = 0 ;
5477	<	int result;
5478	<	void *argp1 = 0 ;
5479	<	int res1 = 0 ;
5480	<	int res2 = SWIG_OLDOBJ ;
5481	<	int res3 = SWIG_OLDOBJ ;
5482	<	int res4 = SWIG_OLDOBJ ;
5483	<	int res5 = SWIG_OLDOBJ ;
5484	<	PyObject * obj0 = 0 ;
5485	<	PyObject * obj1 = 0 ;
5486	<	PyObject * obj2 = 0 ;
23793	<	PyObject * obj3 = 0 ;
23794	<	PyObject * obj4 = 0 ;
23795	<
23796	<	if (!PyArg_ParseTuple(args,(char *)"OOOOO:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23797	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
23798	<	if (!SWIG_IsOK(res1)) {
23799	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_purge" "', argument " "1"" of type '" "BossAdministratorSession *""'");
23800	<	}
23801	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
23802	<	{
23803	<	std::string *ptr = (std::string *)0;
23804	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
23805	<	if (!SWIG_IsOK(res2)) {
23806	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_purge" "', argument " "2"" of type '" "std::string const &""'");
23807	<	}
23808	<	if (!ptr) {
23809	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "2"" of type '" "std::string const &""'");
23810	<	}
23811	<	arg2 = ptr;
23812	<	}
23813	<	{
23814	<	std::string *ptr = (std::string *)0;
23815	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
23816	<	if (!SWIG_IsOK(res3)) {
23817	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossAdministratorSession_purge" "', argument " "3"" of type '" "std::string const &""'");
23818	<	}
23819	<	if (!ptr) {
23820	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "3"" of type '" "std::string const &""'");
23821	<	}
23822	<	arg3 = ptr;
23823	<	}
23824	<	{
23825	<	std::string *ptr = (std::string *)0;
23826	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
23827	<	if (!SWIG_IsOK(res4)) {
23828	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossAdministratorSession_purge" "', argument " "4"" of type '" "std::string const &""'");
5470	>	static PyObject *_wrap_BossAdministratorSession_SQL(PyObject *self, PyObject *args) {
5471	>	PyObject *resultobj;
5472	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5473	>	std::string arg2 ;
5474	>	bool arg3 = (bool) false ;
5475	>	std::string result;
5476	>	PyObject * obj0 = 0 ;
5477	>	PyObject * obj1 = 0 ;
5478	>	PyObject * obj2 = 0 ;
5479	>
5480	>	if(!PyArg_ParseTuple(args,(char *)"OO|O:BossAdministratorSession_SQL",&obj0,&obj1,&obj2)) goto fail;
5481	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5482	>	{
5483	>	if (PyString_Check(obj1))
5484	>	arg2 = std::string(PyString_AsString(obj1));
5485	>	else
5486	>	SWIG_exception(SWIG_TypeError, "string expected");
5487		}
5488	<	if (!ptr) {
5489	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "4"" of type '" "std::string const &""'");
5488	>	if (obj2) {
5489	>	arg3 = PyInt_AsLong(obj2) ? true : false;
5490	>	if (PyErr_Occurred()) SWIG_fail;
5491		}
5492	<	arg4 = ptr;
5493	<	}
5494	<	{
5495	<	std::string *ptr = (std::string *)0;
5496	<	res5 = SWIG_AsPtr_std_string(obj4, &ptr);
5497	<	if (!SWIG_IsOK(res5)) {
5498	<	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 &""'");
5492	>	{
5493	>	try {
5494	>	result = (arg1)->SQL(arg2,arg3);
5495	>
5496	>	}catch (const std::exception& e) {
5497	>	SWIG_exception(SWIG_RuntimeError, e.what());
5498	>	}
5499		}
5500	<	arg5 = ptr;
5501	<	}
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());
5500	>	{
5501	>	resultobj = PyString_FromStringAndSize((&result)->data(),(&result)->size());
5502		}
5503	<	}
5504	<	resultobj = SWIG_From_int(static_cast< int >(result));
5505	<	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;
5503	>	return resultobj;
5504	>	fail:
5505	>	return NULL;
5506		}
5507
5508
5509	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_purge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5510	<	PyObject *resultobj = 0;
5511	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5512	<	std::string *arg2 = 0 ;
5513	<	std::string *arg3 = 0 ;
5514	<	std::string *arg4 = 0 ;
5515	<	int result;
5516	<	void *argp1 = 0 ;
5517	<	int res1 = 0 ;
5518	<	int res2 = SWIG_OLDOBJ ;
5519	<	int res3 = SWIG_OLDOBJ ;
5520	<	int res4 = SWIG_OLDOBJ ;
5521	<	PyObject * obj0 = 0 ;
5522	<	PyObject * obj1 = 0 ;
5523	<	PyObject * obj2 = 0 ;
5524	<	PyObject * obj3 = 0 ;
5525	<
5526	<	if (!PyArg_ParseTuple(args,(char *)"OOOO:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5527	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5528	<	if (!SWIG_IsOK(res1)) {
5529	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_purge" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5530	<	}
5531	<	arg1 = reinterpret_cast< BossAdministratorSession * >(argp1);
5532	<	{
5533	<	std::string *ptr = (std::string *)0;
5534	<	res2 = SWIG_AsPtr_std_string(obj1, &ptr);
5535	<	if (!SWIG_IsOK(res2)) {
5536	<	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BossAdministratorSession_purge" "', argument " "2"" of type '" "std::string const &""'");
23896	<	}
23897	<	if (!ptr) {
23898	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "2"" of type '" "std::string const &""'");
23899	<	}
23900	<	arg2 = ptr;
23901	<	}
23902	<	{
23903	<	std::string *ptr = (std::string *)0;
23904	<	res3 = SWIG_AsPtr_std_string(obj2, &ptr);
23905	<	if (!SWIG_IsOK(res3)) {
23906	<	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BossAdministratorSession_purge" "', argument " "3"" of type '" "std::string const &""'");
23907	<	}
23908	<	if (!ptr) {
23909	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "3"" of type '" "std::string const &""'");
23910	<	}
23911	<	arg3 = ptr;
23912	<	}
23913	<	{
23914	<	std::string *ptr = (std::string *)0;
23915	<	res4 = SWIG_AsPtr_std_string(obj3, &ptr);
23916	<	if (!SWIG_IsOK(res4)) {
23917	<	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BossAdministratorSession_purge" "', argument " "4"" of type '" "std::string const &""'");
23918	<	}
23919	<	if (!ptr) {
23920	<	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BossAdministratorSession_purge" "', argument " "4"" of type '" "std::string const &""'");
5509	>	static PyObject *_wrap_BossAdministratorSession_purge(PyObject *self, PyObject *args) {
5510	>	PyObject *resultobj;
5511	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5512	>	std::string *arg2 = 0 ;
5513	>	std::string *arg3 = 0 ;
5514	>	std::string *arg4 = 0 ;
5515	>	std::string const &arg5_defvalue = "0" ;
5516	>	std::string *arg5 = (std::string *) &arg5_defvalue ;
5517	>	int result;
5518	>	std::string temp2 ;
5519	>	std::string temp3 ;
5520	>	std::string temp4 ;
5521	>	std::string temp5 ;
5522	>	PyObject * obj0 = 0 ;
5523	>	PyObject * obj1 = 0 ;
5524	>	PyObject * obj2 = 0 ;
5525	>	PyObject * obj3 = 0 ;
5526	>	PyObject * obj4 = 0 ;
5527	>
5528	>	if(!PyArg_ParseTuple(args,(char *)"OOOO|O:BossAdministratorSession_purge",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5529	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5530	>	{
5531	>	if (PyString_Check(obj1)) {
5532	>	temp2 = std::string(PyString_AsString(obj1));
5533	>	arg2 = &temp2;
5534	>	}else {
5535	>	SWIG_exception(SWIG_TypeError, "string expected");
5536	>	}
5537		}
5538	<	arg4 = ptr;
5539	<	}
5540	<	{
5541	<	try {
5542	<	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
5543	<	} catch (const std::exception& e) {
5544	<	SWIG_exception(SWIG_RuntimeError, e.what());
5538	>	{
5539	>	if (PyString_Check(obj2)) {
5540	>	temp3 = std::string(PyString_AsString(obj2));
5541	>	arg3 = &temp3;
5542	>	}else {
5543	>	SWIG_exception(SWIG_TypeError, "string expected");
5544	>	}
5545		}
5546	<	}
5547	<	resultobj = SWIG_From_int(static_cast< int >(result));
5548	<	if (SWIG_IsNewObj(res2)) delete arg2;
5549	<	if (SWIG_IsNewObj(res3)) delete arg3;
5550	<	if (SWIG_IsNewObj(res4)) delete arg4;
5551	<	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	<	}
5546	>	{
5547	>	if (PyString_Check(obj3)) {
5548	>	temp4 = std::string(PyString_AsString(obj3));
5549	>	arg4 = &temp4;
5550	>	}else {
5551	>	SWIG_exception(SWIG_TypeError, "string expected");
5552		}
23972	–	}
5553		}
5554	<	}
5555	<	if (argc == 5) {
5556	<	int _v;
5557	<	void *vptr = 0;
5558	<	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_BossAdministratorSession, 0);
5559	<	_v = SWIG_CheckState(res);
5560	<	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);
5554	>	if (obj4) {
5555	>	{
5556	>	if (PyString_Check(obj4)) {
5557	>	temp5 = std::string(PyString_AsString(obj4));
5558	>	arg5 = &temp5;
5559	>	}else {
5560	>	SWIG_exception(SWIG_TypeError, "string expected");
5561		}
23995	–	}
5562		}
23997	–	}
5563		}
5564	<	}
5565	<
5566	<	fail:
5567	<	SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'BossAdministratorSession_purge'");
5568	<	return NULL;
5564	>	{
5565	>	try {
5566	>	result = (int)(arg1)->purge((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
5567	>
5568	>	}catch (const std::exception& e) {
5569	>	SWIG_exception(SWIG_RuntimeError, e.what());
5570	>	}
5571	>	}
5572	>	resultobj = PyInt_FromLong((long)result);
5573	>	return resultobj;
5574	>	fail:
5575	>	return NULL;
5576		}
5577
5578
5579	<	SWIGINTERN PyObject *_wrap_BossAdministratorSession_configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5580	<	PyObject *resultobj = 0;
5581	<	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5582	<	std::string arg2 ;
5583	<	int result;
5584	<	void *argp1 = 0 ;
5585	<	int res1 = 0 ;
5586	<	PyObject * obj0 = 0 ;
5587	<	PyObject * obj1 = 0 ;
5588	<
5589	<	if (!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_configure",&obj0,&obj1)) SWIG_fail;
5590	<	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BossAdministratorSession, 0 |  0 );
5591	<	if (!SWIG_IsOK(res1)) {
5592	<	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BossAdministratorSession_configure" "', argument " "1"" of type '" "BossAdministratorSession *""'");
5593	<	}
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""'");
5579	>	static PyObject *_wrap_BossAdministratorSession_registerPlugins(PyObject *self, PyObject *args) {
5580	>	PyObject *resultobj;
5581	>	BossAdministratorSession *arg1 = (BossAdministratorSession *) 0 ;
5582	>	std::string arg2 ;
5583	>	int result;
5584	>	PyObject * obj0 = 0 ;
5585	>	PyObject * obj1 = 0 ;
5586	>
5587	>	if(!PyArg_ParseTuple(args,(char *)"OO:BossAdministratorSession_registerPlugins",&obj0,&obj1)) goto fail;
5588	>	if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_BossAdministratorSession,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
5589	>	{
5590	>	if (PyString_Check(obj1))
5591	>	arg2 = std::string(PyString_AsString(obj1));
5592	>	else
5593	>	SWIG_exception(SWIG_TypeError, "string expected");
5594		}
5595	<	arg2 = *ptr;
5596	<	if (SWIG_IsNewObj(res)) delete ptr;
5597	<	}
5598	<	{
5599	<	try {
5600	<	result = (int)(arg1)->configure(arg2);
5601	<	} catch (const std::exception& e) {
24036	<	SWIG_exception(SWIG_RuntimeError, e.what());
5595	>	{
5596	>	try {
5597	>	result = (int)(arg1)->registerPlugins(arg2);
5598	>
5599	>	}catch (const std::exception& e) {
5600	>	SWIG_exception(SWIG_RuntimeError, e.what());
5601	>	}
5602		}
5603	<	}
5604	<	resultobj = SWIG_From_int(static_cast< int >(result));
5605	<	return resultobj;
5606	<	fail:
24042	<	return NULL;
5603	>	resultobj = PyInt_FromLong((long)result);
5604	>	return resultobj;
5605	>	fail:
5606	>	return NULL;
5607		}
5608
5609
5610	<	SWIGINTERN PyObject *BossAdministratorSession_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5611	<	PyObject *obj;
5612	<	if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
5613	<	SWIG_TypeNewClientData(SWIGTYPE_p_BossAdministratorSession, SWIG_NewClientData(obj));
5614	<	return SWIG_Py_Void();
5610	>	static PyObject * BossAdministratorSession_swigregister(PyObject *self, PyObject *args) {
5611	>	PyObject *obj;
5612	>	if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5613	>	SWIG_TypeClientData(SWIGTYPE_p_BossAdministratorSession, obj);
5614	>	Py_INCREF(obj);
5615	>	return Py_BuildValue((char *)"");
5616		}
24052	–
5617		static PyMethodDef SwigMethods[] = {
5618	<	{ (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
5619	<	{ (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
5620	<	{ (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
5621	<	{ (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
5622	<	{ (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
5623	<	{ (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
5624	<	{ (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
5625	<	{ (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
5626	<	{ (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
5627	<	{ (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
5628	<	{ (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
5629	<	{ (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
5630	<	{ (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
5631	<	{ (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
5632	<	{ (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
5633	<	{ (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
5634	<	{ (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
5635	<	{ (char *)"objectMap_iterator", _wrap_objectMap_iterator, METH_VARARGS, NULL},
5636	<	{ (char *)"objectMap___nonzero__", _wrap_objectMap___nonzero__, METH_VARARGS, NULL},
5637	<	{ (char *)"objectMap___len__", _wrap_objectMap___len__, METH_VARARGS, NULL},
5638	<	{ (char *)"objectMap___getitem__", _wrap_objectMap___getitem__, METH_VARARGS, NULL},
5639	<	{ (char *)"objectMap___setitem__", _wrap_objectMap___setitem__, METH_VARARGS, NULL},
5640	<	{ (char *)"objectMap___delitem__", _wrap_objectMap___delitem__, METH_VARARGS, NULL},
5641	<	{ (char *)"objectMap_has_key", _wrap_objectMap_has_key, METH_VARARGS, NULL},
5642	<	{ (char *)"objectMap_keys", _wrap_objectMap_keys, METH_VARARGS, NULL},
5643	<	{ (char *)"objectMap_values", _wrap_objectMap_values, METH_VARARGS, NULL},
5644	<	{ (char *)"objectMap_items", _wrap_objectMap_items, METH_VARARGS, NULL},
5645	<	{ (char *)"objectMap___contains__", _wrap_objectMap___contains__, METH_VARARGS, NULL},
5646	<	{ (char *)"objectMap_key_iterator", _wrap_objectMap_key_iterator, METH_VARARGS, NULL},
5647	<	{ (char *)"objectMap_value_iterator", _wrap_objectMap_value_iterator, METH_VARARGS, NULL},
5648	<	{ (char *)"new_objectMap", _wrap_new_objectMap, METH_VARARGS, NULL},
5649	<	{ (char *)"objectMap_empty", _wrap_objectMap_empty, METH_VARARGS, NULL},
5650	<	{ (char *)"objectMap_size", _wrap_objectMap_size, METH_VARARGS, NULL},
5651	<	{ (char *)"objectMap_clear", _wrap_objectMap_clear, METH_VARARGS, NULL},
5652	<	{ (char *)"objectMap_swap", _wrap_objectMap_swap, METH_VARARGS, NULL},
5653	<	{ (char *)"objectMap_get_allocator", _wrap_objectMap_get_allocator, METH_VARARGS, NULL},
5654	<	{ (char *)"objectMap_begin", _wrap_objectMap_begin, METH_VARARGS, NULL},
5655	<	{ (char *)"objectMap_end", _wrap_objectMap_end, METH_VARARGS, NULL},
5656	<	{ (char *)"objectMap_rbegin", _wrap_objectMap_rbegin, METH_VARARGS, NULL},
5657	<	{ (char *)"objectMap_rend", _wrap_objectMap_rend, METH_VARARGS, NULL},
5658	<	{ (char *)"objectMap_count", _wrap_objectMap_count, METH_VARARGS, NULL},
5659	<	{ (char *)"objectMap_erase", _wrap_objectMap_erase, METH_VARARGS, NULL},
5660	<	{ (char *)"objectMap_find", _wrap_objectMap_find, METH_VARARGS, NULL},
5661	<	{ (char *)"objectMap_lower_bound", _wrap_objectMap_lower_bound, METH_VARARGS, NULL},
5662	<	{ (char *)"objectMap_upper_bound", _wrap_objectMap_upper_bound, METH_VARARGS, NULL},
5663	<	{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS, NULL},
5664	<	{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS, NULL},
5665	<	{ (char *)"vector_string_iterator", _wrap_vector_string_iterator, METH_VARARGS, NULL},
5666	<	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS, NULL},
5667	<	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS, NULL},
5668	<	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS, NULL},
5669	<	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS, NULL},
5670	<	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS, NULL},
5671	<	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS, NULL},
5672	<	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS, NULL},
5673	<	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS, NULL},
5674	<	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS, NULL},
5675	<	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS, NULL},
5676	<	{ (char *)"vector_string_empty", _wrap_vector_string_empty, METH_VARARGS, NULL},
5677	<	{ (char *)"vector_string_size", _wrap_vector_string_size, METH_VARARGS, NULL},
5678	<	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS, NULL},
5679	<	{ (char *)"vector_string_swap", _wrap_vector_string_swap, METH_VARARGS, NULL},
5680	<	{ (char *)"vector_string_get_allocator", _wrap_vector_string_get_allocator, METH_VARARGS, NULL},
5681	<	{ (char *)"vector_string_begin", _wrap_vector_string_begin, METH_VARARGS, NULL},
5682	<	{ (char *)"vector_string_end", _wrap_vector_string_end, METH_VARARGS, NULL},
5683	<	{ (char *)"vector_string_rbegin", _wrap_vector_string_rbegin, METH_VARARGS, NULL},
5684	<	{ (char *)"vector_string_rend", _wrap_vector_string_rend, METH_VARARGS, NULL},
5685	<	{ (char *)"vector_string_pop_back", _wrap_vector_string_pop_back, METH_VARARGS, NULL},
5686	<	{ (char *)"vector_string_erase", _wrap_vector_string_erase, METH_VARARGS, NULL},
5687	<	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS, NULL},
5688	<	{ (char *)"vector_string_push_back", _wrap_vector_string_push_back, METH_VARARGS, NULL},
5689	<	{ (char *)"vector_string_front", _wrap_vector_string_front, METH_VARARGS, NULL},
5690	<	{ (char *)"vector_string_back", _wrap_vector_string_back, METH_VARARGS, NULL},
5691	<	{ (char *)"vector_string_assign", _wrap_vector_string_assign, METH_VARARGS, NULL},
5692	<	{ (char *)"vector_string_resize", _wrap_vector_string_resize, METH_VARARGS, NULL},
5693	<	{ (char *)"vector_string_insert", _wrap_vector_string_insert, METH_VARARGS, NULL},
5694	<	{ (char *)"vector_string_reserve", _wrap_vector_string_reserve, METH_VARARGS, NULL},
5695	<	{ (char *)"vector_string_capacity", _wrap_vector_string_capacity, METH_VARARGS, NULL},
5696	<	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS, NULL},
5697	<	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS, NULL},
5698	<	{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS, NULL},
5699	<	{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS, NULL},
5700	<	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS, NULL},
5701	<	{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS, NULL},
5702	<	{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS, NULL},
5703	<	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS, NULL},
5704	<	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS, NULL},
5705	<	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS, NULL},
5706	<	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS, NULL},
5707	<	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS, NULL},
5708	<	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS, NULL},
5709	<	{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS, NULL},
5710	<	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS, NULL},
5711	<	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS, NULL},
5712	<	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS, NULL},
5713	<	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS, NULL},
5714	<	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS, NULL},
5715	<	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS, NULL},
5716	<	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS, NULL},
5717	<	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS, NULL},
5718	<	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS, NULL},
5719	<	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS, NULL},
5720	<	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS, NULL},
5721	<	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS, NULL},
5722	<	{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS, NULL},
5723	<	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS, NULL},
5724	<	{ (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 }
5618	>	{ (char *)"new_objectMap", _wrap_new_objectMap, METH_VARARGS },
5619	>	{ (char *)"objectMap___len__", _wrap_objectMap___len__, METH_VARARGS },
5620	>	{ (char *)"objectMap_clear", _wrap_objectMap_clear, METH_VARARGS },
5621	>	{ (char *)"objectMap___nonzero__", _wrap_objectMap___nonzero__, METH_VARARGS },
5622	>	{ (char *)"objectMap___getitem__", _wrap_objectMap___getitem__, METH_VARARGS },
5623	>	{ (char *)"objectMap___setitem__", _wrap_objectMap___setitem__, METH_VARARGS },
5624	>	{ (char *)"objectMap___delitem__", _wrap_objectMap___delitem__, METH_VARARGS },
5625	>	{ (char *)"objectMap_has_key", _wrap_objectMap_has_key, METH_VARARGS },
5626	>	{ (char *)"objectMap_keys", _wrap_objectMap_keys, METH_VARARGS },
5627	>	{ (char *)"objectMap_values", _wrap_objectMap_values, METH_VARARGS },
5628	>	{ (char *)"objectMap_items", _wrap_objectMap_items, METH_VARARGS },
5629	>	{ (char *)"objectMap___contains__", _wrap_objectMap___contains__, METH_VARARGS },
5630	>	{ (char *)"objectMap___iter__", _wrap_objectMap___iter__, METH_VARARGS },
5631	>	{ (char *)"delete_objectMap", _wrap_delete_objectMap, METH_VARARGS },
5632	>	{ (char *)"objectMap_swigregister", objectMap_swigregister, METH_VARARGS },
5633	>	{ (char *)"new_vector_string", _wrap_new_vector_string, METH_VARARGS },
5634	>	{ (char *)"vector_string___len__", _wrap_vector_string___len__, METH_VARARGS },
5635	>	{ (char *)"vector_string___nonzero__", _wrap_vector_string___nonzero__, METH_VARARGS },
5636	>	{ (char *)"vector_string_clear", _wrap_vector_string_clear, METH_VARARGS },
5637	>	{ (char *)"vector_string_append", _wrap_vector_string_append, METH_VARARGS },
5638	>	{ (char *)"vector_string_pop", _wrap_vector_string_pop, METH_VARARGS },
5639	>	{ (char *)"vector_string___getitem__", _wrap_vector_string___getitem__, METH_VARARGS },
5640	>	{ (char *)"vector_string___getslice__", _wrap_vector_string___getslice__, METH_VARARGS },
5641	>	{ (char *)"vector_string___setitem__", _wrap_vector_string___setitem__, METH_VARARGS },
5642	>	{ (char *)"vector_string___setslice__", _wrap_vector_string___setslice__, METH_VARARGS },
5643	>	{ (char *)"vector_string___delitem__", _wrap_vector_string___delitem__, METH_VARARGS },
5644	>	{ (char *)"vector_string___delslice__", _wrap_vector_string___delslice__, METH_VARARGS },
5645	>	{ (char *)"delete_vector_string", _wrap_delete_vector_string, METH_VARARGS },
5646	>	{ (char *)"vector_string_swigregister", vector_string_swigregister, METH_VARARGS },
5647	>	{ (char *)"BossSession_show", _wrap_BossSession_show, METH_VARARGS },
5648	>	{ (char *)"BossSession_CHTools", _wrap_BossSession_CHTools, METH_VARARGS },
5649	>	{ (char *)"BossSession_ProgramTypes", _wrap_BossSession_ProgramTypes, METH_VARARGS },
5650	>	{ (char *)"BossSession_RTMons", _wrap_BossSession_RTMons, METH_VARARGS },
5651	>	{ (char *)"BossSession_schedulers", _wrap_BossSession_schedulers, METH_VARARGS },
5652	>	{ (char *)"BossSession_schedListMatch", _wrap_BossSession_schedListMatch, METH_VARARGS },
5653	>	{ (char *)"BossSession_queryTasks", _wrap_BossSession_queryTasks, METH_VARARGS },
5654	>	{ (char *)"new_BossSession", _wrap_new_BossSession, METH_VARARGS },
5655	>	{ (char *)"delete_BossSession", _wrap_delete_BossSession, METH_VARARGS },
5656	>	{ (char *)"BossSession_clear", _wrap_BossSession_clear, METH_VARARGS },
5657	>	{ (char *)"BossSession_makeBossTask", _wrap_BossSession_makeBossTask, METH_VARARGS },
5658	>	{ (char *)"BossSession_destroyBossTask", _wrap_BossSession_destroyBossTask, METH_VARARGS },
5659	>	{ (char *)"BossSession_defaultCHTool", _wrap_BossSession_defaultCHTool, METH_VARARGS },
5660	>	{ (char *)"BossSession_defaultProgramType", _wrap_BossSession_defaultProgramType, METH_VARARGS },
5661	>	{ (char *)"BossSession_defaultRTMon", _wrap_BossSession_defaultRTMon, METH_VARARGS },
5662	>	{ (char *)"BossSession_defaultScheduler", _wrap_BossSession_defaultScheduler, METH_VARARGS },
5663	>	{ (char *)"BossSession_version", _wrap_BossSession_version, METH_VARARGS },
5664	>	{ (char *)"BossSession_clientID", _wrap_BossSession_clientID, METH_VARARGS },
5665	>	{ (char *)"BossSession_showConfigs", _wrap_BossSession_showConfigs, METH_VARARGS },
5666	>	{ (char *)"BossSession_RTupdate", _wrap_BossSession_RTupdate, METH_VARARGS },
5667	>	{ (char *)"BossSession_listMatch", _wrap_BossSession_listMatch, METH_VARARGS },
5668	>	{ (char *)"BossSession_schedulerQuery", _wrap_BossSession_schedulerQuery, METH_VARARGS },
5669	>	{ (char *)"BossSession_selectTasks", _wrap_BossSession_selectTasks, METH_VARARGS },
5670	>	{ (char *)"BossSession_query", _wrap_BossSession_query, METH_VARARGS },
5671	>	{ (char *)"BossSession_swigregister", BossSession_swigregister, METH_VARARGS },
5672	>	{ (char *)"BossTaskException_key_set", _wrap_BossTaskException_key_set, METH_VARARGS },
5673	>	{ (char *)"BossTaskException_key_get", _wrap_BossTaskException_key_get, METH_VARARGS },
5674	>	{ (char *)"new_BossTaskException", _wrap_new_BossTaskException, METH_VARARGS },
5675	>	{ (char *)"BossTaskException_what", _wrap_BossTaskException_what, METH_VARARGS },
5676	>	{ (char *)"delete_BossTaskException", _wrap_delete_BossTaskException, METH_VARARGS },
5677	>	{ (char *)"BossTaskException_swigregister", BossTaskException_swigregister, METH_VARARGS },
5678	>	{ (char *)"BossTask_appendToPyDict", _wrap_BossTask_appendToPyDict, METH_VARARGS },
5679	>	{ (char *)"BossTask_jobDict", _wrap_BossTask_jobDict, METH_VARARGS },
5680	>	{ (char *)"BossTask_jobsDict", _wrap_BossTask_jobsDict, METH_VARARGS },
5681	>	{ (char *)"BossTask_progDict", _wrap_BossTask_progDict, METH_VARARGS },
5682	>	{ (char *)"BossTask_jobPrograms", _wrap_BossTask_jobPrograms, METH_VARARGS },
5683	>	{ (char *)"delete_BossTask", _wrap_delete_BossTask, METH_VARARGS },
5684	>	{ (char *)"new_BossTask", _wrap_new_BossTask, METH_VARARGS },
5685	>	{ (char *)"BossTask_id", _wrap_BossTask_id, METH_VARARGS },
5686	>	{ (char *)"BossTask_name", _wrap_BossTask_name, METH_VARARGS },
5687	>	{ (char *)"BossTask_taskMap", _wrap_BossTask_taskMap, METH_VARARGS },
5688	>	{ (char *)"BossTask_job_begin", _wrap_BossTask_job_begin, METH_VARARGS },
5689	>	{ (char *)"BossTask_job_end", _wrap_BossTask_job_end, METH_VARARGS },
5690	>	{ (char *)"BossTask_jobsMap", _wrap_BossTask_jobsMap, METH_VARARGS },
5691	>	{ (char *)"BossTask_jobMap", _wrap_BossTask_jobMap, METH_VARARGS },
5692	>	{ (char *)"BossTask_programsMap", _wrap_BossTask_programsMap, METH_VARARGS },
5693	>	{ (char *)"BossTask_queryJobPrograms", _wrap_BossTask_queryJobPrograms, METH_VARARGS },
5694	>	{ (char *)"BossTask_declare", _wrap_BossTask_declare, METH_VARARGS },
5695	>	{ (char *)"BossTask_remove", _wrap_BossTask_remove, METH_VARARGS },
5696	>	{ (char *)"BossTask_archive", _wrap_BossTask_archive, METH_VARARGS },
5697	>	{ (char *)"BossTask_submit", _wrap_BossTask_submit, METH_VARARGS },
5698	>	{ (char *)"BossTask_reSubmit", _wrap_BossTask_reSubmit, METH_VARARGS },
5699	>	{ (char *)"BossTask_kill", _wrap_BossTask_kill, METH_VARARGS },
5700	>	{ (char *)"BossTask_getOutput", _wrap_BossTask_getOutput, METH_VARARGS },
5701	>	{ (char *)"BossTask_getAllOutput", _wrap_BossTask_getAllOutput, METH_VARARGS },
5702	>	{ (char *)"BossTask_query", _wrap_BossTask_query, METH_VARARGS },
5703	>	{ (char *)"BossTask_query_out", _wrap_BossTask_query_out, METH_VARARGS },
5704	>	{ (char *)"BossTask_clear", _wrap_BossTask_clear, METH_VARARGS },
5705	>	{ (char *)"BossTask_swigregister", BossTask_swigregister, METH_VARARGS },
5706	>	{ (char *)"prompt", _wrap_prompt, METH_VARARGS },
5707	>	{ (char *)"new_BossAdministratorSession", _wrap_new_BossAdministratorSession, METH_VARARGS },
5708	>	{ (char *)"delete_BossAdministratorSession", _wrap_delete_BossAdministratorSession, METH_VARARGS },
5709	>	{ (char *)"BossAdministratorSession_configureDB", _wrap_BossAdministratorSession_configureDB, METH_VARARGS },
5710	>	{ (char *)"BossAdministratorSession_configureRTMonDB", _wrap_BossAdministratorSession_configureRTMonDB, METH_VARARGS },
5711	>	{ (char *)"BossAdministratorSession_deleteCHTool", _wrap_BossAdministratorSession_deleteCHTool, METH_VARARGS },
5712	>	{ (char *)"BossAdministratorSession_deleteProgramType", _wrap_BossAdministratorSession_deleteProgramType, METH_VARARGS },
5713	>	{ (char *)"BossAdministratorSession_deleteRTMon", _wrap_BossAdministratorSession_deleteRTMon, METH_VARARGS },
5714	>	{ (char *)"BossAdministratorSession_deleteScheduler", _wrap_BossAdministratorSession_deleteScheduler, METH_VARARGS },
5715	>	{ (char *)"BossAdministratorSession_registerCHTool", _wrap_BossAdministratorSession_registerCHTool, METH_VARARGS },
5716	>	{ (char *)"BossAdministratorSession_registerProgram", _wrap_BossAdministratorSession_registerProgram, METH_VARARGS },
5717	>	{ (char *)"BossAdministratorSession_registerRTMon", _wrap_BossAdministratorSession_registerRTMon, METH_VARARGS },
5718	>	{ (char *)"BossAdministratorSession_registerScheduler", _wrap_BossAdministratorSession_registerScheduler, METH_VARARGS },
5719	>	{ (char *)"BossAdministratorSession_help", _wrap_BossAdministratorSession_help, METH_VARARGS },
5720	>	{ (char *)"BossAdministratorSession_SQL", _wrap_BossAdministratorSession_SQL, METH_VARARGS },
5721	>	{ (char *)"BossAdministratorSession_purge", _wrap_BossAdministratorSession_purge, METH_VARARGS },
5722	>	{ (char *)"BossAdministratorSession_registerPlugins", _wrap_BossAdministratorSession_registerPlugins, METH_VARARGS },
5723	>	{ (char *)"BossAdministratorSession_swigregister", BossAdministratorSession_swigregister, METH_VARARGS },
5724	>	{ NULL, NULL }
5725		};
5726
5727
5728		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5729
5730	<	static void *_p_BossTaskExceptionTo_p_std__exception(void *x) {
5731	<	return (void *)((std::exception *)  ((BossTaskException *) x));
5732	<	}
5733	<	static swig_type_info _swigt__p_BossAdministratorSession = {"_p_BossAdministratorSession", "BossAdministratorSession *", 0, 0, (void*)0, 0};
5734	<	static swig_type_info _swigt__p_BossAttributeContainer = {"_p_BossAttributeContainer", "BossAttributeContainer *", 0, 0, (void*)0, 0};
5735	<	static swig_type_info _swigt__p_BossDatabase = {"_p_BossDatabase", "BossDatabase *", 0, 0, (void*)0, 0};
5736	<	static swig_type_info _swigt__p_BossJob = {"_p_BossJob", "BossJob *", 0, 0, (void*)0, 0};
5737	<	static swig_type_info _swigt__p_BossSession = {"_p_BossSession", "BossSession *", 0, 0, (void*)0, 0};
5738	<	static swig_type_info _swigt__p_BossTask = {"_p_BossTask", "BossTask *", 0, 0, (void*)0, 0};
5739	<	static swig_type_info _swigt__p_BossTaskException = {"_p_BossTaskException", "BossTaskException *", 0, 0, (void*)0, 0};
5740	<	static swig_type_info _swigt__p_XMLDoc = {"_p_XMLDoc", "XMLDoc *", 0, 0, (void*)0, 0};
5741	<	static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
5742	<	static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
5743	<	static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
5744	<	static swig_type_info _swigt__p_job_iterator = {"_p_job_iterator", "job_iterator *", 0, 0, (void*)0, 0};
5745	<	static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
5746	<	static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
5747	<	static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
5748	<	static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
5749	<	static swig_type_info _swigt__p_std__exception = {"_p_std__exception", "std::exception *", 0, 0, (void*)0, 0};
5750	<	static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
5751	<	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};
5752	<	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};
5753	<	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};
5754	<	static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
5755	<	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};
5756	<	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};
5757	<	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};
5758	<	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};
5759	<	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};
5760	<	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};
5761	<	static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
5762	<	static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
5763	<
5764	<	static swig_type_info *swig_type_initial[] = {
5765	<	&_swigt__p_BossAdministratorSession,
5766	<	&_swigt__p_BossAttributeContainer,
5767	<	&_swigt__p_BossDatabase,
5768	<	&_swigt__p_BossJob,
5769	<	&_swigt__p_BossSession,
5770	<	&_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,
5730	>	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}};
5731	>	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}};
5732	>	static swig_type_info _swigt__p_XMLDoc[] = {{"_p_XMLDoc", 0, "XMLDoc *", 0},{"_p_XMLDoc"},{0}};
5733	>	static swig_type_info _swigt__p_std__vectorTBossTask_p_t[] = {{"_p_std__vectorTBossTask_p_t", 0, "std::vector<BossTask * > *", 0},{"_p_std__vectorTBossTask_p_t"},{0}};
5734	>	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}};
5735	>	static swig_type_info _swigt__p_BossTask[] = {{"_p_BossTask", 0, "BossTask *", 0},{"_p_BossTask"},{0}};
5736	>	static swig_type_info _swigt__p_BossTaskException[] = {{"_p_BossTaskException", 0, "BossTaskException *", 0},{"_p_BossTaskException"},{0}};
5737	>	static swig_type_info _swigt__p_std__ostream[] = {{"_p_std__ostream", 0, "std::ostream *", 0},{"_p_std__ostream"},{0}};
5738	>	static swig_type_info _swigt__p_BossAttributeContainer[] = {{"_p_BossAttributeContainer", 0, "BossAttributeContainer *", 0},{"_p_BossAttributeContainer"},{0}};
5739	>	static swig_type_info _swigt__p_printOption[] = {{"_p_printOption", 0, "printOption const &", 0},{"_p_printOption"},{0}};
5740	>	static swig_type_info _swigt__p_BossJob[] = {{"_p_BossJob", 0, "BossJob *", 0},{"_p_BossJob"},{0}};
5741	>	static swig_type_info _swigt__p_BossDatabase[] = {{"_p_BossDatabase", 0, "BossDatabase *", 0},{"_p_BossDatabase"},{0}};
5742	>	static swig_type_info _swigt__p_BossSession[] = {{"_p_BossSession", 0, "BossSession *", 0},{"_p_BossSession"},{0}};
5743	>	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}};
5744	>	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}};
5745	>	static swig_type_info _swigt__p_BossAdministratorSession[] = {{"_p_BossAdministratorSession", 0, "BossAdministratorSession *", 0},{"_p_BossAdministratorSession"},{0}};
5746	>	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}};
5747	>	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}};
5748	>	static swig_type_info _swigt__p_jobStates[] = {{"_p_jobStates", 0, "jobStates const &", 0},{"_p_jobStates"},{0}};
5749	>
5750	>	static swig_type_info *swig_types_initial[] = {
5751	>	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t,
5752	>	_swigt__p_std__vectorTstd__pairTBossProgram_BossProgramExec_t_t__const_iterator,
5753	>	_swigt__p_XMLDoc,
5754	>	_swigt__p_std__vectorTBossTask_p_t,
5755	>	_swigt__p_std__mapTstd__string_std__mapTstd__string_std__string_t_t,
5756	>	_swigt__p_BossTask,
5757	>	_swigt__p_BossTaskException,
5758	>	_swigt__p_std__ostream,
5759	>	_swigt__p_BossAttributeContainer,
5760	>	_swigt__p_printOption,
5761	>	_swigt__p_BossJob,
5762	>	_swigt__p_BossDatabase,
5763	>	_swigt__p_BossSession,
5764	>	_swigt__p_std__vectorTstd__string_t,
5765	>	_swigt__p_std__mapTstd__string_std__string_t,
5766	>	_swigt__p_BossAdministratorSession,
5767	>	_swigt__p_BossTask__job_iterator,
5768	>	_swigt__p_std__vectorTBossJob_p_t__const_iterator,
5769	>	_swigt__p_jobStates,
5770	>	0
5771		};
5772
5773
5774		/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
5775
5776		static swig_const_info swig_const_table[] = {
5777	<	{0, 0, 0, 0.0, 0, 0}};
5777	>	{ SWIG_PY_INT,     (char *)"RUNNING", (long) RUNNING, 0, 0, 0},
5778	>	{ SWIG_PY_INT,     (char *)"SCHEDULED", (long) SCHEDULED, 0, 0, 0},
5779	>	{ SWIG_PY_INT,     (char *)"SUBMITTED", (long) SUBMITTED, 0, 0, 0},
5780	>	{ SWIG_PY_INT,     (char *)"ALL", (long) ALL, 0, 0, 0},
5781	>	{ SWIG_PY_INT,     (char *)"STATUS_ONLY", (long) STATUS_ONLY, 0, 0, 0},
5782	>	{ SWIG_PY_INT,     (char *)"NORMAL", (long) NORMAL, 0, 0, 0},
5783	>	{ SWIG_PY_INT,     (char *)"SPECIFIC", (long) SPECIFIC, 0, 0, 0},
5784	>	{ SWIG_PY_INT,     (char *)"PROGRAMS", (long) PROGRAMS, 0, 0, 0},
5785	>	{ SWIG_PY_INT,     (char *)"FULL", (long) FULL, 0, 0, 0},
5786	>	{0}};
5787
5788		#ifdef __cplusplus
5789		}
5790		#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	–	* ----------------------------------------------------------------------------- */
5791
5792		#ifdef __cplusplus
5793	<	extern "C" {
24400	<	#if 0
24401	<	} /* c-mode */
24402	<	#endif
24403	<	#endif
24404	<
24405	<	#if 0
24406	<	#define SWIGRUNTIME_DEBUG
24407	<	#endif
24408	<
24409	<	SWIGRUNTIME void
24410	<	SWIG_InitializeModule(void *clientdata) {
24411	<	size_t i;
24412	<	swig_module_info *module_head;
24413	<	static int init_run = 0;
24414	<
24415	<	clientdata = clientdata;
24416	<
24417	<	if (init_run) return;
24418	<	init_run = 1;
24419	<
24420	<	/* Initialize the swig_module */
24421	<	swig_module.type_initial = swig_type_initial;
24422	<	swig_module.cast_initial = swig_cast_initial;
24423	<
24424	<	/* Try and load any already created modules */
24425	<	module_head = SWIG_GetModule(clientdata);
24426	<	if (module_head) {
24427	<	swig_module.next = module_head->next;
24428	<	module_head->next = &swig_module;
24429	<	} else {
24430	<	/* This is the first module loaded */
24431	<	swig_module.next = &swig_module;
24432	<	SWIG_SetModule(clientdata, &swig_module);
24433	<	}
24434	<
24435	<	/* Now work on filling in swig_module.types */
24436	<	#ifdef SWIGRUNTIME_DEBUG
24437	<	printf("SWIG_InitializeModule: size %d\n", swig_module.size);
24438	<	#endif
24439	<	for (i = 0; i < swig_module.size; ++i) {
24440	<	swig_type_info *type = 0;
24441	<	swig_type_info *ret;
24442	<	swig_cast_info *cast;
24443	<
24444	<	#ifdef SWIGRUNTIME_DEBUG
24445	<	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
24446	<	#endif
24447	<
24448	<	/* if there is another module already loaded */
24449	<	if (swig_module.next != &swig_module) {
24450	<	type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
24451	<	}
24452	<	if (type) {
24453	<	/* Overwrite clientdata field */
24454	<	#ifdef SWIGRUNTIME_DEBUG
24455	<	printf("SWIG_InitializeModule: found type %s\n", type->name);
24456	<	#endif
24457	<	if (swig_module.type_initial[i]->clientdata) {
24458	<	type->clientdata = swig_module.type_initial[i]->clientdata;
24459	<	#ifdef SWIGRUNTIME_DEBUG
24460	<	printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
5793	>	extern "C"
5794		#endif
5795	<	}
5796	<	} else {
5797	<	type = swig_module.type_initial[i];
5798	<	}
5795	>	SWIGEXPORT(void) SWIG_init(void) {
5796	>	static PyObject *SWIG_globals = 0;
5797	>	static int       typeinit = 0;
5798	>	PyObject *m, *d;
5799	>	int       i;
5800	>	if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
5801	>	m = Py_InitModule((char *) SWIG_name, SwigMethods);
5802	>	d = PyModule_GetDict(m);
5803
5804	<	/* Insert casting types */
5805	<	cast = swig_module.cast_initial[i];
5806	<	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	<	}
5804	>	if (!typeinit) {
5805	>	for (i = 0; swig_types_initial[i]; i++) {
5806	>	swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
5807		}
5808	<	}
5808	>	typeinit = 1;
5809		}
5810	<	}
5811	<
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)));
5810	>	SWIG_InstallConstants(d,swig_const_table);
5811	>
5812		}
5813

Diff Legend

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